diff --git a/algo/core/automaton.hpp b/algo/core/automaton.hpp
index 0cee677858a649fad5015a0b5c5eb5cca58b128b..865aaaac435cfd6674d1915c3d679c1100246c6b 100644
--- a/algo/core/automaton.hpp
+++ b/algo/core/automaton.hpp
@@ -211,7 +211,6 @@ void PointerACAutomaton<Info>::insert(const seqtype &sequence, const string &lab
   if (seed.empty())
     seed = this->seed;
   size_t seed_span = seed.length();
-  size_t seed_w = seed_weight(seed);
 
   for(size_t i = start_indexing ; i + seed_span < end_indexing + 1 ; i++) {
     seqtype substr = sequence.substr(i, seed_span);
@@ -226,11 +225,11 @@ void PointerACAutomaton<Info>::insert(const seqtype &sequence, const string &lab
     }
 
     for (seqtype &seq: sequences) {
-      insert(seq, Info(label, 1, seed_w));
+      insert(seq, Info(label, 1, seed_span));
     }
     if (! Info::hasRevcompSymetry()) {
       for (seqtype &seq: sequences_rev) {
-        insert(seq, Info(label, -1, seed_w));
+        insert(seq, Info(label, -1, seed_span));
       }
     }
   }
diff --git a/algo/core/germline.cpp b/algo/core/germline.cpp
index bb973661a610449fd8f70c08223c3a7628d61c1f..cfc9f1d9487d686ca3552cc3db66499c7ae79b6b 100644
--- a/algo/core/germline.cpp
+++ b/algo/core/germline.cpp
@@ -214,13 +214,14 @@ ostream &operator<<(ostream &out, const Germline &germline)
       << setw(3) << germline.delta_min
       << " ";
 
+  size_t seed_span = germline.seed.size();
   size_t seed_w = seed_weight(germline.seed);
 
   if (germline.index) {
     out << " 0x" << hex << setw(2) << setfill('0') << germline.index->id << dec << setfill(' ') << " " ;
     out << fixed << setprecision(3) << setw(8)
-        << 100 * germline.index->getIndexLoad(KmerAffect(germline.affect_5, 1, seed_w)) << "%" << " "
-        << 100 * germline.index->getIndexLoad(KmerAffect(germline.affect_3, 1, seed_w)) << "%";
+        << 100 * germline.index->getIndexLoad(KmerAffect(germline.affect_5, 1, seed_span)) << "%" << " "
+        << 100 * germline.index->getIndexLoad(KmerAffect(germline.affect_3, 1, seed_span)) << "%";
     out << " l" << germline.seed.length() << " k" << seed_w << " " << germline.seed ;
   }
 
diff --git a/algo/core/kmerstore.h b/algo/core/kmerstore.h
index 7eea0358a4682b337f4a893fdf018a467bbf4dac..f09cbae46415a90adea1c2250c96bb80533de229 100644
--- a/algo/core/kmerstore.h
+++ b/algo/core/kmerstore.h
@@ -279,10 +279,10 @@ void IKmerStore<T>::insert(Fasta& input,
     insert(input.sequence(r), label, true, keep_only, seed);
   }
 
-  labels.push_back(make_pair(T(label, 1, seed_weight(seed)), input)) ;
+  labels.push_back(make_pair(T(label, 1, seed.size()), input)) ;
 
   if (revcomp_indexed  && ! T::hasRevcompSymetry()) {
-    labels.push_back(make_pair(T(label, -1, seed_weight(seed)), input)) ;
+    labels.push_back(make_pair(T(label, -1, seed.size()), input)) ;
   }
 }
 
@@ -304,7 +304,6 @@ void IKmerStore<T>::insert(const seqtype &sequence,
     seed = this->seed;
 
   size_t seed_span = seed.length();
-  size_t seed_w = seed_weight(seed);
   size_t size_indexing = end_indexing - start_indexing;
   if (size_indexing > max_size_indexing) {
     max_size_indexing = size_indexing;
@@ -329,13 +328,13 @@ void IKmerStore<T>::insert(const seqtype &sequence,
     if (this_kmer.isNull()) {
       nb_kmers_inserted++;
     }
-    this_kmer += T(label, strand, seed_w);
+    this_kmer += T(label, strand, seed.size());
     if (revcomp_indexed && ! T::hasRevcompSymetry()) {
       seqtype rc_kmer = spaced(revcomp(substr), seed);
       T &this_rc_kmer = this->get(rc_kmer);
       if (this_rc_kmer.isNull())
         nb_kmers_inserted++;
-      this_rc_kmer += T(label, -1, seed_w);
+      this_rc_kmer += T(label, -1, seed.size());
     }
   }
 }
diff --git a/algo/core/segment.cpp b/algo/core/segment.cpp
index caf7ae98938b488fc58278b7866241209d967bd1..996eaa56e1f6bb204d99800d19865d840597b3df 100644
--- a/algo/core/segment.cpp
+++ b/algo/core/segment.cpp
@@ -490,12 +490,12 @@ KmerSegmenter::KmerSegmenter(Sequence seq, Germline *germline, double threshold,
     return ;
   } else if (nb_strand[0] > RATIO_STRAND * nb_strand[1]) {
     strand = -1;
-    before = KmerAffect(germline->affect_3, -1, seed_weight(germline->seed));
-    after = KmerAffect(germline->affect_5, -1, seed_weight(germline->seed));
+    before = KmerAffect(germline->affect_3, -1, germline->seed.size());
+    after = KmerAffect(germline->affect_5, -1, germline->seed.size());
   } else if (nb_strand[1] > RATIO_STRAND * nb_strand[0]) {
     strand = 1;
-    before = KmerAffect(germline->affect_5, 1, seed_weight(germline->seed));
-    after = KmerAffect(germline->affect_3, 1, seed_weight(germline->seed));
+    before = KmerAffect(germline->affect_5, 1, germline->seed.size());
+    after = KmerAffect(germline->affect_3, 1, germline->seed.size());
   } else {
     // Ambiguous information: we have positive and negative strands
     // and there is not enough difference to put them apart.
diff --git a/algo/tests/unit-tests/testAffectAnalyser.cpp b/algo/tests/unit-tests/testAffectAnalyser.cpp
index 67d3e5d7f7e986424bd6769a3a2d2326acc8a813..eac15ccd69ca3eb330af900c54d1bceeedf070a5 100644
--- a/algo/tests/unit-tests/testAffectAnalyser.cpp
+++ b/algo/tests/unit-tests/testAffectAnalyser.cpp
@@ -197,6 +197,36 @@ void testAffectAnalyserMaxes() {
   delete index;
 }
 
+template<template <class> class T>
+void testAffectAnalyserSpaced() {
+  const string seed = "##-##";
+  const bool revcomp = false;
+
+  T<KmerAffect> *index = createIndex<T<KmerAffect> >(seed, revcomp);
+
+  string sequence = "AAAACCCCCGGGGG";
+  // AA-AC, AA-CC, AA-CC, AC-CC, CC-CC, CC-CG, CC-GG, CG-GG, GG-GG
+  KmerAffectAnalyser kaa(*index, sequence);
+  CountKmerAffectAnalyser ckaa(*index, sequence);
+
+  KmerAffect affect_AAAC(seq[11], 1, seed.size());
+  KmerAffect affect_AAAC_bad(seq[11], 1, seed_weight(seed));
+  KmerAffect affect_CCCC(seq[1], 1, seed.size());
+  KmerAffect affect_CCCC_bad(seq[1], 1, seed_weight(seed));
+  KmerAffect affect_GGGG(seq[3], 1, seed.size());
+  KmerAffect affect_GGGG_bad(seq[3], 1, seed_weight(seed));
+
+  TAP_TEST(kaa.toString().find("+V _ _ _+C _ _ _ _+G") != string::npos,
+           TEST_AA_TO_STRING, "");
+  TAP_TEST(kaa.count(affect_AAAC) == 1, TEST_AA_COUNT, "Expected 1, got " << kaa.count(affect_AAAC) << " in " << __PRETTY_FUNCTION__);
+  TAP_TEST(kaa.count(affect_CCCC) == 1, TEST_AA_COUNT, "Expected 1, got " << kaa.count(affect_CCCC) << " in " << __PRETTY_FUNCTION__);
+  TAP_TEST(kaa.count(affect_GGGG) == 1, TEST_AA_COUNT, "Expected 1, got " << kaa.count(affect_GGGG) << " in " << __PRETTY_FUNCTION__);
+
+  TAP_TEST(kaa.count(affect_AAAC_bad) == 0, TEST_AA_COUNT, "Expected 0, got " << kaa.count(affect_AAAC_bad) << " in " << __PRETTY_FUNCTION__);
+  TAP_TEST(kaa.count(affect_CCCC_bad) == 0, TEST_AA_COUNT, "Expected 0, got " << kaa.count(affect_CCCC_bad) << " in " << __PRETTY_FUNCTION__);
+  TAP_TEST(kaa.count(affect_GGGG_bad) == 0, TEST_AA_COUNT, "Expected 0, got " << kaa.count(affect_GGGG_bad) << " in " << __PRETTY_FUNCTION__);
+}
+
 template<template <class> class T>
 void testGetMaximum() {
   const int k = 4;
@@ -371,15 +401,19 @@ void testAffectAnalyser() {
   testAffectAnalyser2<MapKmerStore>();
   testBugAffectAnalyser<MapKmerStore>();
   testGetMaximum<MapKmerStore>();
+  testAffectAnalyserSpaced<MapKmerStore>();
 
   testAffectAnalyser1<ArrayKmerStore>();
   testAffectAnalyser2<ArrayKmerStore>();
   testAffectAnalyserMaxes<ArrayKmerStore>();
   testBugAffectAnalyser<ArrayKmerStore>();
   testGetMaximum<ArrayKmerStore>();
+  testAffectAnalyserSpaced<ArrayKmerStore>();
+
 
   testAffectAnalyser1<PointerACAutomaton>();
   testAffectAnalyser2<PointerACAutomaton>();
   testAffectAnalyserMaxes<PointerACAutomaton>();
   testBugAffectAnalyser<PointerACAutomaton>();
+  testAffectAnalyserSpaced<PointerACAutomaton>();
 }
diff --git a/algo/tests/unit-tests/tests.h b/algo/tests/unit-tests/tests.h
index 83e6cc80a2f8d51814995ef01a52dc49ac4d1cdf..f579a5028ea37a6068eeef9e59c09d5ffcb24aec 100644
--- a/algo/tests/unit-tests/tests.h
+++ b/algo/tests/unit-tests/tests.h
@@ -86,6 +86,7 @@ enum {
   TEST_AA_GET_MAXIMUM_COUNTS,
   TEST_AA_GET_MAXIMUM_VALUE,
   TEST_AA_GET_SEQUENCE,
+  TEST_AA_TO_STRING,
   TEST_COUNT_AA_GET_OVERLAP,
   TEST_COUNT_AA_COUNT,
   TEST_COUNT_AA_COUNT_BEFORE,
@@ -252,6 +253,7 @@ inline void declare_tests() {
   RECORD_TAP_TEST(TEST_AA_GET_MAXIMUM_COUNTS, "KmerAffectAnalyser: getMaximum() function, counts of affectations");
   RECORD_TAP_TEST(TEST_AA_GET_MAXIMUM_VALUE, "KmerAffectAnalyser: getMaximum() function, maximum value");
   RECORD_TAP_TEST(TEST_AA_GET_SEQUENCE, "KmerAffectAnalyser: getSequence() function");
+  RECORD_TAP_TEST(TEST_AA_TO_STRING, "KmerAffectAnalyser: toString() function");
   RECORD_TAP_TEST(TEST_COUNT_AA_GET_OVERLAP, "CountKmerAffectAnalyser::getAllowedOverlap");
   RECORD_TAP_TEST(TEST_COUNT_AA_COUNT, "CountKmerAffectAnalyser::count");
   RECORD_TAP_TEST(TEST_COUNT_AA_COUNT_BEFORE, "CountKmerAffectAnalyser::countBefore");