[med-svn] r17766 - in trunk/packages/mapsembler2/trunk/debian: . patches

Olivier Sallou osallou at moszumanska.debian.org
Mon Aug 18 16:24:08 UTC 2014


Author: osallou
Date: 2014-08-18 16:24:08 +0000 (Mon, 18 Aug 2014)
New Revision: 17766

Added:
   trunk/packages/mapsembler2/trunk/debian/patches/use_debian_libs
Modified:
   trunk/packages/mapsembler2/trunk/debian/control
   trunk/packages/mapsembler2/trunk/debian/copyright
   trunk/packages/mapsembler2/trunk/debian/docs
   trunk/packages/mapsembler2/trunk/debian/mapsembler2.install
   trunk/packages/mapsembler2/trunk/debian/mapsembler2.manpages
   trunk/packages/mapsembler2/trunk/debian/patches/series
   trunk/packages/mapsembler2/trunk/debian/rules
Log:
add patch ti use hdf5 from debian, add missing new deps, update binaries to install

Modified: trunk/packages/mapsembler2/trunk/debian/control
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/control	2014-08-18 15:30:32 UTC (rev 17765)
+++ trunk/packages/mapsembler2/trunk/debian/control	2014-08-18 16:24:08 UTC (rev 17766)
@@ -13,7 +13,7 @@
 Package: mapsembler2
 Architecture: any
 Depends: ${misc:Depends}, ${shlibs:Depends},
-         zlib1g, bc
+         zlib1g, bc, libhdf5-dev
 Description: bioinformatics targeted assembly software
  Mapsembler2 is a targeted assembly software.
  It takes as input a set of NGS raw reads (fasta or fastq, gzipped or not)

Modified: trunk/packages/mapsembler2/trunk/debian/copyright
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/copyright	2014-08-18 15:30:32 UTC (rev 17765)
+++ trunk/packages/mapsembler2/trunk/debian/copyright	2014-08-18 16:24:08 UTC (rev 17766)
@@ -4,505 +4,24 @@
 Files-Excluded:
     visu
     results_visualization
+    mapsembler2_extremities/thirdparty/gatb-core/thirdparty/boost
+    mapsembler2_extremities/thirdparty/gatb-core/thirdparty/hdf5
 
-License: CeCILL
- This Agreement is a free software license that is the result of  discussions
- between its authors  in  order  to  ensure  compliance  with  the  two  main
- principles guiding its drafting:
-   - firstly, its conformity with French law, both as  regards  the  law  of
-     torts and intellectual property law, and the protection that it offers
-     to authors and the holders of economic rights over software.
-   - secondly, compliance with the principles for the distribution  of  free
-     software: access to source codes, extended user-rights.
+Files: mapsembler2_extremities/thirdparty/gatb-core/thirdparty/emphf/*
+Copyright: 2013 Giuseppe Ottaviano <giuott at gmail.com>
+License: Apache v2.0
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
  .
- The following bodies are the authors of this license CeCILL (Ce : CEA, C :
- CNRS, I : INRIA, LL : Logiciel Libre):
+     http://www.apache.org/licenses/LICENSE-2.0
  .
- Commissariat à l'Energie Atomique - CEA, a public scientific, technical  and
- industrial establishment, having its principal place of  business  at  31-33
- rue de la Fédération, 75752 PARIS cedex 15, France.
- .
- Centre National de la Recherche Scientifique -  CNRS,  a  public  scientific
- and technological establishment, having its principal place of  business  at
- 3 rue Michel-Ange 75794 Paris cedex 16, France.
- .
- Institut National de Recherche en Informatique et en Automatique - INRIA,  a
- public scientific and  technological  establishment,  having  its  principal
- place of business at Domaine de Voluceau, Rocquencourt,  BP  105,  78153  Le
- Chesnay cedex.
- .
- .
- PREAMBLE
- --------
- .
- .
- The purpose of this Free Software Licensing Agreement is to grant users  the
- right to modify and redistribute  the  software  governed  by  this  license
- within the framework of an "open source" distribution model.
- .
- The exercising of these rights is conditional upon certain  obligations  for
- users  so  as  to  ensure  that  this  status  is  retained  for  subsequent
- redistribution operations.
- .
- As a counterpart to the access to the source code and rights to copy, modify
- and redistribute granted by the license,  users are provided only with  a
- limited warranty and  the software's author, the holder of the economic
- rights,  and  the  successive licensors only have limited liability.
- .
- In this respect, it is brought to the user's attention that the risks
- associated  with loading, using, modifying and/or developing or reproducing
- the  software  by the user given its nature of Free Software,  that  may  
- mean that it is complicated to manipulate, and that also therefore means 
- that it is reserved for developers and experienced professionals having
- in-depth computer knowledge. Users are therefore encouraged to load and test
- the Software's suitability  as  regards  their  requirements  in  conditions
- enabling  the security of their systems and/or data to be ensured and, more
- generally,  to use and operate  it  in  the  same  conditions  of security.
- This Agreement may be  freely  reproduced  and  published, provided  it  is
- not altered, and that no Articles are either added or removed herefrom. 
- .
- This Agreement may apply to any or all software for which the holder of  the
- economic rights decides to submit the operation thereof to its provisions.
- .
- .
- Article 1  - DEFINITIONS
- ------------------------
- .
- .
- For the purposes of this Agreement, when the following expressions  commence
- with a capital letter, they shall have the following meaning:
- .
- Agreement: means this Licensing Agreement, and any or all of its  subsequent
- versions.
- .
- Software: means the software in its Object  Code  and/or  Source  Code  form
- and, where applicable, its documentation, "as  is"  at  the  time  when  the
- Licensee accepts the Agreement.
- .
- Initial Software: means the Software in its Source Code and/or  Object  Code
- form and, where applicable, its documentation, "as is" at the time  when  it
- is distributed for the first time under the  terms  and  conditions  of  the
- Agreement.
- .
- Modified  Software:  means  the  Software   modified   by   at   least   one
- Contribution.
- .
- Source Code: means all the Software's  instructions  and  program  lines  to
- which access is required so as to modify the Software.
- .
- Object Code: means the binary files originating from the compilation of  the
- Source Code.
- .
- Holder: means  the  holder  of  the  economic  rights  over  the  Initial
- Software.
- .
- Licensee(s): mean(s) the Software user(s) having accepted the Agreement.
- .
- Contributor: means a Licensee having made at least one Contribution.
- .
- Licensor: means the Holder, or any or all other individual or legal  entity,
- that distributes the Software under the Agreement.
- .
- Contributions: mean any or  all  modifications,  corrections,  translations,
- adaptations and/or new functionalities integrated into the Software  by  any
- or all Contributor, and the Static Modules.
- .
- Module: means a set of sources files  including  their  documentation  that,
- once compiled in executable form, enables supplementary  functionalities  or
- services to be developed in addition to those offered by the Software.
- .
- Dynamic Module: means any or all module, created by  the  Contributor,  that
- is independent of the Software, so that this module and the Software are  in
- two different executable forms that are  run  in  separate  address  spaces,
- with one calling the other when they are run.
- .
- Static Module: means any or all  module,  created  by  the  Contributor  and
- connected to the Software by a static link that  makes  their  object  codes
- interdependent. This module and the Software to which it is  connected,  are
- combined in a single executable.
- .
- Parties: mean both the Licensee and the Licensor.
- .
- These expressions may be used both in singular and plural form.
- .
- .
- Article 2 - PURPOSE
- -------------------
- .
- .
- The purpose of the  Agreement  is  to  enable  the  Licensor  to  grant  the
- Licensee a free, non-exclusive, transferable and worldwide License  for  the
- Software as set forth in  Article  5  hereinafter  for  the  whole  term  of
- protection of the rights over said Software.
- .
- .
- Article 3 - ACCEPTANCE
- ----------------------
- .
- .
- 3.1. The  Licensee  shall  be  deemed  as  having  accepted  the  terms  and
- conditions of  this  Agreement  by  the  occurrence  of  the  first  of  the
- following events:
- - (i) loading the Software by any or all means, notably,  by  downloading
-   from a remote server, or by loading from a physical medium;
- - (ii) the first time the Licensee exercises any of  the  rights  granted
-   hereunder.
- .
- 3.2. One copy  of  the  Agreement,  containing  a  notice  relating  to  the
- specific nature of the  Software,  to  the  limited  warranty,  and  to  the
- limitation to use by experienced users has been  provided  to  the  Licensee
- prior to its acceptance as set forth in Article  3.1  hereinabove,  and  the
- Licensee hereby acknowledges that it is aware thereof.
- .
- .
- Article 4 - EFFECTIVE DATE AND TERM
- -----------------------------------
- .
- .
- 4.1. EFFECTIVE DATE
- .
- The Agreement shall become effective on the date when it is accepted by  the
- Licensee as set forth in Article 3.1.
- .
- 4.2. TERM
- .
- The Agreement  shall  remain  in  force  during  the  whole  legal  term  of
- protection of the economic rights over the Software.
- .
- .
- Article 5 - SCOPE OF THE RIGHTS GRANTED
- ---------------------------------------
- .
- .
- The  Licensor  hereby  grants  to  the  Licensee,  that  accepts  such,  the
- following rights as regards the Software for any or all  use,  and  for  the
- term of the Agreement, on the basis of the terms and  conditions  set  forth
- hereinafter.
- .
- Otherwise, the Licensor grants to the Licensee free of  charge  exploitation
- rights on  the  patents  he  holds  on  whole  or  part  of  the  inventions
- implemented in the Software.
- .
- 5.1. RIGHTS OF USE
- .
- The Licensee is authorized to use the Software, unrestrictedly,  as  regards
- the fields of application, with it being  hereinafter  specified  that  this
- relates to:
- - permanent or temporary reproduction of all or part of the Software  by
-   any or all means and in any or all form.
- - loading, displaying, running, or storing the Software on any or all
-   medium.
- - entitlement to observe, study or test the operation thereof so  as  to
-   establish the ideas and principles that form the basis for any or  all
-   constituent elements of said  Software.  This  shall  apply  when  the
-   Licensee  carries  out  any  or  all  loading,  displaying,   running,
-   transmission or storage operation as regards the Software, that it  is
-   entitled to carry out hereunder.
- .
- 5.2. entitlement to make CONTRIBUTIONS
- .
- The right to make Contributions includes  the  right  to  translate,  adapt,
- arrange, or make any or all modification to the Software, and the  right  to
- reproduce the resulting Software.
- .
- The Licensee is authorized to make any or all Contribution to  the  Software
- provided that it  explicitly  mentions  its  name  as  the  author  of  said
- Contribution and the date of the development thereof.
- .
- 5.3. DISTRIBUTION AND PUBLICATION RIGHTS
- .
- In particular, the right of distribution and publication includes the  right
- to transmit and communicate the Software to the general  public  on  any  or
- all medium, and by any or all means, and the  right  to  market,  either  in
- consideration of a fee, or free of charge, a  copy or copies of the Software 
- by means of any or all process.
- The Licensee is further authorized to redistribute copies  of  the  modified
- or  unmodified  Software  to  third  parties  according  to  the  terms  and
- conditions set forth hereinafter.
- .
- 5.3.1. REDISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION
- .
- The Licensee is authorized to redistribute true copies of  the  Software  in
- Source Code or Object Code form, provided that said redistribution  complies
- with all the provisions of the Agreement and is accompanied by:
- - a copy of the Agreement,
- - a notice relating to the limitation of both  the  Licensor's  warranty
-   and liability as set forth in Articles 8 and 9,
- and  that,  in  the  event  that  only  the  Software's   Object   Code   is
- redistributed, the Licensee allows future  Licensees  unhindered  access  to
- the Software's full Source  Code  by  providing  them  with  the  terms  and
- conditions for access thereto, it being understood that the additional  cost
- of acquiring the Source Code shall not exceed the cost of  transferring  the
- data.
- .
- 5.3.2. REDISTRIBUTION OF MODIFIED  SOFTWARE
- .
- When the Licensee makes a  Contribution  to  the  Software,  the  terms  and
- conditions for the redistribution of the Modified  Software  shall  then  be
- subject to all the provisions hereof.
- .
- The Licensee is authorized to redistribute the Modified Software, in  Source
- Code or Object Code form, provided that said  redistribution  complies  with
- all the provisions of the Agreement and is accompanied by:
- - a copy of the Agreement,
- - a notice relating to the limitation of both  the  Licensor's  warranty
-   and liability as set forth in Articles 8 and 9,
- and that, in the event that only the  Modified  Software's  Object  Code  is
- redistributed, the Licensee allows future  Licensees  unhindered  access  to
- the Modified Software's full Source Code by providing them  with  the  terms
- and conditions for access thereto, it being understood that  the  additional
- cost of acquiring the Source Code shall not exceed the cost of  transferring
- the data.
- .
- .
- 5.3.3. redistribution OF DYNAMIC MODULES
- .
- When the Licensee has developed a Dynamic Module, the terms  and  conditions
- hereof do not apply to said Dynamic Module, that  may  be  distributed under 
- a separate Licensing Agreement.
- .
- 5.3.4. COMPATIBILITY WITH THE GPL LICENSE
- .
- In the event that the Modified or unmodified Software is included in a code
- that is subject to the provisions of the GPL License, the Licensee is
- authorized to redistribute the whole under the GPL License.
- .
- In the event that the Modified Software includes a code that is  subject  to
- the  provisions  of  the  GPL  License,  the  Licensee  is   authorized   to
- redistribute the Modified Software under the GPL License.
- .
- .
- Article 6  - INTELLECTUAL PROPERTY
- ----------------------------------
- .
- .
- 6.1. OVER THE INITIAL SOFTWARE
- .
- The Holder owns the economic rights over the Initial Software.  Any  or  all
- use of the Initial Software is subject to  compliance  with  the  terms  and
- conditions under which the Holder has elected to distribute its work and  no
- one shall be entitled to  and it shall have sole entitlement to  modify  the
- terms and conditions for the distribution of said Initial Software.
- .
- The Holder undertakes to maintain the distribution of the  Initial  Software
- under the conditions of  the  Agreement,  for  the  duration  set  forth  in
- article 4.2..
- .
- 6.2. OVER THE CONTRIBUTIONS
- .
- The intellectual property rights over the Contributions belong to  the
- holder of the economic rights as designated by effective legislation.
- .
- 6.3. OVER THE DYNAMIC MODULES
- .
- The Licensee having  developed  a  Dynamic  Module  is  the  holder  of  the
- intellectual property rights over said Dynamic Module and is free to  choose
- the agreement that shall govern its distribution.
- .
- 6.4. JOINT PROVISIONS
- .
- 6.4.1. The Licensee expressly undertakes:
- - not to remove, or modify, in  any  or  all  manner,  the  intellectual
-   property notices affixed to the Software;
- - to reproduce said notices, in an identical manner, in  the  copies  of
-   the Software.
- .
- 6.4.2. The Licensee undertakes not to directly or  indirectly  infringe  the
- intellectual property rights of the Holder and/or Contributors and to  take,
- where applicable, vis-à-vis its staff,  any  or  all  measures  required  to
- ensure respect for said intellectual property rights of  the  Holder  and/or
- Contributors.
- .
- .
- Article 7  - RELATED SERVICES
- -----------------------------
- .
- .
- 7.1. Under no circumstances shall  the  Agreement  oblige  the  Licensor  to
- provide technical assistance or maintenance services for the Software.
- .
- However, the Licensor is entitled to offer  this  type  of  service. The
- terms  and  conditions  of  such  technical  assistance,  and/or   such 
- maintenance, shall then be set forth in  a  separate  instrument.  Only  the
- Licensor offering said  maintenance  and/or  technical  assistance  services
- shall incur liability therefor.
- .
- 7.2. Similarly, any or all Licensor  shall  be  entitled  to  offer  to  its
- Licensees, under its own responsibility, a  warranty,  that  shall  only  be
- binding upon itself, for the  redistribution  of  the  Software  and/or  the
- Modified Software, under terms and conditions  that  it  shall  decide  upon
- itself. Said warranty,  and  the  financial  terms  and  conditions  of  its
- application, shall be subject to a separate instrument executed between  the
- Licensor and the Licensee.
- .
- .
- Article 8  - LIABILITY
- ----------------------
- .
- .
- 8.1. Subject to the provisions of Article 8.2, should the Licensor  fail  to
- fulfill all or part of its obligations  hereunder,  the  Licensee  shall  be
- entitled to claim compensation for the direct loss suffered  as a result of
- a fault on the part of the Licensor, subject to providing evidence of it. 
- .
- 8.2. The Licensor's liability is limited to the commitments made under  this
- Licensing Agreement and shall not be incurred as a result ,  in  particular:
- (i) of loss due the Licensee's total  or  partial  failure  to  fulfill  its
- obligations, (ii) direct or consequential loss due to the Software's use  or
- performance that  is  suffered  by  the  Licensee,  when  the  latter  is  a
- professional  using  said  Software  for  professional  purposes  and  (iii)
- consequential loss due to the Software's use  or  performance.  The  Parties
- expressly agree that any or all pecuniary or business  loss  (i.e.  loss  of
- data, loss  of  profits,  operating  loss,  loss  of  customers  or  orders,
- opportunity cost, any disturbance to business  activities)  or  any  or  all
- legal proceedings instituted against the Licensee by a  third  party,  shall
- constitute consequential loss and shall not provide entitlement  to  any  or
- all compensation from the Licensor.
- .
- .
- Article 9  - WARRANTY
- ---------------------
- .
- .
- 9.1. The  Licensee  acknowledges  that  the  current  situation  as  regards
- scientific and  technical  know-how  at  the  time  when  the  Software  was
- distributed did not enable all possible uses to be tested and verified,  nor
- for the presence of any or all faults to be detected. In this  respect,  the
- Licensee's attention has been drawn to the risks  associated  with  loading,
- using, modifying and/or developing and reproducing  the  Software  that  are
- reserved for experienced users.
- .
- The Licensee shall be responsible for verifying, by any or  all  means,  the
- product's suitability for its requirements, its due and proper  functioning,
- and for ensuring that it  shall  not  cause  damage  to  either  persons  or
- property.
- .
- 9.2. The Licensor hereby represents, in good faith, that it is  entitled  to
- grant all the rights on the  Software (including in  particular  the  rights
- set forth in Article 5 hereof over the Software).
- .
- 9.3. The Licensee acknowledges that the Software is supplied "as is" by  the
- Licensor without any or all other express  or  tacit  warranty,  other  than
- that provided for in Article 9.2 and, in  particular,  without  any  or  all
- warranty as to its market  value,  its  secured,  innovative  or  relevant
- nature.
- .
- Specifically, the Licensor does not warrant that the Software is  free  from
- any or all error, that it shall  operate  continuously,  that  it  shall  be
- compatible  with   the   Licensee's   own   equipment   and   its   software
- configuration, nor that it shall meet the Licensee's requirements.
- .
- 9.4. The Licensor does not either expressly  or  tacitly  warrant  that  the
- Software does not  infringe  any  or  all  third  party  intellectual  right
- relating to a patent, software or  to  any  or  all  other  property  right.
- Moreover, the Licensor shall not hold the Licensee harmless against  any  or
- all proceedings for infringement that may be instituted in  respect  of  the
- use, modification and redistribution of the Software.  Nevertheless,  should
- such proceedings be instituted against  the  Licensee,  the  Licensor  shall
- provide it with  technical  and  legal  assistance  for  its  defense.  Such
- technical and legal assistance shall  be  decided  upon  on  a  case-by-case
- basis  between  the  relevant  Licensor  and  the  Licensee  pursuant  to  a
- memorandum of understanding. The Licensor disclaims any or all liability  as
- regards the Licensee's use of the Software's  name.  No  warranty  shall  be
- provided as regards the existence of prior  rights  over  the  name  of  the
- Software and as regards the existence of a trademark.
- .
- .
- Article 10  - TERMINATION
- -------------------------
- .
- .
- 10.1. In  the  event  of  a  breach  by  the  Licensee  of  its  obligations
- hereunder, the Licensor may automatically terminate  this  Agreement  thirty
- (30) days after notice has been  sent  to  the  Licensee  and  has  remained
- ineffective.
- .
- 10.2. The  Licensee  whose  Agreement  is  terminated  shall  no  longer  be
- authorized to use, modify or distribute the Software. However,  any  or  all
- licenses that it may have granted prior to  termination  of  the  Agreement
- shall remain valid subject to their having been granted in  compliance  with
- the terms and conditions hereof.
- .
- .
- Article 11  - MISCELLANEOUS PROVISIONS
- --------------------------------------
- .
- .
- 11.1. EXCUSABLE EVENTS
- .
- Neither Party shall be liable for any or all delay, or  failure  to  perform
- the Agreement, that may be attributable to an event  of  force  majeure,  an
- act of God or an outside cause, such as, notably, defective functioning,  or
- interruptions affecting  the  electricity  or  telecommunications  networks,
- blocking of the network following a virus attack, the  intervention  of  the
- government authorities, natural disasters, water damage, earthquakes,  fire,
- explosions, strikes and labor unrest, war, etc.
- .
- 11.2. The fact that either Party may fail, on one or several  occasions,  to
- invoke  one  or  several  of  the  provisions   hereof,   shall   under   no
- circumstances be interpreted as being a waiver by the  interested  Party  of
- its entitlement to invoke said provision(s) subsequently.
- .
- 11.3. The Agreement cancels and replaces  any  or  all  previous  agreement,
- whether written or oral, between the Parties and having  the  same  purpose,
- and  constitutes  the  entirety  of  the  agreement  between  said   Parties
- concerning said purpose. No supplement or  modification  to  the  terms  and
- conditions hereof shall be effective as regards the  Parties  unless  it  is
- made in writing and signed by their duly authorized representatives.
- .
- 11.4. In the event that one or several of  the  provisions  hereof  were  to
- conflict with a current or future applicable act or legislative  text,  said
- act or legislative text shall take precedence, and the  Parties  shall  make
- the necessary amendments so  as  to  be  in  compliance  with  said  act  or
- legislative  text.  All  the  other  provisions  shall   remain   effective.
- Similarly, the fact that a provision of  the  Agreement  may   be  null  and
- void, for any reason whatsoever, shall not cause the Agreement  as  a  whole
- to be null and void.
- .
- 11.5. LANGUAGE
- .
- The Agreement is drafted in both French and  English.  In  the  event  of  a
- conflict as  regards  construction,  the  French  version  shall  be  deemed
- authentic.
- .
- .
- Article 12  - NEW VERSIONS OF THE AGREEMENT
- -------------------------------------------
- .
- .
- 12.1. Any or all person is authorized to duplicate and distribute copies  of
- this Agreement.
- .
- 12.2. So as to ensure coherence, the wording of this Agreement is  protected
- and may only be modified by the authors of the  License,  that  reserve  the
- right to periodically publish updates or  new  versions  of  the  Agreement,
- each with a separate number. These subsequent versions may address new issues
- encountered by Free Software.
- .
- 12.3. Any  or  all  Software  distributed  under  a  given  version  of  the
- Agreement may only be subsequently distributed under  the  same  version  of
- the Agreement, or  a  subsequent  version,  subject  to  the  provisions  of
- article 5.3.4.
- .
- .
- Article 13 - GOVERNING LAW AND JURISDICTION
- -------------------------------------------
- .
- .
- 13.1. The Agreement is  governed  by  French  law.   The  Parties  agree  to
- endeavor to settle the disagreements or disputes that may arise  during  the
- performance of the Agreement out-of-court.
- .
- 13.2. In the absence of an out-of-court settlement within two (2) months  as
- from their occurrence, and unless emergency proceedings are  necessary,  the
- disagreements or disputes shall be  referred  to  the  Paris  Courts  having
- jurisdiction, by the first Party to take action.
- .
- .
+ 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.
 
-
-Files: maps/read_coherence_mapsembler/libchash.*
-       kissreads_g/read_coherence_mapsembler/libchash.*
+Files: kissreads_graph/read_coherence_mapsembler/libchash.*
 Copyright: 1998-2005 Google Inc.
 License: BSD
  All rights reserved.
@@ -540,7 +59,21 @@
 
 Files: *
 Copyright: 2013 INRIA / IRISA
-License: CeCILL
+License: AGPL-3+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ .
+ The complete text of the GNU Affero General Public License
+ can be found in the file `/usr/share/doc/mapsembler2/LICENCE.md.gz'.
 
 Files: debian/*
 Copyright: 2013 Olivier Sallou <osallou at debian.org>

Modified: trunk/packages/mapsembler2/trunk/debian/docs
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/docs	2014-08-18 15:30:32 UTC (rev 17765)
+++ trunk/packages/mapsembler2/trunk/debian/docs	2014-08-18 16:24:08 UTC (rev 17766)
@@ -1 +1 @@
-LICENSE.md
+LICENCE.md

Modified: trunk/packages/mapsembler2/trunk/debian/mapsembler2.install
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/mapsembler2.install	2014-08-18 15:30:32 UTC (rev 17765)
+++ trunk/packages/mapsembler2/trunk/debian/mapsembler2.install	2014-08-18 16:24:08 UTC (rev 17766)
@@ -1,2 +1,6 @@
-maps/mapsembler usr/bin/
-sample_example usr/share/doc/mapsembler2/
+#maps/mapsembler usr/bin/
+mapsembler2_extremities/build/mapsembler2_extremities  usr/bin/
+mapsembler2_extend/mapsembler_extend usr/bin/
+#sample_example usr/share/doc/mapsembler2/
+kissreads_graph/kissreads_graph usr/bin/
+kissreads/kissreads usr/bin/

Modified: trunk/packages/mapsembler2/trunk/debian/mapsembler2.manpages
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/mapsembler2.manpages	2014-08-18 15:30:32 UTC (rev 17765)
+++ trunk/packages/mapsembler2/trunk/debian/mapsembler2.manpages	2014-08-18 16:24:08 UTC (rev 17766)
@@ -1 +1,5 @@
-mapsembler.1
+mapsembler2_extremities.1
+mapsembler2_extend.1
+kissreads.1
+kissreads_graph.1
+

Modified: trunk/packages/mapsembler2/trunk/debian/patches/series
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/patches/series	2014-08-18 15:30:32 UTC (rev 17765)
+++ trunk/packages/mapsembler2/trunk/debian/patches/series	2014-08-18 16:24:08 UTC (rev 17766)
@@ -0,0 +1 @@
+use_debian_libs

Added: trunk/packages/mapsembler2/trunk/debian/patches/use_debian_libs
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/patches/use_debian_libs	                        (rev 0)
+++ trunk/packages/mapsembler2/trunk/debian/patches/use_debian_libs	2014-08-18 16:24:08 UTC (rev 17766)
@@ -0,0 +1,2292 @@
+Index: mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/thirdparty/CMakeLists.txt
+===================================================================
+--- mapsembler2_pipeline.orig/mapsembler2_extremities/thirdparty/gatb-core/thirdparty/CMakeLists.txt
++++ mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/thirdparty/CMakeLists.txt
+@@ -2,47 +2,6 @@
+ #  HDF5 GENERATION 
+ ################################################################################
+ 
+-SET (HDF5_ENABLE_THREADSAFE       ON)
+-
+-##########  MOMENTARY DEACTIVATED => CRASH ON MACOS TO BE INVESTIGATED  ##########
+-SET (HDF5_BUILD_TOOLS             ON CACHE BOOL "Build HDF5 Tools")
+-#SET (CMAKE_EXE_LINKER_FLAGS       "-lpthread -lz")
+-
+-SET (HDF5_EXTERNALLY_CONFIGURED     ON)
+-
+-#SET (HDF5_INSTALL_BIN_DIR           ${PROJECT_BINARY_DIR}/bin/${CMAKE_BUILD_TYPE})
+-#SET (HDF5_INSTALL_LIB_DIR           ${PROJECT_BINARY_DIR}/lib/${CMAKE_BUILD_TYPE})
+-SET (HDF5_INSTALL_BIN_DIR           bin)
+-SET (HDF5_INSTALL_LIB_DIR           lib)
+-
+-SET (HDF5_INSTALL_INCLUDE_DIR       ${PROJECT_BINARY_DIR}/include/${CMAKE_BUILD_TYPE}/hdf5)
+-SET (HDF5_INSTALL_DATA_DIR          ${PROJECT_BINARY_DIR}/share/${CMAKE_BUILD_TYPE})
+-SET (HDF5_INSTALL_CMAKE_DIR         ${PROJECT_BINARY_DIR}/share/${CMAKE_BUILD_TYPE})
+-
+-IF (NOT DEFINED GATB_CORE_INSTALL_EXCLUDE)
+-    SET (HDF5_EXPORTED_TARGETS          "gatb-hdf5")
+-ENDIF()
+-
+-# We don't want warnings from HDF5 compilation
+-set (COMPILE_DEFINITIONS  "${COMPILE_DEFINITIONS}  -w")
+-add_definitions (${COMPILE_DEFINITIONS})
+-
+-# add HDF5 generation
+-ADD_SUBDIRECTORY (hdf5)
+-
+-# We add a custom target for copying header files.
+-add_custom_target (hdf5_postbuild ALL)
+-
+-# We build the output directory
+-add_custom_command (TARGET hdf5_postbuild POST_BUILD  COMMAND ${CMAKE_COMMAND} -E make_directory ${HDF5_INSTALL_INCLUDE_DIR})
+-
+-# We define all the header files to be copied
+-file (GLOB headerfiles ${PROJECT_SOURCE_DIR}/thirdparty/hdf5/src/*.h ${PROJECT_BINARY_DIR}/thirdparty/hdf5/H5pubconf.h)
+-
+-# We copy each header file
+-foreach (header ${headerfiles})
+-  add_custom_command (TARGET hdf5_postbuild POST_BUILD  COMMAND ${CMAKE_COMMAND} -E copy_if_different ${header} ${HDF5_INSTALL_INCLUDE_DIR}  )
+-endforeach()
+ 
+ ################################################################################
+ #  EMPHF GENERATION 
+@@ -77,6 +36,5 @@ endforeach()
+ #  INSTALL 
+ ################################################################################
+ IF (NOT DEFINED GATB_CORE_INSTALL_EXCLUDE)
+-    INSTALL (DIRECTORY ${PROJECT_BINARY_DIR}/include/${CMAKE_BUILD_TYPE}/hdf5 DESTINATION include)
+     INSTALL (DIRECTORY ${PROJECT_BINARY_DIR}/include/${CMAKE_BUILD_TYPE}/emphf DESTINATION include)
+ ENDIF ()
+Index: mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/CMakeLists.txt
+===================================================================
+--- mapsembler2_pipeline.orig/mapsembler2_extremities/thirdparty/gatb-core/CMakeLists.txt
++++ mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/CMakeLists.txt
+@@ -173,7 +173,7 @@ ADD_SUBDIRECTORY(thirdparty)
+ #  DEPENDENCIES 
+ ################################################################################
+ # we must be sure that hdf5 is built and installed before building gatb-core
+-ADD_DEPENDENCIES (gatbcore-static hdf5 hdf5_postbuild emphf_copyasis)
++ADD_DEPENDENCIES (gatbcore-static hdf5 emphf_copyasis)
+ 
+ 
+ ################################################################################
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/LargeInt.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/LargeInt.hpp
++++ /dev/null
+@@ -1,547 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file LargeInt.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Class that manages large integers
+- *
+- * arbitrary-precision integer library
+- * very limited: only does what minia needs (but not what minia deserves)
+- * This file holds interfaces related to the Design Pattern Observer.
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_MATH_LARGEINT_HPP_
+-#define _GATB_CORE_TOOLS_MATH_LARGEINT_HPP_
+-
+-/********************************************************************************/
+-
+-#include <stdint.h>
+-#include <algorithm>
+-#include <iostream>
+-#include <hdf5/hdf5.h>
+-
+-#include <gatb/system/api/Exception.hpp>
+-#include <gatb/tools/math/NativeInt64.hpp>
+-
+-#ifndef ASSERTS
+-#define NDEBUG // disable asserts; those asserts make sure that with PRECISION == [1 or 2], all is correct
+-#endif
+-
+-#include <assert.h>
+-
+-// some 64-bit assert macros
+-#if defined(_LP64)
+-#define assert128(x) assert(precision != 2 || (x));
+-#else
+-#define assert128(x) ;
+-#endif
+-
+-extern const unsigned char revcomp_4NT[];
+-extern const unsigned char comp_NT    [];
+-
+-/********************************************************************************/
+-namespace gatb  {
+-namespace core  {
+-namespace tools {
+-/** \brief Math package */
+-namespace math  {
+-/********************************************************************************/
+-
+-/** \brief Large integer class
+- */
+-template<int precision>  class LargeInt : public misc::ArrayData<u_int64_t, precision>
+-{
+-public:
+-
+-    static const char* getName ()
+-    {
+-        static char buffer[256];
+-        static bool first = true;
+-        if (first)  {  first = false;  snprintf (buffer, sizeof(buffer), "LargeInt<%d>", precision);  }
+-        return buffer;
+-    }
+-
+-     u_int64_t getVal()  { return this->value[0]; }
+-    static const size_t getSize ()  { return 8*sizeof(u_int64_t)*precision; }
+-
+-    /********************************************************************************/
+-    /** Constructor.
+-     * \param[in] val : initial value of the large integer. */
+-    LargeInt(const u_int64_t& val = 0)
+-    {
+-        this->value[0] = val;   for (int i = 1; i < precision; i++)  {  this->value[i] = 0;  }
+-    }
+-
+-    /********************************************************************************/
+-    /** Returns lower 64 bits */
+-    u_int64_t toInt () const  {  throw system::Exception ("LargeInt<%d> no support of toInt", precision);  }
+-
+-    /********************************************************************************/
+-    LargeInt operator+ (const LargeInt& other) const
+-    {
+-        LargeInt result;
+-        int carry = 0;
+-        for (int i = 0 ; i < precision ; i++)
+-        {
+-            result.value[i] = this->value[i] + other.value[i] + carry;
+-            carry = (result.value[i] < this->value[i]) ? 1 : 0;
+-        }
+-
+-        assert    (precision != 1 || (result == other.value[0] + this->value[0]));
+-        assert128 (result.toInt128() == other.toInt128() + toInt128());
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt operator- (const LargeInt& other) const
+-    {
+-        LargeInt result;
+-        int carry = 0;
+-        for (int i = 0 ; i < precision ; i++)
+-        {
+-            result.value[i] = this->value[i] - other.value[i] - carry;
+-            carry = (result.value[i] > this->value[i]) ? 1 : 0;
+-        }
+-
+-        assert(precision != 1 || (result == this->value[0] - other.value[0]));
+-        assert128(result.toInt128() == toInt128() - other.toInt128());
+-        return result;
+-    }
+-
+-    
+-    
+-    /********************************************************************************/
+-    LargeInt operator*(const int& coeff) const
+-    {
+-        LargeInt result (*this);
+-        // minia doesn't have that many multiplications cases
+-
+-        if (coeff == 2 || coeff == 4)
+-        {
+-            result = result << (coeff / 2);
+-        }
+-        else
+-        {
+-            if (coeff == 21)
+-            {
+-                result = (result << 4) + (result << 2) + result;
+-            }
+-            else
+-            {
+-                printf("unsupported LargeInt multiplication: %d\n",coeff);
+-                exit(1);
+-            }
+-        }
+-
+-        assert(precision != 1 || (result == this->value[0] * coeff));
+-        assert128(result.toInt128() == toInt128() * coeff);
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt operator/(const uint32_t& divisor) const
+-    {
+-        LargeInt result;
+-        std::fill( result.value, result.value + precision, 0 );
+-
+-        // inspired by Divide32() from http://subversion.assembla.com/svn/pxcode/RakNet/Source/BigInt.cpp
+-
+-        u_int64_t r = 0;
+-        uint32_t mask32bits = ~0;
+-        for (int i = precision-1; i >= 0; --i)
+-        {
+-            for (int j = 1; j >= 0; --j) // [j=1: high-32 bits, j=0: low-32 bits] of array[i]
+-            {
+-                u_int64_t n = (r << 32) | ((this->value[i] >> (32*j)) & mask32bits );
+-                result.value[i] = result.value[i] | (((n / divisor) & mask32bits) << (32*j));
+-                r = n % divisor;
+-            }
+-        }
+-        assert(precision != 1 || (result == this->value[0] / divisor));
+-        assert128(result.toInt128() == toInt128() / divisor);
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    uint32_t operator%(const uint32_t& divisor) const
+-    {
+-        u_int64_t r = 0;
+-        uint32_t mask32bits = ~0;
+-        for (int i = precision-1; i >= 0; --i)
+-        {
+-            for (int j = 1; j >= 0; --j) // [j=1: high-32 bits, j=0: low-32 bits] of array[i]
+-            {
+-                u_int64_t n = (r << 32) | ((this->value[i] >> (32*j)) & mask32bits );
+-                r = n % divisor;
+-            }
+-        }
+-
+-        assert(precision != 1 || (r == this->value[0] % divisor));
+-        assert128(r == toInt128() % divisor);
+-        return (uint32_t)r;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt operator^(const LargeInt& other) const
+-    {
+-        LargeInt result;
+-        for (int i=0 ; i < precision ; i++)
+-            result.value[i] = this->value[i] ^ other.value[i];
+-
+-        assert(precision != 1 || (result == (this->value[0] ^ other.value[0])));
+-        assert128(result.toInt128() == (toInt128() ^ other.toInt128()));
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt operator|(const LargeInt& other) const
+-    {
+-        LargeInt result;
+-        for (int i=0 ; i < precision ; i++)
+-            result.value[i] = this->value[i] | other.value[i];
+-        
+-        assert(precision != 1 || (result == (this->value[0] | other.value[0])));
+-        assert128(result.toInt128() == (toInt128() | other.toInt128()));
+-        return result;
+-    }
+-    
+-    /********************************************************************************/
+-    LargeInt operator&(const LargeInt& other) const
+-    {
+-        LargeInt result;
+-        for (int i=0 ; i < precision ; i++)
+-            result.value[i] = this->value[i] & other.value[i];
+-
+-        assert(precision != 1 || (result == (this->value[0] & other.value[0])));
+-        assert128(result.toInt128() == (toInt128() & other.toInt128()));
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt operator&(const char& other) const
+-    {
+-        LargeInt result;
+-        result.value[0] = this->value[0] & other;
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt operator~() const
+-                    {
+-        LargeInt result;
+-        for (int i=0 ; i < precision ; i++)
+-            result.value[i] = ~this->value[i];
+-
+-        assert(precision != 1 || (result == ~this->value[0]));
+-        assert128(result.toInt128() == ~toInt128());
+-        return result;
+-                    }
+-
+-    /********************************************************************************/
+-    LargeInt operator<<(const int& coeff) const
+-    {
+-        LargeInt result (0);
+-
+-        int large_shift = coeff / 64;
+-        int small_shift = coeff % 64;
+-
+-        for (int i = large_shift ; i < precision-1; i++)
+-        {
+-            result.value[i] = result.value[i] | (this->value[i-large_shift] << small_shift);
+-
+-            if (small_shift == 0) // gcc "bug".. u_int64_t x; x>>64 == 1<<63, x<<64 == 1
+-            {
+-                result.value[i+1] = 0;
+-            }
+-            else
+-            {
+-                result.value[i+1] = this->value[i-large_shift] >> (64 - small_shift);
+-            }
+-
+-        }
+-        result.value[precision-1] = result.value[precision-1] | (this->value[precision-1-large_shift] << small_shift);
+-
+-        assert(precision != 1 || (result == (this->value[0] << coeff)));
+-        assert128(result.toInt128() == (toInt128() << coeff));
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt operator>>(const int& coeff) const
+-    {
+-        LargeInt result (0);
+-
+-        int large_shift = coeff / 64;
+-        int small_shift = coeff % 64;
+-
+-        result.value[0] = (this->value[large_shift] >> small_shift);
+-
+-        for (int i = 1 ; i < precision - large_shift ; i++)
+-        {
+-            result.value[i] = (this->value[i+large_shift] >> small_shift);
+-            if (small_shift == 0 && large_shift > 0) // gcc "bug".. u_int64_t x; x>>64 == 1<<63, x<<64 == 1
+-            {
+-                result.value[i-1] =  result.value[i-1];
+-            }
+-            else
+-            {
+-                result.value[i-1] =  result.value[i-1] | (this->value[i+large_shift] << (64 - small_shift));
+-            }
+-        }
+-
+-        assert(precision != 1 || ( small_shift == 0 || (result == this->value[0] >> coeff)));
+-        assert128(small_shift == 0 || (result.toInt128() == (toInt128() >> coeff)));
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    bool     operator!=(const LargeInt& c) const
+-                    {
+-        for (int i = 0 ; i < precision ; i++)
+-            if( this->value[i] != c.value[i] )
+-                return true;
+-        return false;
+-                    }
+-
+-    /********************************************************************************/
+-    bool operator==(const LargeInt& c) const
+-    {
+-        for (int i = 0 ; i < precision ; i++)
+-            if( this->value[i] != c.value[i] )
+-                return false;
+-        return true;
+-    }
+-
+-    /********************************************************************************/
+-    bool operator<(const LargeInt& c) const
+-    {
+-        for (int i = precision-1 ; i>=0 ; --i)
+-            if( this->value[i] != c.value[i] )
+-                return this->value[i] < c.value[i];
+-
+-        return false;
+-    }
+-
+-    /********************************************************************************/
+-    bool operator<=(const LargeInt& c) const
+-    {
+-        return operator==(c) || operator<(c);
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& operator+=  (const LargeInt& other)
+-    {
+-        // NOT so easy to optimize because of the carry
+-        *this = *this + other;
+-        return *this;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& operator^=  (const LargeInt& other)
+-    {
+-        for (int i=0 ; i < precision ; i++)  {  this->value[i] ^= other.value[i];  }
+-        return *this;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& operator&=  (const LargeInt& other)
+-    {
+-        for (int i=0 ; i < precision ; i++)  {  this->value[i] &= other.value[i];  }
+-        return *this;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& operator|=  (const LargeInt& other)
+-    {
+-        for (int i=0 ; i < precision ; i++)  {  this->value[i] |= other.value[i];  }
+-        return *this;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& operator<<=  (const int& coeff)
+-    {
+-        *(this) = (*this) << coeff;  return *this;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& operator>>=  (const int& coeff)
+-    {
+-        *(this) = (*this) >> coeff;  return *this;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& sync_fetch_and_or (const LargeInt& other)
+-    {
+-        for (int i=0 ; i < precision ; i++)  {  __sync_fetch_and_or (this->value + i, other.value[i]); }
+-        return *this;
+-    }
+-
+-    /********************************************************************************/
+-    LargeInt& sync_fetch_and_and (const LargeInt& other)
+-    {
+-        for (int i=0 ; i < precision ; i++)  {  __sync_fetch_and_and (this->value + i, other.value[i]); }
+-        return *this;
+-    }
+-
+-    /********************************************************************************/
+-    friend std::ostream & operator<<(std::ostream & s, const LargeInt<precision> & l)
+-    {
+-        int i=0;
+-
+-        /** We want to display the number in hexa (easier to do...) */
+-        s << std::hex;
+-
+-        /** We skip leading 0. */
+-        for (i=precision-1; i>=0 && l.value[i]==0; i--)  {}
+-
+-        /** We dump the different parts of the large integer. */
+-        for (  ; i>=0 ; i--)  { s << l.value[i];   if (i>=1) { s << ".";  }  }
+-
+-        /** We go back to decimal format. */
+-        s << std::dec;
+-
+-        /** We return the output stream. */
+-        return s;
+-    }
+-
+-    /********************************************************************************/
+-    inline static hid_t hdf5 (bool& isCompound)
+-    {
+-        hid_t result = H5Tcopy (H5T_NATIVE_INT);
+-        H5Tset_precision (result, 2*precision);
+-        return result;
+-    }
+-
+-    /********************************************************************************/
+-    template<typename Map>
+-    static LargeInt polynom (const char* data, size_t size, Map fct)
+-    {
+-        LargeInt res (0);
+-        for (size_t i=0; i<size; ++i)  {  res = res * 4 + fct(data[i]);  }
+-        return res;
+-    }
+-
+-    /********************************************************************************/
+-    /** Print corresponding kmer in ASCII
+-     * \param[in] sizeKmer : kmer size (def=32).
+-     */
+-    std::string toString (size_t sizeKmer) const
+-    {
+-        char seq[65];
+-        char bin2NT[4] = {'A','C','T','G'};
+-
+-        for (size_t i=0; i<sizeKmer; i++)  {  seq[sizeKmer-i-1] = bin2NT [(*this)[i]];  }
+-        seq[sizeKmer]='\0';
+-        return seq;
+-    }
+-
+-    /********************************************************************************/
+-    u_int8_t  operator[]  (size_t idx) const    {  return (this->value[0] >> (2*idx)) & 3; }
+-
+-private:
+-//    u_int64_t value[precision];
+-
+-    template<int T>  friend LargeInt<T> revcomp (const LargeInt<T>& i, size_t sizeKmer);
+-    template<int T>  friend u_int64_t   hash1    (const LargeInt<T>& key, u_int64_t  seed);
+-    template<int T>  friend u_int64_t   oahash  (const LargeInt<T>& key);
+-    template<int T>  friend u_int64_t   simplehash16    (const LargeInt<T>& key, int  shift);
+-
+-    // c++ fun fact:
+-    // "const" will ban the function from being anything which can attempt to alter any member variables in the object.
+-    // 2 months later: I don't understand this fun fact anymore. thanks c++.
+-};
+-
+-/********************************************************************************/
+-template<int precision>  inline LargeInt<precision> revcomp (const LargeInt<precision>& x, size_t sizeKmer)
+-{
+-    const LargeInt<precision> res = x;
+-
+-    unsigned char* kmerrev  = (unsigned char *) (&(res.value[0]));
+-    unsigned char* kmer     = (unsigned char *) (&(x.value[0]));
+-
+-    for (size_t i=0; i<8*precision; ++i)
+-    {
+-        kmerrev[8*precision-1-i] = revcomp_4NT [kmer[i]];
+-    }
+-
+-    return (res >> (2*( 32*precision - sizeKmer))  ) ;
+-}
+-
+-/********************************************************************************/
+-template<int precision>  inline u_int64_t hash1 (const LargeInt<precision>& elem, u_int64_t seed=0)
+-{
+-    // hash = XOR_of_series[hash(i-th chunk iof 64 bits)]
+-    u_int64_t result = 0, chunk, mask = ~0;
+-
+-    LargeInt<precision> intermediate = elem;
+-    for (size_t i=0;i<precision;i++)
+-    {
+-        chunk = (intermediate & mask).value[0];
+-        intermediate = intermediate >> 64;
+-
+-        result ^= NativeInt64::hash64 (chunk,seed);
+-    }
+-    return result;
+-}
+-
+-/********************************************************************************/
+-template<int precision>  u_int64_t oahash (const LargeInt<precision>& elem)
+-{
+-    // hash = XOR_of_series[hash(i-th chunk iof 64 bits)]
+-    u_int64_t result = 0, chunk, mask = ~0;
+-
+-    LargeInt<precision> intermediate = elem;
+-    for (size_t i=0;i<precision;i++)
+-    {
+-        chunk = (intermediate & mask).value[0];
+-        intermediate = intermediate >> 64;
+-        result ^= NativeInt64::oahash64 (chunk);
+-    }
+-    return result;
+-}
+-
+-/********************************************************************************/
+-template<int precision>  inline u_int64_t simplehash16 (const LargeInt<precision>& elem, int  shift)
+-{
+-    u_int64_t result = 0, chunk, mask = ~0;
+-    LargeInt<precision> intermediate = elem;
+-    
+-    chunk = (intermediate & mask).value[0];
+-    result ^= NativeInt64::simplehash16_64 (chunk,shift);
+-
+-    return result;
+-}
+-
+-
+-/********************************************************************************/
+-/********************     SPECIALIZATION FOR precision=1     ********************/
+-/********************************************************************************/
+-#include <gatb/tools/math/LargeInt1.pri>
+-
+-/********************************************************************************/
+-/********************     SPECIALIZATION FOR precision=2     ********************/
+-/********************************************************************************/
+-#include <gatb/tools/math/LargeInt2.pri>
+-
+-/********************************************************************************/
+-} } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_MATH_LARGEINT_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt128.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt128.hpp
++++ /dev/null
+@@ -1,224 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file NativeInt128.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Integer class relying on native 128 bits integer type
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_128_HPP_
+-#define _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_128_HPP_
+-
+-#include <gatb/system/api/config.hpp>
+-
+-/********************************************************************************/
+-#if  INT128_FOUND == 1
+-/********************************************************************************/
+-
+-#include <iostream>
+-#include <hdf5/hdf5.h>
+-
+-#include <gatb/system/api/types.hpp>
+-#include <gatb/tools/misc/api/Abundance.hpp>
+-#include <gatb/tools/math/NativeInt64.hpp>
+-
+-extern const unsigned char revcomp_4NT[];
+-extern const unsigned char comp_NT    [];
+-
+-/********************************************************************************/
+-namespace gatb  {
+-namespace core  {
+-namespace tools {
+-/** \brief Math package */
+-namespace math  {
+-/********************************************************************************/
+-
+-/** \brief Large integer class
+- */
+-class NativeInt128 : private misc::ArrayData<__uint128_t, 1>
+-{
+-public:
+-
+-    /** Constructor.
+-     * \param[in] c : initial value of the large integer. */
+-    NativeInt128 (const __uint128_t& c=0)  {  value[0] = c;  }
+-
+-    static const char* getName ()  { return "NativeInt128"; }
+-
+-    u_int64_t getVal ()  { return *value; }
+-
+-    static const size_t getSize ()  { return 8*sizeof(__uint128_t); }
+-
+-    NativeInt128 operator+  (const NativeInt128& other)     const   {  return value[0] + other.value[0];  }
+-    NativeInt128 operator-  (const NativeInt128& other)     const   {  return value[0] - other.value[0];  }
+-    NativeInt128 operator|  (const NativeInt128& other)     const   {  return value[0] | other.value[0];  }
+-    NativeInt128 operator*  (const int& coeff)              const   {  return value[0] * coeff;        }
+-    NativeInt128 operator/  (const u_int32_t& divisor)      const   {  return value[0] / divisor;      }
+-    u_int32_t    operator%  (const u_int32_t& divisor)      const   {  return value[0] % divisor;      }
+-    NativeInt128 operator^  (const NativeInt128& other)     const   {  return value[0] ^ other.value[0];  }
+-    NativeInt128 operator&  (const NativeInt128& other)     const   {  return value[0] & other.value[0];  }
+-    NativeInt128 operator&  (const char& other)             const   {  return value[0] & other;        }
+-    NativeInt128 operator~  ()                              const   {  return ~value[0];               }
+-    NativeInt128 operator<< (const int& coeff)              const   {  return value[0] << coeff;       }
+-    NativeInt128 operator>> (const int& coeff)              const   {  return value[0] >> coeff;       }
+-    bool         operator!= (const NativeInt128& c)         const   {  return value[0] != c.value[0];     }
+-    bool         operator== (const NativeInt128& c)         const   {  return value[0] == c.value[0];     }
+-    bool         operator<  (const NativeInt128& c)         const   {  return value[0] < c.value[0];      }
+-    bool         operator<= (const NativeInt128& c)         const   {  return value[0] <= c.value[0];     }
+-
+-    NativeInt128& operator+=  (const NativeInt128& other)    {  value[0] += other.value[0]; return *this; }
+-    NativeInt128& operator^=  (const NativeInt128& other)    {  value[0] ^= other.value[0]; return *this; }
+-    NativeInt128& operator&=  (const NativeInt128& other)    {  value[0] &= other.value[0]; return *this; }
+-    NativeInt128& operator|=  (const NativeInt128& other)    {  value[0] |= other.value[0]; return *this; }
+-    NativeInt128& operator<<= (const int& coeff)             {  value[0] <<= coeff;         return *this; }
+-    NativeInt128& operator>>= (const int& coeff)             {  value[0] >>= coeff;         return *this; }
+-
+-    /********************************************************************************/
+-    NativeInt128& sync_fetch_and_or (const NativeInt128& other)
+-    {
+-        for (int i=0 ; i < 2 ; i++)  {  __sync_fetch_and_or ((u_int64_t*)(value + i), other.value[i]); }
+-        return *this;
+-    }
+-
+-    /********************************************************************************/
+-    NativeInt128& sync_fetch_and_and (const NativeInt128& other)
+-    {
+-        for (int i=0 ; i < 2 ; i++)  {  __sync_fetch_and_and (this->value + i, other.value[i]); }
+-        return *this;
+-    }
+-
+-    /** Output stream overload. NOTE: for easier process, dump the value in hexadecimal.
+-     * \param[in] os : the output stream
+-     * \param[in] in : the integer value to be output.
+-     * \return the output stream.
+-     */
+-    friend std::ostream & operator<<(std::ostream & os, const NativeInt128 & in)
+-    {
+-        __uint128_t x = in.value[0];
+-
+-        u_int64_t high_nucl = (u_int64_t) (x>>64);
+-        u_int64_t low_nucl  = (u_int64_t)(x&((((__uint128_t)1)<<64)-1));
+-
+-        if (high_nucl == 0) {   os << std::hex <<                     low_nucl << std::dec;  }
+-        else                {   os << std::hex << high_nucl << "." << low_nucl << std::dec;  }
+-        return os;
+-    }
+-
+-    /********************************************************************************/
+-    
+-    /** Print corresponding kmer in ASCII
+-     * \param[sizeKmer] in : kmer size (def=64).
+-     */
+-    inline void printASCII ( size_t sizeKmer = 64)
+-    {
+-        int i;
+-        u_int64_t temp = value[0];
+-        
+-        
+-        char seq[65];
+-        char bin2NT[4] = {'A','C','T','G'};
+-        
+-        for (i=sizeKmer-1; i>=0; i--)
+-        {
+-            seq[i] = bin2NT[ temp&3 ];
+-            temp = temp>>2;
+-        }
+-        seq[sizeKmer]='\0';
+-        
+-        std::cout << seq << std::endl;
+-    }
+-    
+-    /********************************************************************************/
+-    inline static hid_t hdf5 (bool& isCompound)
+-    {
+-        hid_t result = H5Tcopy (H5T_NATIVE_INT);
+-        H5Tset_precision (result, 128);
+-        return result;
+-    }
+-    
+-private:
+-    friend NativeInt128 revcomp (const NativeInt128& i,   size_t sizeKmer);
+-    friend u_int64_t    hash1    (const NativeInt128& key, u_int64_t  seed);
+-    friend u_int64_t    oahash  (const NativeInt128& key);
+-    friend u_int64_t    simplehash16    (const NativeInt128& key, int  shift);
+-
+-};
+-
+-/********************************************************************************/
+-inline NativeInt128 revcomp (const NativeInt128& in, size_t sizeKmer)
+-{
+-    //                  ---64bits--   ---64bits--
+-    // original kmer: [__high_nucl__|__low_nucl___]
+-    //
+-    // ex:            [         AC  | .......TG   ]
+-    //
+-    //revcomp:        [         CA  | .......GT   ]
+-    //                 \_low_nucl__/\high_nucl/
+-
+-    const __uint128_t& x = in.value[0];
+-
+-    u_int64_t high_nucl = (u_int64_t)(x>>64);
+-    int nb_high_nucl = sizeKmer>32?sizeKmer - 32:0;
+-
+-    __uint128_t revcomp_high_nucl = NativeInt64::revcomp64 (high_nucl, nb_high_nucl);
+-
+-    if (sizeKmer<=32) revcomp_high_nucl = 0; // srsly dunno why this is needed. gcc bug? u_int64_t x ---> (x>>64) != 0
+-
+-    u_int64_t low_nucl = (u_int64_t)(x&((((__uint128_t)1)<<64)-1));
+-    int nb_low_nucl = sizeKmer>32?32:sizeKmer;
+-
+-    __uint128_t revcomp_low_nucl = NativeInt64::revcomp64 (low_nucl, nb_low_nucl);
+-
+-    return (revcomp_low_nucl<<(2*nb_high_nucl)) + revcomp_high_nucl;
+-}
+-
+-/********************************************************************************/
+-inline u_int64_t hash1 (const NativeInt128& item, u_int64_t seed=0)
+-{
+-    const __uint128_t& elem = item.value[0];
+-
+-    return NativeInt64::hash64 ((u_int64_t)(elem>>64),seed) ^
+-           NativeInt64::hash64 ((u_int64_t)(elem&((((__uint128_t)1)<<64)-1)),seed);
+-}
+-
+-/********************************************************************************/
+-inline u_int64_t oahash (const NativeInt128& item)
+-{
+-    const __uint128_t& elem = item.value[0];
+-
+-    return NativeInt64::oahash64 ((u_int64_t)(elem>>64)) ^
+-           NativeInt64::oahash64 ((u_int64_t)(elem&((((__uint128_t)1)<<64)-1)));
+-}
+-
+-/********************************************************************************/
+-inline u_int64_t simplehash16 (const NativeInt128& key, int  shift)
+-{
+-    return NativeInt64::simplehash16_64 ((u_int64_t)key.value[0], shift);
+-}
+-
+-/********************************************************************************/
+-} } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-/********************************************************************************/
+-#endif //INT128_FOUND
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_128_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt16.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt16.hpp
++++ /dev/null
+@@ -1,94 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file NativeInt16.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Integer class relying on native u_int16_t type
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_16_HPP_
+-#define _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_16_HPP_
+-
+-/********************************************************************************/
+-
+-#include <iostream>
+-#include <gatb/system/api/types.hpp>
+-#include <gatb/tools/misc/api/Abundance.hpp>
+-#include <hdf5/hdf5.h>
+-
+-/********************************************************************************/
+-namespace gatb  {
+-namespace core  {
+-namespace tools {
+-/** \brief Math package */
+-namespace math  {
+-/********************************************************************************/
+-
+-/** \brief Large integer class
+- */
+-class NativeInt16 : private misc::ArrayData<u_int16_t, 1>
+-{
+-public:
+-
+-    typedef ArrayData<u_int16_t, 1> POD;
+-
+-    /** Constructor.
+-     * \param[in] c : initial value of the large integer. */
+-    NativeInt16 (const u_int8_t& c=0)  {  value[0] = c;  }
+-
+-    static const char* getName ()  { return "NativeInt16"; }
+-
+-    static const size_t getSize ()  { return 8*sizeof(u_int16_t); }
+-
+-    NativeInt16 operator+  (const NativeInt16& other)   const   {  return value[0] + other.value[0];  }
+-    NativeInt16 operator-  (const NativeInt16& other)   const   {  return value[0] - other.value[0];  }
+-    NativeInt16 operator|  (const NativeInt16& other)   const   {  return value[0] | other.value[0];  }
+-    NativeInt16 operator^  (const NativeInt16& other)   const   {  return value[0] ^ other.value[0];  }
+-    NativeInt16 operator&  (const NativeInt16& other)   const   {  return value[0] & other.value[0];  }
+-    NativeInt16 operator&  (const char& other)          const   {  return value[0] & other;        }
+-    NativeInt16 operator~  ()                           const   {  return ~value[0];               }
+-    NativeInt16 operator<< (const int& coeff)           const   {  return value[0] << coeff;       }
+-    NativeInt16 operator>> (const int& coeff)           const   {  return value[0] >> coeff;       }
+-    bool        operator!= (const NativeInt16& c)       const   {  return value[0] != c.value[0];     }
+-    bool        operator== (const NativeInt16& c)       const   {  return value[0] == c.value[0];     }
+-    bool        operator<  (const NativeInt16& c)       const   {  return value[0] < c.value[0];      }
+-    bool        operator<= (const NativeInt16& c)       const   {  return value[0] <= c.value[0];     }
+-    bool        operator>= (const NativeInt16& c)       const   {  return value[0] >= c.value[0];     }
+-    NativeInt16& operator+=  (const NativeInt16& other)    {  value[0] += other.value[0]; return *this; }
+-    NativeInt16& operator^=  (const NativeInt16& other)    {  value[0] ^= other.value[0]; return *this; }
+-
+-    /********************************************************************************/
+-    friend std::ostream & operator<<(std::ostream & s, const NativeInt16 & l)
+-    {
+-        s << std::hex << l.value[0] << std::dec;  return s;
+-    }
+-
+-    /********************************************************************************/
+-    inline static hid_t hdf5 (bool& isCompound)
+-    {
+-        return H5Tcopy (H5T_NATIVE_UINT16);
+-    }
+-};
+-
+-/********************************************************************************/
+-} } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_16_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt64.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt64.hpp
++++ /dev/null
+@@ -1,248 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file NativeInt64.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Integer class relying on native u_int64_t type
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_64_HPP_
+-#define _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_64_HPP_
+-
+-/********************************************************************************/
+-
+-#include <iostream>
+-#include <gatb/system/api/types.hpp>
+-#include <gatb/tools/misc/api/Abundance.hpp>
+-#include <hdf5/hdf5.h>
+-
+-extern const unsigned char revcomp_4NT[];
+-extern const unsigned char comp_NT    [];
+-extern const u_int64_t random_values    [256];
+-
+-/********************************************************************************/
+-namespace gatb  {
+-namespace core  {
+-namespace tools {
+-/** \brief Math package */
+-namespace math  {
+-/********************************************************************************/
+-
+-/** \brief Large integer class
+- */
+-class NativeInt64 : private misc::ArrayData<u_int64_t, 1>
+-{
+-public:
+-
+-    /** Constructor.
+-     * \param[in] c : initial value of the large integer. */
+-    NativeInt64 (const u_int64_t& c=0)  {  value[0] = c;  }
+-
+-    static const char* getName ()  { return "NativeInt64"; }
+-
+-     u_int64_t getVal ()  { return *value; }
+-
+-    
+-    static const size_t getSize ()  { return 8*sizeof(u_int64_t); }
+-
+-    NativeInt64 operator+  (const NativeInt64& other)   const   {  return value[0] + other.value[0];  }
+-    NativeInt64 operator-  (const NativeInt64& other)   const   {  return value[0] - other.value[0];  }
+-    NativeInt64 operator|  (const NativeInt64& other)   const   {  return value[0] | other.value[0];  }
+-    NativeInt64 operator*  (const int& coeff)           const   {  return value[0] * coeff;        }
+-    NativeInt64 operator/  (const u_int32_t& divisor)   const   {  return value[0] / divisor;      }
+-    u_int32_t   operator%  (const u_int32_t& divisor)   const   {  return value[0] % divisor;      }
+-    NativeInt64 operator^  (const NativeInt64& other)   const   {  return value[0] ^ other.value[0];  }
+-    NativeInt64 operator&  (const NativeInt64& other)   const   {  return value[0] & other.value[0];  }
+-    NativeInt64 operator&  (const char& other)          const   {  return value[0] & other;        }
+-    NativeInt64 operator~  ()                           const   {  return ~value[0];               }
+-    NativeInt64 operator<< (const int& coeff)           const   {  return value[0] << coeff;       }
+-    NativeInt64 operator>> (const int& coeff)           const   {  return value[0] >> coeff;       }
+-    bool        operator!= (const NativeInt64& c)       const   {  return value[0] != c.value[0];     }
+-    bool        operator== (const NativeInt64& c)       const   {  return value[0] == c.value[0];     }
+-    bool        operator<  (const NativeInt64& c)       const   {  return value[0] < c.value[0];      }
+-    bool        operator<= (const NativeInt64& c)       const   {  return value[0] <= c.value[0];     }
+-
+-    NativeInt64& operator+=  (const NativeInt64& other)    {  value[0] += other.value[0]; return *this; }
+-    NativeInt64& operator^=  (const NativeInt64& other)    {  value[0] ^= other.value[0]; return *this; }
+-    NativeInt64& operator&=  (const NativeInt64& other)    {  value[0] &= other.value[0]; return *this; }
+-    NativeInt64& operator|=  (const NativeInt64& other)    {  value[0] |= other.value[0]; return *this; }
+-    NativeInt64& operator<<= (const int& coeff)            {  value[0] <<= coeff;         return *this; }
+-    NativeInt64& operator>>= (const int& coeff)            {  value[0] >>= coeff;         return *this; }
+-
+-    NativeInt64& sync_fetch_and_or  (const NativeInt64& other)  { __sync_fetch_and_or  (&(value[0]), other.value[0]); return *this; }
+-    NativeInt64& sync_fetch_and_and (const NativeInt64& other)  { __sync_fetch_and_and (&(value[0]), other.value[0]); return *this; }
+-
+-    u_int8_t  operator[]  (size_t idx)    {  return (value[0] >> (2*idx)) & 3; }
+-
+-    u_int64_t toInt () const  {  return value[0]; }
+-
+-    /********************************************************************************/
+-    friend std::ostream & operator<<(std::ostream & s, const NativeInt64 & l)
+-    {
+-        s << std::hex << l.value[0] << std::dec;  return s;
+-    }
+-    /********************************************************************************/
+-    /** Print corresponding kmer in ASCII
+-     * \param[in] sizeKmer : kmer size (def=32).
+-     */
+-    inline void printASCII ( size_t sizeKmer = 32)
+-    {
+-        int i;
+-        u_int64_t temp = value[0];
+-
+-        
+-        char seq[33];
+-        char bin2NT[4] = {'A','C','T','G'};
+-        
+-        for (i=sizeKmer-1; i>=0; i--)
+-        {
+-            seq[i] = bin2NT[ temp&3 ];
+-            temp = temp>>2;
+-        }
+-            seq[sizeKmer]='\0';
+-        
+-        std::cout << seq << std::endl;
+-    }
+-
+-    /********************************************************************************/
+-    /** Print corresponding kmer in ASCII
+-     * \param[in] sizeKmer : kmer size (def=32).
+-     */
+-    std::string toString (size_t sizeKmer) const
+-    {
+-        int i;
+-        u_int64_t temp = value[0];
+-
+-        char seq[33];
+-        char bin2NT[4] = {'A','C','T','G'};
+-
+-        for (i=sizeKmer-1; i>=0; i--)
+-        {
+-            seq[i] = bin2NT[ temp&3 ];
+-            temp = temp>>2;
+-        }
+-        seq[sizeKmer]='\0';
+-        return seq;
+-    }
+-
+-    
+-    /********************************************************************************/
+-    inline static u_int64_t revcomp64 (const u_int64_t& x, size_t sizeKmer)
+-    {
+-        u_int64_t res = x;
+-
+-        unsigned char* kmerrev  = (unsigned char *) (&(res));
+-        unsigned char* kmer     = (unsigned char *) (&(x));
+-
+-        for (size_t i=0; i<8; ++i)  {  kmerrev[8-1-i] = revcomp_4NT [kmer[i]];  }
+-
+-        return (res >> (2*( 32 - sizeKmer))) ;
+-    }
+-
+-    /********************************************************************************/
+-    inline static u_int64_t hash64 (u_int64_t key, u_int64_t seed)
+-    {
+-        u_int64_t hash = seed;
+-        hash ^= (hash <<  7) ^  key * (hash >> 3) ^ (~((hash << 11) + (key ^ (hash >> 5))));
+-        hash = (~hash) + (hash << 21); // hash = (hash << 21) - hash - 1;
+-        hash = hash ^ (hash >> 24);
+-        hash = (hash + (hash << 3)) + (hash << 8); // hash * 265
+-        hash = hash ^ (hash >> 14);
+-        hash = (hash + (hash << 2)) + (hash << 4); // hash * 21
+-        hash = hash ^ (hash >> 28);
+-        hash = hash + (hash << 31);
+-        return hash;
+-    }
+-
+-    /********************************************************************************/
+-    inline static u_int64_t oahash64 (u_int64_t elem)
+-    {
+-        u_int64_t code = elem;
+-        code = code ^ (code >> 14); //supp
+-        code = (~code) + (code << 18);
+-        code = code ^ (code >> 31);
+-        code = code * 21;
+-        code = code ^ (code >> 11);
+-        code = code + (code << 6);
+-        code = code ^ (code >> 22);
+-        return code;
+-    }
+-
+-    /********************************************************************************/
+-    /** computes a simple, naive hash using only 16 bits from input key
+-     * \param[in] key : key of the hash
+-     * \param[in] shift : selects which of the input byte will be used for hash computation
+-     */
+-    inline static  u_int64_t    simplehash16_64   (u_int64_t key, int  shift)
+-    {
+-        u_int64_t input = key >> shift;
+-        u_int64_t res = random_values[input & 255]   ;
+-        
+-        input = input  >> 8;
+-        res  ^= random_values[input & 255] ;
+-        
+-        return res;
+-        //could be improved by xor'ing result of multiple bytes
+-    }
+-
+-    /********************************************************************************/
+-    inline static hid_t hdf5 (bool& isCompound)
+-    {
+-        return H5Tcopy (H5T_NATIVE_UINT64);
+-    }
+-
+-private:
+-
+-    friend NativeInt64 revcomp (const NativeInt64& i,   size_t sizeKmer);
+-    friend u_int64_t    hash1    (const NativeInt64& key, u_int64_t  seed);
+-    friend u_int64_t    oahash  (const NativeInt64& key);
+-    friend u_int64_t    simplehash16    (const NativeInt64& key, int  shift);
+-
+-};
+-
+-/********************************************************************************/
+-inline NativeInt64 revcomp (const NativeInt64& x, size_t sizeKmer)
+-{
+-    return NativeInt64::revcomp64 (x.value[0], sizeKmer);
+-}
+-
+-/********************************************************************************/
+-inline u_int64_t hash1 (const NativeInt64& key, u_int64_t seed=0)
+-{
+-    return NativeInt64::hash64 (key.value[0], seed);
+-}
+-
+-/********************************************************************************/
+-inline u_int64_t oahash (const NativeInt64& key)
+-{
+-    return NativeInt64::oahash64 (key.value[0]);
+-}
+-    
+-/********************************************************************************/
+-inline u_int64_t simplehash16 (const NativeInt64& key, int  shift)
+-{
+-    return NativeInt64::simplehash16_64 (key.value[0], shift);
+-}
+-
+-/********************************************************************************/
+-} } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_64_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt8.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/math/NativeInt8.hpp
++++ /dev/null
+@@ -1,93 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file NativeInt8.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Integer class relying on native u_int8_t type
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_8_HPP_
+-#define _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_8_HPP_
+-
+-/********************************************************************************/
+-
+-#include <iostream>
+-#include <gatb/system/api/types.hpp>
+-#include <gatb/tools/misc/api/Abundance.hpp>
+-#include <hdf5/hdf5.h>
+-
+-/********************************************************************************/
+-namespace gatb  {
+-namespace core  {
+-namespace tools {
+-/** \brief Math package */
+-namespace math  {
+-/********************************************************************************/
+-
+-/** \brief Large integer class
+- */
+-class NativeInt8 : private misc::ArrayData<u_int8_t, 1>
+-{
+-public:
+-
+-    /** Constructor.
+-     * \param[in] c : initial value of the large integer. */
+-    NativeInt8 (const u_int8_t& c=0)  {  value[0] = c;  }
+-
+-    static const char* getName ()  { return "NativeInt8"; }
+-
+-    static const size_t getSize ()  { return 8*sizeof(u_int8_t); }
+-
+-    operator char ()  const {  return (char) value[0];  }
+-
+-    NativeInt8 operator+  (const NativeInt8& other)   const   {  return value[0] + other.value[0];  }
+-    NativeInt8 operator-  (const NativeInt8& other)   const   {  return value[0] - other.value[0];  }
+-    NativeInt8 operator|  (const NativeInt8& other)   const   {  return value[0] | other.value[0];  }
+-    NativeInt8 operator^  (const NativeInt8& other)   const   {  return value[0] ^ other.value[0];  }
+-    NativeInt8 operator&  (const NativeInt8& other)   const   {  return value[0] & other.value[0];  }
+-    NativeInt8 operator&  (const char& other)          const   {  return value[0] & other;        }
+-    NativeInt8 operator~  ()                           const   {  return ~value[0];               }
+-    NativeInt8 operator<< (const int& coeff)           const   {  return value[0] << coeff;       }
+-    NativeInt8 operator>> (const int& coeff)           const   {  return value[0] >> coeff;       }
+-    bool        operator!= (const NativeInt8& c)       const   {  return value[0] != c.value[0];     }
+-    bool        operator== (const NativeInt8& c)       const   {  return value[0] == c.value[0];     }
+-    bool        operator<  (const NativeInt8& c)       const   {  return value[0] < c.value[0];      }
+-    bool        operator<= (const NativeInt8& c)       const   {  return value[0] <= c.value[0];     }
+-    NativeInt8& operator+=  (const NativeInt8& other)    {  value[0] += other.value[0]; return *this; }
+-    NativeInt8& operator^=  (const NativeInt8& other)    {  value[0] ^= other.value[0]; return *this; }
+-
+-    /********************************************************************************/
+-    friend std::ostream & operator<<(std::ostream & s, const NativeInt8 & l)
+-    {
+-        s << std::hex << l.value[0] << std::dec;  return s;
+-    }
+-
+-    /********************************************************************************/
+-    inline static hid_t hdf5 (bool& isCompound)
+-    {
+-        return H5Tcopy (H5T_NATIVE_UINT8);
+-    }
+-};
+-
+-/********************************************************************************/
+-} } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_MATH_INTEGER_NATIVE_8_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/storage/impl/CollectionHDF5.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/storage/impl/CollectionHDF5.hpp
++++ /dev/null
+@@ -1,466 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file CollectionHDF5.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Collection interface
+- *
+- *  This file holds interfaces related to the Collection interface
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_STORAGE_IMPL_COLLECTION_HDF5_HPP_
+-#define _GATB_CORE_TOOLS_STORAGE_IMPL_COLLECTION_HDF5_HPP_
+-
+-/********************************************************************************/
+-
+-#include <gatb/tools/collections/api/Collection.hpp>
+-#include <gatb/tools/collections/impl/BagFile.hpp>
+-#include <gatb/tools/collections/impl/IteratorFile.hpp>
+-#include <gatb/tools/collections/impl/CollectionAbstract.hpp>
+-#include <gatb/tools/designpattern/impl/IteratorHelpers.hpp>
+-#include <gatb/system/impl/System.hpp>
+-
+-#include <string>
+-#include <vector>
+-#include <stdarg.h>
+-#include <hdf5/hdf5.h>
+-
+-/********************************************************************************/
+-namespace gatb      {
+-namespace core      {
+-namespace tools     {
+-namespace storage   {
+-namespace impl      {
+-/********************************************************************************/
+-
+-template <class Item> class BagHDF5 : public collections::Bag<Item>, public system::SmartPointer
+-{
+-public:
+-
+-    /** */
+-    BagHDF5 (hid_t datasetId, hid_t typeId, u_int64_t& nbItems, system::ISynchronizer* synchro)
+-        : _datasetId(datasetId), _typeId(typeId), _nbInserted(0), _nbItems(nbItems), _synchro(synchro)
+-    {
+-    }
+-
+-    /** Insert an item into the bag.
+-     * \param[in] item : the item to be inserted. */
+-    void insert (const Item& item) {  insert (&item, 1);  }
+-
+-    void insert (const std::vector<Item>& items, size_t length=0)  {  insert (items.data(), length==0 ? items.size() : length); }
+-
+-    /** Insert items into the bag.
+-     * \param[in] items : items to be inserted. */
+-    void insert (const Item* items, size_t length)
+-    {
+-        if (items==0 || length==0)  { return; }
+-        
+-        herr_t status = 0;
+-
+-        system::LocalSynchronizer localsynchro (_synchro);
+-
+-        /** Resize the memory dataspace to indicate the new size of our buffer. */
+-        hsize_t memDim = length;
+-        hid_t memspaceId = H5Screate_simple (1, &memDim, NULL);
+-
+-        /** Extend dataset. */
+-        hsize_t newDim = _nbInserted + length;
+-        status = H5Dset_extent (_datasetId, &newDim);
+-        if (status != 0)  { std::cout << "err H5Dset_extent" << std::endl; }
+-
+-        /** Select hyperslab on file dataset. */
+-        hid_t filespaceId = H5Dget_space(_datasetId);
+-        hsize_t start = _nbInserted;
+-        hsize_t count = length;
+-        status = H5Sselect_hyperslab (filespaceId, H5S_SELECT_SET, &start, NULL, &count, NULL);
+-        if (status != 0)  { std::cout << "err H5Sselect_hyperslab" << std::endl; }
+-
+-        /** Append buffer to dataset */
+-        status = H5Dwrite (_datasetId, _typeId, memspaceId, filespaceId, H5P_DEFAULT, items);
+-        if (status != 0)  { std::cout << "err H5Dwrite" << std::endl; }
+-
+-        /** We increase the number of inserted items. */
+-        _nbInserted += length;
+-
+-        __sync_fetch_and_add (&_nbItems, length);
+-
+-        /** Close resources. */
+-        status = H5Sclose (filespaceId);
+-        status = H5Sclose (memspaceId);
+-        if (status != 0)  { std::cout << "err H5Sclose" << std::endl; }
+-
+-    }
+-
+-    /** */
+-    void flush ()  {}
+-
+-private:
+-
+-    hid_t     _datasetId;
+-    hid_t     _typeId;
+-    u_int64_t& _nbItems;
+-    u_int64_t _nbInserted;
+-    system::ISynchronizer* _synchro;
+-
+-};
+-
+-/********************************************************************************/
+-
+-template<typename Item> class HDF5Iterator;
+-
+-template <class Item> class IterableHDF5 : public collections::Iterable<Item>, public system::SmartPointer
+-{
+-public:
+-
+-    /** */
+-    IterableHDF5 (hid_t datasetId, hid_t typeId, u_int64_t& nbItems,     system::ISynchronizer* synchro)
+-        :  _datasetId(datasetId), _typeId(typeId), _nbItems(nbItems), _synchro(synchro)  {}
+-
+-    /** */
+-    ~IterableHDF5 ()  {}
+-
+-    /** */
+-    dp::Iterator<Item>* iterator ()  {  return new HDF5Iterator<Item> (this);  }
+-
+-    /** */
+-    int64_t getNbItems ()
+-    {
+-        return _nbItems;
+-    }
+-
+-    /** */
+-    int64_t estimateNbItems ()
+-    {
+-        return getNbItems();
+-    }
+-
+-    /** */
+-    Item* getItems (Item*& buffer)
+-    {
+-        retrieveCache (buffer, 0, getNbItems());
+-        return buffer;
+-    }
+-
+-
+-private:
+-
+-    hid_t _datasetId;
+-    hid_t _typeId;
+-    u_int64_t& _nbItems;
+-    system::ISynchronizer* _synchro;
+-
+-
+-    /** */
+-    u_int64_t retrieveCache (Item* data, hsize_t start, hsize_t count)
+-    {
+-        herr_t status = 0;
+-
+-        system::LocalSynchronizer localsynchro (_synchro);
+-
+-        hid_t memspaceId = H5Screate_simple (1, &count, NULL);
+-
+-        /** Select hyperslab on file dataset. */
+-        hid_t filespaceId = H5Dget_space(_datasetId);
+-        status = H5Sselect_hyperslab (filespaceId, H5S_SELECT_SET, &start, NULL, &count, NULL);
+-        if (status != 0)  { std::cout << "err H5Sselect_hyperslab" << std::endl; }
+-
+-        /** Read buffer from dataset */
+-        status = H5Dread (_datasetId, _typeId, memspaceId, filespaceId, H5P_DEFAULT, data);
+-        if (status != 0)  { std::cout << "err H5Dread" << std::endl; }
+-
+-        /** Close resources. */
+-        status = H5Sclose (filespaceId);
+-        status = H5Sclose (memspaceId);
+-        if (status != 0)  { std::cout << "err H5Sclose" << std::endl; }
+-
+-        return count;
+-    }
+-
+-    template<typename U>
+-    friend class HDF5Iterator;
+-};
+-
+-/********************************************************************************/
+-
+-/** */
+-template<typename Item>
+-class HDF5Iterator : public dp::Iterator<Item>
+-{
+-public:
+-
+-    /** */
+-    HDF5Iterator ()  : _ref(0), _blockSize(0),
+-         _data(0), _dataSize(0), _dataIdx(0), _isDone (true),
+-         _nbRead(0), _memspaceId(0), _total(0)
+-    {}
+-
+-    /** */
+-    HDF5Iterator (const HDF5Iterator& it)
+-    : _ref(it._ref), _blockSize(it._blockSize),
+-        _data(0), _dataSize(0), _dataIdx(0), _isDone (true),
+-        _nbRead(0), _memspaceId(0), _total(0)
+-    {
+-        _data = (Item*) malloc (_blockSize*sizeof(Item));
+-        memset (_data, 0, _blockSize*sizeof(Item));
+-        _total = _ref->_nbItems;
+-    }
+-
+-    /** */
+-    HDF5Iterator (IterableHDF5<Item>* ref, size_t blockSize=4096)
+-        : _ref(ref), _blockSize(blockSize),
+-          _data(0), _dataSize(0), _dataIdx(0), _isDone (true),
+-          _nbRead(0), _memspaceId(0), _total(0)
+-    {
+-        _data = (Item*) malloc (_blockSize*sizeof(Item));
+-        memset (_data, 0, _blockSize*sizeof(Item));
+-
+-        _total = _ref->_nbItems;
+-    }
+-
+-    HDF5Iterator& operator= (const HDF5Iterator& it)
+-    {
+-        if (this != &it)
+-        {
+-            _ref        = it._ref;
+-            _blockSize  = it._blockSize;
+-            _dataSize   = it._dataSize;
+-            _dataIdx    = it._dataIdx;
+-            _isDone     = it._isDone;
+-            _nbRead     = it._nbRead;
+-            _memspaceId = it._memspaceId;
+-            _total      = it._total;
+-
+-            if (_data)  { free (_data); }
+-            _data = (Item*) malloc (_blockSize*sizeof(Item));
+-            memcpy (_data, it._data, _blockSize*sizeof(Item));
+-        }
+-        return *this;
+-    }
+-
+-
+-    /** */
+-    ~HDF5Iterator()
+-    {
+-        if (_data)  { free (_data); }
+-    }
+-
+-    void first()
+-    {
+-        _nbRead   = 0;
+-        _dataIdx  = 0;
+-        _dataSize = retrieveNextCache();
+-        _isDone   = _dataIdx >= _dataSize;
+-
+-        if (!_isDone)  {  *this->_item = _data[_dataIdx];  }
+-    }
+-
+-    void next()
+-    {
+-        _dataIdx++;
+-        _isDone = _dataIdx >= _dataSize;
+-        if (!_isDone)  {  *this->_item = _data[_dataIdx];  }
+-        else
+-        {
+-            _dataIdx  = 0;
+-            _dataSize = retrieveNextCache();
+-            _isDone = _dataIdx >= _dataSize;
+-            if (!_isDone)  {  *this->_item = _data[_dataIdx];  }
+-        }
+-    }
+-
+-    bool isDone()
+-    {
+-        return _isDone;
+-    }
+-
+-    Item& item ()  { return *this->_item; }
+-
+-private:
+-    IterableHDF5<Item>* _ref;
+-    size_t        _blockSize;
+-
+-    Item*     _data;
+-    u_int64_t _dataSize;
+-    u_int64_t _dataIdx;
+-
+-    bool _isDone;
+-
+-    u_int64_t     _nbRead;
+-    u_int64_t     _total;
+-
+-    hid_t _memspaceId;
+-
+-    u_int64_t retrieveNextCache ()
+-    {
+-        if (_total <= _nbRead)  {  return 0;   }
+-        hsize_t nbToRead = std::min ((u_int64_t)_blockSize, _total - _nbRead);
+-
+-        _nbRead += _ref->retrieveCache (_data, _nbRead, nbToRead);
+-
+-        return nbToRead;
+-    }
+-};
+-
+-/********************************************************************************/
+-
+-/** \brief Collection interface
+- */
+-template <class Item> class CollectionHDF5 : public collections::impl::CollectionAbstract<Item>, public system::SmartPointer
+-{
+-public:
+-
+-    /** Constructor. */
+-    CollectionHDF5 (hid_t fileId, const std::string& filename, system::ISynchronizer* synchro)
+-        : collections::impl::CollectionAbstract<Item> (0,0), _datasetId(0), _typeId(0), _nbItems(0)
+-    {
+-        herr_t status;
+-
+-        system::LocalSynchronizer localsynchro (synchro);
+-
+-        /** We get the HDF5 type of the item. */
+-        bool isCompound=false;
+-        _typeId = Item().hdf5(isCompound);
+-
+-        /** We pack the type. */
+-        hid_t actualType = H5Tcopy (_typeId);
+-        //if (isCompound)  {  status = H5Tpack(actualType);  }
+-
+-        std::string actualName = filename;
+-
+-        /** We look whether the object exists or not. */
+-        htri_t doesExist = H5Lexists (fileId, actualName.c_str(), H5P_DEFAULT);
+-
+-        if (doesExist > 0)
+-        {
+-            _datasetId = H5Dopen2 (fileId, actualName.c_str(), H5P_DEFAULT);
+-
+-            hid_t filespaceId = H5Dget_space (_datasetId);
+-
+-            hsize_t dims;
+-            H5Sget_simple_extent_dims (filespaceId, &dims, NULL);
+-
+-            _nbItems = dims;
+-            status = H5Sclose (filespaceId);
+-        }
+-        else
+-        {
+-            /** We create the dataspace. */
+-            hsize_t dims      = 0;
+-            hsize_t maxdims   = H5S_UNLIMITED;
+-            hid_t dataspaceId = H5Screate_simple (1, &dims, &maxdims);
+-
+-            /* Modify dataset creation properties, i.e. enable chunking  */
+-            hsize_t chunk_dims = 4096;
+-            hid_t propId = H5Pcreate     (H5P_DATASET_CREATE);
+-            status       = H5Pset_layout (propId, H5D_CHUNKED);
+-            status       = H5Pset_chunk  (propId, 1, &chunk_dims);
+-
+-            /** We create the dataset. */
+-            _datasetId = H5Dcreate2 (fileId, filename.c_str(),  actualType, dataspaceId, H5P_DEFAULT, propId, H5P_DEFAULT);
+-
+-            /** Some cleanup. */
+-            H5Pclose (propId);
+-            H5Sclose (dataspaceId);
+-            H5Tclose (actualType);
+-        }
+-
+-        /** We create the bag and the iterable instances. */
+-        this->setBag      (new BagHDF5<Item>      (_datasetId, _typeId, _nbItems, synchro));
+-        this->setIterable (new IterableHDF5<Item> (_datasetId, _typeId, _nbItems, synchro));
+-
+-    }
+-
+-    /** Destructor. */
+-    virtual ~CollectionHDF5()
+-    {
+-        herr_t status;
+-        status = H5Dclose (_datasetId);
+-        status = H5Tclose (_typeId);
+-    }
+-
+-    /** \copydoc Collection::remove */
+-    void remove ()  {}
+-
+-    /** \copydoc Collection::addProperty */
+-    void addProperty (const std::string& key, const std::string value)
+-    {
+-        hid_t datatype = H5Tcopy (H5T_C_S1);  H5Tset_size (datatype, H5T_VARIABLE);
+-
+-        hsize_t dims = 1;
+-        hid_t space_id = H5Screate_simple (1, &dims, NULL);
+-
+-        /** We create the attribute. */
+-        hid_t attrId = H5Acreate2 (_datasetId, key.c_str(), datatype,  space_id, H5P_DEFAULT, H5P_DEFAULT);
+-
+-        /** We write the data. */
+-        const char* array[] = { value.c_str() };
+-        H5Awrite (attrId, datatype, &array);
+-
+-        /** We close resources. */
+-        H5Aclose (attrId);
+-        H5Tclose (datatype);
+-        H5Sclose (space_id);
+-    }
+-
+-    /** \copydoc Collection::getProperty */
+-    std::string getProperty (const std::string& key)
+-    {
+-        std::string result;
+-        herr_t status;
+-
+-        hid_t datatype = H5Tcopy (H5T_C_S1);  H5Tset_size (datatype, H5T_VARIABLE);
+-
+-        hid_t attrId = H5Aopen (_datasetId, key.c_str(), H5P_DEFAULT);
+-
+-        hid_t space_id = H5Aget_space (attrId);
+-
+-        hsize_t dims = 1;
+-        H5Sget_simple_extent_dims (space_id, &dims, NULL);
+-        char** rdata = (char **) malloc (dims * sizeof (char *));
+-
+-        status = H5Aread (attrId, datatype, rdata);
+-
+-        /** We set the result. */
+-        result.assign (rdata[0]);
+-
+-        /** We release buffers. */
+-        status = H5Dvlen_reclaim (datatype, space_id, H5P_DEFAULT, rdata);
+-        free (rdata);
+-
+-        /** We close resources. */
+-        H5Aclose (attrId);
+-        H5Tclose (datatype);
+-        H5Sclose (space_id);
+-
+-        return result;
+-    }
+-
+-private:
+-
+-    hid_t _datasetId;
+-    hid_t _typeId;
+-    u_int64_t _nbItems;
+-};
+-
+-/********************************************************************************/
+-} } } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_STORAGE_IMPL_COLLECTION_HDF5_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/storage/impl/StorageHDF5.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/storage/impl/StorageHDF5.hpp
++++ /dev/null
+@@ -1,301 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file StorageHDF5.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Collection interface
+- *
+- *  This file holds interfaces related to the Collection interface
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_STORAGE_IMPL_STORAGE_HDF5_HPP_
+-#define _GATB_CORE_TOOLS_STORAGE_IMPL_STORAGE_HDF5_HPP_
+-
+-/********************************************************************************/
+-
+-#include <gatb/tools/storage/impl/CollectionHDF5.hpp>
+-#include <gatb/system/impl/System.hpp>
+-#include <hdf5/hdf5.h>
+-#include <typeinfo>
+-
+-/********************************************************************************/
+-namespace gatb      {
+-namespace core      {
+-namespace tools     {
+-namespace storage   {
+-namespace impl      {
+-/********************************************************************************/
+-
+-class StorageHDF5Factory
+-{
+-public:
+-
+-    /** */
+-    static Storage* createStorage (const std::string& name, bool deleteIfExist, bool autoRemove)
+-    {
+-        return new StorageHDF5 (STORAGE_HDF5, name, deleteIfExist, autoRemove);
+-    }
+-
+-    /** */
+-    static bool exists (const std::string& name)
+-    {
+-        H5Eset_auto (0, NULL, NULL);
+-
+-        bool result = false;
+-        {
+-            hid_t id = H5Fopen (name.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
+-            if (id > 0)  {  H5Fclose(id);  result = true;  }
+-        }
+-        {
+-            hid_t id = H5Fopen ((name+".h5").c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
+-            if (id > 0)  {  H5Fclose(id);  result = true;  }
+-        }
+-        return result;
+-    }
+-
+-    /** */
+-    static Group* createGroup (ICell* parent, const std::string& name)
+-    {
+-        StorageHDF5* storage = dynamic_cast<StorageHDF5*> (ICell::getRoot (parent));
+-        assert (storage != 0);
+-
+-        return new GroupHDF5 (storage, parent, name);
+-    }
+-
+-    /** */
+-    template<typename Type>
+-    static Partition<Type>* createPartition (ICell* parent, const std::string& name, size_t nb)
+-    {
+-        StorageHDF5* storage = dynamic_cast<StorageHDF5*> (ICell::getRoot (parent));
+-        assert (storage != 0);
+-
+-        std::string actualName = parent->getFullId('/') + "/" + name;
+-
+-        /** We create the HDF5 group if needed. */
+-        htri_t doesExist = H5Lexists (storage->getId(), actualName.c_str(), H5P_DEFAULT);
+-        if (doesExist <= 0)
+-        {
+-            hid_t group = H5Gcreate (storage->getId(), actualName.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+-            H5Gclose (group);
+-        }
+-
+-        return new Partition<Type> (storage->getFactory(), parent, name, nb);
+-    }
+-
+-    /** */
+-    template<typename Type>
+-    static CollectionNode<Type>* createCollection (ICell* parent, const std::string& name, system::ISynchronizer* synchro)
+-    {
+-#if 1
+-        synchro = GlobalSynchro::singleton();
+-#endif
+-
+-        StorageHDF5* storage = dynamic_cast<StorageHDF5*> (ICell::getRoot (parent));
+-        assert (storage != 0);
+-
+-        std::string actualName = parent->getFullId('/') + "/" + name;
+-
+-        return new CollectionNode<Type> (storage->getFactory(), parent, name, new CollectionHDF5<Type>(storage->getId(), actualName, synchro));
+-    }
+-
+-private:
+-
+-    class GlobalSynchro
+-    {
+-    public:
+-        static system::ISynchronizer* singleton()
+-        {
+-            static GlobalSynchro instance;
+-            return instance.synchro;
+-        }
+-
+-    private:
+-        GlobalSynchro ()  { synchro = system::impl::System::thread().newSynchronizer(); }
+-        ~GlobalSynchro () { if (synchro)  { delete synchro; } }
+-        system::ISynchronizer* synchro;
+-    };
+-
+-    /************************************************************/
+-    class StorageHDF5 : public Storage
+-    {
+-    public:
+-        StorageHDF5 (StorageMode_e mode, const std::string& name, bool deleteIfExist, bool autoRemove)
+-            : Storage (mode, name, autoRemove), _fileId(0), _name(name)
+-        {
+-            if (deleteIfExist)  {  system::impl::System::file().remove (getActualName());  }
+-
+-            /** We test the actual name exists in filesystem. */
+-            bool exists = system::impl::System::file().doesExist(getActualName());
+-
+-            if (exists==true)
+-            {
+-                /** We open the existing file. */
+-                _fileId = H5Fopen (getActualName().c_str(), H5P_DEFAULT, H5P_DEFAULT);
+-            }
+-            else
+-            {
+-                /** We create a new file using default properties. */
+-                _fileId = H5Fcreate (getActualName().c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+-            }
+-        }
+-
+-        virtual ~StorageHDF5 ()
+-        {
+-            if (_autoRemove)  { remove(); }
+-            H5Fclose(_fileId);
+-        }
+-
+-        hid_t getId ()  { return _fileId; }
+-
+-        void remove ()
+-        {
+-            system::impl::System::file().remove (getActualName());
+-        }
+-
+-
+-    private:
+-        hid_t       _fileId;
+-        std::string _name;
+-        std::string _actualName;
+-
+-        /** */
+-        std::string getActualName ()
+-        {
+-            /** We set the actual name at first call. */
+-            if (_actualName.empty())
+-            {
+-                _actualName = _name;
+-                /** We check whether the given name has a ".h5" suffix. */
+-                if (_name.rfind(".h5") == std::string::npos)  {  _actualName += ".h5";  }
+-
+-            }
+-            return _actualName;
+-        }
+-
+-        /** */
+-        std::string getName       () const  { return _name;         }
+-
+-    };
+-
+-    /************************************************************/
+-    class GroupHDF5 : public Group
+-    {
+-    public:
+-        GroupHDF5 (StorageHDF5* storage, ICell* parent, const std::string& name)
+-        : Group(storage->getFactory(),parent,name), _groupId(0)
+-        {
+-            /** We may need to create the HDF5 group. Empty name means root group, which is constructed by default. */
+-            if (name.empty() == false)
+-            {
+-                std::string actualName = this->getFullId('/');
+-
+-                /** We create the HDF5 group if needed. */
+-                htri_t doesExist = H5Lexists (storage->getId(), actualName.c_str(), H5P_DEFAULT);
+-
+-                if (doesExist <= 0)
+-                {
+-                    _groupId = H5Gcreate (storage->getId(), actualName.c_str(), H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+-                }
+-                else
+-                {
+-                    _groupId = H5Gopen2 (storage->getId(), actualName.c_str(), H5P_DEFAULT);
+-                }
+-            }
+-            else
+-            {
+-                _groupId = H5Gopen2 (storage->getId(), "/", H5P_DEFAULT);
+-            }
+-        }
+-
+-        /** */
+-        ~GroupHDF5()
+-        {
+-            /** We release the group handle. */
+-            H5Gclose(_groupId);
+-        }
+-
+-        /** */
+-        void addProperty (const std::string& key, const std::string value)
+-        {
+-            hid_t datatype = H5Tcopy (H5T_C_S1);  H5Tset_size (datatype, H5T_VARIABLE);
+-
+-            hsize_t dims = 1;
+-            hid_t space_id = H5Screate_simple (1, &dims, NULL);
+-
+-            /** We create the attribute. */
+-            hid_t attrId = H5Acreate2 (_groupId, key.c_str(), datatype,  space_id, H5P_DEFAULT, H5P_DEFAULT);
+-            if (attrId >= 0)
+-            {
+-                /** We write the data. */
+-                const char* array[] = { value.c_str() };
+-                H5Awrite (attrId, datatype, &array);
+-
+-                /** We close resources. */
+-                H5Aclose (attrId);
+-                H5Tclose (datatype);
+-                H5Sclose (space_id);
+-            }
+-        }
+-
+-        /** */
+-        std::string getProperty (const std::string& key)
+-        {
+-            std::string result;
+-            herr_t status;
+-
+-            hid_t datatype = H5Tcopy (H5T_C_S1);  H5Tset_size (datatype, H5T_VARIABLE);
+-
+-            hid_t attrId = H5Aopen (_groupId, key.c_str(), H5P_DEFAULT);
+-            if (attrId >= 0)
+-            {
+-                hid_t space_id = H5Aget_space (attrId);
+-
+-                hsize_t dims = 1;
+-                H5Sget_simple_extent_dims (space_id, &dims, NULL);
+-                char** rdata = (char **) malloc (dims * sizeof (char *));
+-
+-                status = H5Aread (attrId, datatype, rdata);
+-
+-                /** We set the result. */
+-                result.assign (rdata[0]);
+-
+-                /** We release buffers. */
+-                status = H5Dvlen_reclaim (datatype, space_id, H5P_DEFAULT, rdata);
+-                free (rdata);
+-
+-                /** We close resources. */
+-                H5Aclose (attrId);
+-                H5Tclose (datatype);
+-                H5Sclose (space_id);
+-            }
+-
+-            return result;
+-        }
+-
+-    private:
+-        hid_t _groupId;
+-    };
+-};
+-
+-/********************************************************************************/
+-} } } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_STORAGE_IMPL_STORAGE_HDF5_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/misc/api/IHistogram.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/misc/api/IHistogram.hpp
++++ /dev/null
+@@ -1,104 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file IHistogram.hpp
+- *  \date 01/03/2013
+- *  \author edrezen
+- *  \brief Interface for histogram (something counting abundances).
+- */
+-
+-#ifndef _GATB_CORE_TOOLS_MISC_IHISTOGRAM_HPP_
+-#define _GATB_CORE_TOOLS_MISC_IHISTOGRAM_HPP_
+-
+-#include <gatb/system/api/ISmartPointer.hpp>
+-#include <hdf5/hdf5.h>
+-
+-/********************************************************************************/
+-namespace gatb      {
+-namespace core      {
+-namespace tools     {
+-namespace misc      {
+-/********************************************************************************/
+-
+-/** Here is a command line for showing the histogram with gnuplot from the hdf5 file 'graph.h5'
+-    h5dump -y -d dsk/histogram graph.h5 | grep [0-9] | grep -v [A-Z].* | paste - - | gnuplot -p -e 'plot [][0:100] "-" with lines'
+-
+- For the sum of the distribution, you can use;
+-    h5dump -y -d dsk/histogram graph.h5 | grep [0-9] | grep -v [A-Z].* | paste - - | gawk 'BEGIN{s=0; i=0} { s=s+$2; i=i+1; print i,"  ", s}' | gnuplot -p -e 'plot [0:10][0:] "-" with lines'
+-*/
+-
+-/** \brief TBD */
+-class IHistogram : virtual public system::ISmartPointer
+-{
+-public:
+-
+-    /********************************************************************************/
+-    struct Entry
+-    {
+-        u_int16_t index;
+-        u_int64_t abundance;
+-
+-        inline static hid_t hdf5 (bool& compound)
+-        {
+-            hid_t result = H5Tcreate (H5T_COMPOUND, sizeof(Entry));
+-            H5Tinsert (result, "index",      HOFFSET(Entry, index),     H5T_NATIVE_UINT16);
+-            H5Tinsert (result, "abundance",  HOFFSET(Entry, abundance), H5T_NATIVE_UINT64);
+-            compound = true;
+-            return result;
+-        }
+-        
+-        /** Comparison operator
+-         * \param[in] other : object to be compared to
+-         * \return true if the provided kmer value is greater than the current one. */
+-        bool operator< (const Entry& other) const {  return this->index < other.index; }
+-        
+-        /** Equal operator
+-         * \param[in] other : object to be compared to
+-         * \return true if the provided kmer value is greater than the current one. */
+-        bool operator== (const Entry& other) const {  return (this->index == other.index && this->abundance == other.abundance); }
+-    };
+-
+-    /** */
+-    virtual ~IHistogram() {}
+-
+-    /** */
+-    virtual size_t getLength() = 0;
+-
+-    /** */
+-    virtual void inc (u_int16_t index) = 0;
+-
+-    /** */
+-    virtual void save () = 0;
+-
+-	/** */
+-    virtual void compute_threshold () = 0;
+-	
+-	//compute_threshold needs to be called first
+-	virtual u_int16_t get_solid_cutoff () = 0;
+-	virtual u_int64_t get_nbsolids_auto () = 0;
+-
+-    /** */
+-    virtual u_int64_t& get (u_int16_t idx) = 0;
+-};
+-
+-/********************************************************************************/
+-} } } } /* end of namespaces. */
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_MISC_IHISTOGRAM_HPP_ */
+Index: mapsembler2_pipeline/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/misc/api/Abundance.hpp
+===================================================================
+--- mapsembler2_pipeline.orig/home/osallou/Desktop/mapsembler2/mapsembler2_pipeline/mapsembler2_extremities/thirdparty/gatb-core/src/gatb/tools/misc/api/Abundance.hpp
++++ /dev/null
+@@ -1,98 +0,0 @@
+-/*****************************************************************************
+- *   GATB : Genome Assembly Tool Box
+- *   Copyright (C) 2014  INRIA
+- *   Authors: R.Chikhi, G.Rizk, E.Drezen
+- *
+- *  This program is free software: you can redistribute it and/or modify
+- *  it under the terms of the GNU Affero 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 Affero General Public License for more details.
+- *
+- *  You should have received a copy of the GNU Affero General Public License
+- *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-*****************************************************************************/
+-
+-/** \file Abundance.hpp
+- *  \brief Abundance definition
+- *  \date 01/03/2013
+- *  \author edrezen
+- */
+-
+-/********************************************************************************/
+-
+-#ifndef _GATB_CORE_TOOLS_MISC_ABUNDANCE_HPP_
+-#define _GATB_CORE_TOOLS_MISC_ABUNDANCE_HPP_
+-
+-/********************************************************************************/
+-
+-#include <sys/types.h>
+-#include <hdf5/hdf5.h>
+-
+-/********************************************************************************/
+-namespace gatb      {
+-namespace core      {
+-namespace tools     {
+-namespace misc      {
+-/********************************************************************************/
+-
+-template<typename Type, int precision>
+-struct ArrayData
+-{
+-    Type value[precision];
+-};
+-
+-/********************************************************************************/
+-
+-/** Define an abundance. */
+-template<typename Type, typename Number=u_int16_t> struct Abundance
+-{
+-    Abundance (const Type& val=0, const Number& abund=0) : value(val), abundance(abund) {}
+-
+-    Abundance& operator=(const Abundance& a)
+-    {
+-        if (&a != this)  {  value = a.value;  abundance=a.abundance;  }
+-        return *this;
+-    }
+-
+-    const Number& getAbundance() const { return abundance; }
+-    const Type&   getValue()     const { return value;     }
+-
+-    bool operator== (const Abundance& other) const  {  return value == other.value && abundance == other.abundance;  }
+-
+-    /** Creates a HDF5 type identifier for the [kmer,abundance] structure. This type will be used
+-     * for dumping Count instances in a HDF5 file (like SortingCount algorithm does).
+-     * \param[in] isCompound : tells whether the structure is compound (SHOULD BE OBSOLETE IN THE FUTURE)
+-     * \return the HDF5 identifier for the type. */
+-    static hid_t hdf5 (bool& isCompound)
+-    {
+-        hid_t abundanceType = H5T_NATIVE_UINT16;
+-
+-             if (sizeof(Number)==1) { abundanceType = H5T_NATIVE_UINT8;  }
+-        else if (sizeof(Number)==2) { abundanceType = H5T_NATIVE_UINT16; }
+-        else if (sizeof(Number)==4) { abundanceType = H5T_NATIVE_UINT32; }
+-        else if (sizeof(Number)==8) { abundanceType = H5T_NATIVE_UINT64; }
+-        else { throw "Bad type size for Abundance HDF5 serialization";   }
+-
+-        hid_t result = H5Tcreate (H5T_COMPOUND, sizeof(Abundance));
+-        H5Tinsert (result, "value",      HOFFSET(Abundance, value),     Type::hdf5(isCompound));
+-        H5Tinsert (result, "abundance",  HOFFSET(Abundance, abundance), abundanceType);
+-
+-        isCompound = true;
+-
+-        return result;
+-    }
+-
+-    Type    value;
+-    Number  abundance;
+-};
+-
+-/********************************************************************************/
+-}}}}
+-/********************************************************************************/
+-
+-#endif /* _GATB_CORE_TOOLS_MISC_ABUNDANCE_HPP_ */

Modified: trunk/packages/mapsembler2/trunk/debian/rules
===================================================================
--- trunk/packages/mapsembler2/trunk/debian/rules	2014-08-18 15:30:32 UTC (rev 17765)
+++ trunk/packages/mapsembler2/trunk/debian/rules	2014-08-18 16:24:08 UTC (rev 17766)
@@ -12,13 +12,11 @@
 	uscan --verbose --force-download
 
 override_dh_auto_build:
-	#dh_auto_build
 	mkdir mapsembler2_extremities/build
 	cd mapsembler2_extremities/build && cmake .. && make
 	cd mapsembler2_extend && make k=29
 	cd kissreads_graph && make k=29
 	cd kissreads && make k=29
-	#cd maps && make
 
 
 override_dh_clean:
@@ -27,12 +25,16 @@
 	cd kissreads_graph && make clean
 	cd kissreads && make clean
 
-	#cd maps && make clean
-	#rm -f maps/mapsembler
-	rm -f mapsembler.1
+	rm -f mapsembler2_extremities.1
+	rm -f mapsembler2_extend.1
+	rm -f kissreads.1
+	rm -f kissreads_graph.1
 	dh_clean
 
 override_dh_install:
-	#help2man --help-option=-h --no-discard-stderr --version-string=$(SRC_VERSION) ./maps/mapsembler > mapsembler.1
+	help2man --help-option=-h --no-discard-stderr --version-string=$(SRC_VERSION) ./mapsembler2_extremities/build/mapsembler2_extremities > mapsembler2_extremities.1
+	help2man --help-option=-h --no-discard-stderr --version-string=$(SRC_VERSION) ./mapsembler2_extend/mapsembler2_extend > mapsembler2_extend.1
+	help2man --help-option=-h --no-discard-stderr --version-string=$(SRC_VERSION) ./kissreads/kissreads > kissreads.1
+	help2man --help-option=-h --no-discard-stderr --version-string=$(SRC_VERSION) ./kissreads_graph/kissreads_grpah > kissreads_graph.1
 	dh_install
 




More information about the debian-med-commit mailing list