diff --git a/metagraph/src/cli/build.cpp b/metagraph/src/cli/build.cpp
index d58cbde119..6a193d7214 100644
--- a/metagraph/src/cli/build.cpp
+++ b/metagraph/src/cli/build.cpp
@@ -251,12 +251,16 @@ int build_graph(Config *config) {
         }
 
     } else if (config->graph_type == Config::GraphType::SSHASH && !config->dynamic) {
-        graph.reset(new DBGSSHash(files.at(0), config->k, config->graph_mode, config->num_chars));
         if (files.size() > 1) {
             logger->error("DBGSSHash does not support multiple input files.");
             exit(1);
         }
 
+        graph.reset(new DBGSSHash(files.at(0),
+                                  config->k,
+                                  config->graph_mode,
+                                  config->num_chars,
+                                  config->is_monochromatic));
     } else {
         //slower method
         switch (config->graph_type) {
diff --git a/metagraph/src/cli/config/config.cpp b/metagraph/src/cli/config/config.cpp
index 7312ff93ba..fd81cfd26b 100644
--- a/metagraph/src/cli/config/config.cpp
+++ b/metagraph/src/cli/config/config.cpp
@@ -151,6 +151,8 @@ Config::Config(int argc, char *argv[]) {
             dynamic = true;
         } else if (!strcmp(argv[i], "--mask-dummy")) {
             mark_dummy_kmers = true;
+        } else if (!strcmp(argv[i], "--is-monochromatic")) {
+            is_monochromatic = true;
         } else if (!strcmp(argv[i], "--anno-filename")) {
             filename_anno = true;
         } else if (!strcmp(argv[i], "--anno-header")) {
@@ -972,6 +974,7 @@ if (advanced) {
             fprintf(stderr, "\t   --mode \t\tk-mer indexing mode: basic / canonical / primary [basic]\n");
 #endif
             fprintf(stderr, "\t   --complete \t\tconstruct a complete graph (only for Bitmap graph) [off]\n");
+            fprintf(stderr, "\t   --is-monochromatic \t\tindicate that the input sequences are monochromatic (i.e., their colouring is constant) [off]\n");
             fprintf(stderr, "\t   --mem-cap-gb [INT] \tpreallocated buffer size in GB [1]\n");
 if (advanced) {
             fprintf(stderr, "\t   --dynamic \t\tuse dynamic build method [off]\n");
diff --git a/metagraph/src/cli/config/config.hpp b/metagraph/src/cli/config/config.hpp
index b4848812d8..aae5304270 100644
--- a/metagraph/src/cli/config/config.hpp
+++ b/metagraph/src/cli/config/config.hpp
@@ -28,6 +28,7 @@ class Config {
     bool complete = false;
     bool dynamic = false;
     bool mark_dummy_kmers = false;
+    bool is_monochromatic = false;
     bool filename_anno = false;
     bool annotate_sequence_headers = false;
     bool to_adj_list = false;
diff --git a/metagraph/src/cli/query.cpp b/metagraph/src/cli/query.cpp
index cb7d2e35c9..fcb41c61b5 100644
--- a/metagraph/src/cli/query.cpp
+++ b/metagraph/src/cli/query.cpp
@@ -955,8 +955,9 @@ construct_query_graph(const AnnotatedDBG &anno_graph,
     #pragma omp parallel for num_threads(num_threads)
     for (size_t i = 0; i < contigs.size(); ++i) {
         contigs[i].second.reserve(contigs[i].first.length() - graph_init->get_k() + 1);
-        full_dbg.map_to_nodes(contigs[i].first,
-                              [&](node_index node) { contigs[i].second.push_back(node); });
+        call_annotated_nodes_offsets(full_dbg, contigs[i].first, [&](node_index node, int64_t) {
+            contigs[i].second.push_back(node);
+        });
     }
     logger->trace("[Query graph construction] Contigs mapped to the full graph in {} sec",
                   timer.elapsed());
diff --git a/metagraph/src/graph/alignment/annotation_buffer.cpp b/metagraph/src/graph/alignment/annotation_buffer.cpp
index 4020f312a7..8870b71e0b 100644
--- a/metagraph/src/graph/alignment/annotation_buffer.cpp
+++ b/metagraph/src/graph/alignment/annotation_buffer.cpp
@@ -2,6 +2,7 @@
 
 #include "graph/representation/rc_dbg.hpp"
 #include "graph/representation/succinct/dbg_succinct.hpp"
+#include "graph/representation/hash/dbg_sshash.hpp"
 #include "graph/representation/canonical_dbg.hpp"
 #include "annotation/binary_matrix/base/binary_matrix.hpp"
 #include "common/utils/template_utils.hpp"
@@ -34,8 +35,6 @@ AnnotationBuffer::AnnotationBuffer(const DeBruijnGraph &graph, const Annotator &
 void AnnotationBuffer::fetch_queued_annotations() {
     assert(graph_.get_mode() != DeBruijnGraph::PRIMARY
                 && "PRIMARY graphs must be wrapped into CANONICAL");
-
-    std::vector<node_index> queued_nodes;
     std::vector<Row> queued_rows;
 
     const DeBruijnGraph *base_graph = &graph_;
@@ -45,14 +44,21 @@ void AnnotationBuffer::fetch_queued_annotations() {
 
     const auto *dbg_succ = dynamic_cast<const DBGSuccinct*>(base_graph);
     const boss::BOSS *boss = dbg_succ ? &dbg_succ->get_boss() : nullptr;
+    const DBGSSHash *sshash = dynamic_cast<const DBGSSHash*>(base_graph);
 
+    std::vector<std::tuple<node_index, node_index, int64_t>> to_update;
     for (const auto &path : queued_paths_) {
         std::vector<node_index> base_path;
-        if (base_graph->get_mode() == DeBruijnGraph::CANONICAL) {
+        std::vector<int64_t> base_path_offsets;
+        if (base_graph->get_mode() == DeBruijnGraph::CANONICAL || (sshash && sshash->is_monochromatic())) {
             // TODO: avoid this call of spell_path
             std::string query = spell_path(graph_, path);
-            base_path = map_to_nodes(*base_graph, query);
-
+            base_path.reserve(path.size());
+            call_annotated_nodes_offsets(graph_, query, [&](node_index i, int64_t o) {
+                assert(boss || i != DeBruijnGraph::npos);
+                base_path.emplace_back(i);
+                base_path_offsets.emplace_back(o);
+            });
         } else if (canonical_) {
             base_path.reserve(path.size());
             for (node_index node : path) {
@@ -66,125 +72,108 @@ void AnnotationBuffer::fetch_queued_annotations() {
                 std::reverse(base_path.begin(), base_path.end());
         }
 
+        base_path_offsets.resize(base_path.size());
+
         assert(base_path.size() == path.size());
 
         for (size_t i = 0; i < path.size(); ++i) {
-            if (base_path[i] == DeBruijnGraph::npos) {
+            if (base_path[i] == DeBruijnGraph::npos
+                    || (boss && !boss->get_W(dbg_succ->kmer_to_boss_index(base_path[i])))) {
                 // this can happen when the base graph is CANONICAL and path[i] is a
                 // dummy node
-                if (node_to_cols_.try_emplace(path[i], 0).second && has_coordinates())
-                    label_coords_.emplace_back();
-
-                continue;
-            }
-
-            if (boss && !boss->get_W(dbg_succ->kmer_to_boss_index(base_path[i]))) {
-                // skip dummy nodes
                 if (node_to_cols_.try_emplace(base_path[i], 0).second && has_coordinates())
                     label_coords_.emplace_back();
 
-                if (graph_.get_mode() == DeBruijnGraph::CANONICAL
-                        && base_path[i] != path[i]
-                        && node_to_cols_.emplace(path[i], 0).second && has_coordinates()) {
+                if (node_to_cols_.try_emplace(path[i], 0).second && has_coordinates())
                     label_coords_.emplace_back();
-                }
 
                 continue;
             }
 
-            Row row = AnnotatedDBG::graph_to_anno_index(base_path[i]);
-            if (canonical_ || graph_.get_mode() == DeBruijnGraph::BASIC) {
-                if (node_to_cols_.try_emplace(base_path[i], nannot).second) {
-                    queued_rows.push_back(row);
-                    queued_nodes.push_back(base_path[i]);
-                }
+            to_update.emplace_back(base_path[i], path[i], base_path_offsets[i]);
 
-                continue;
-            }
-
-            assert(graph_.get_mode() == DeBruijnGraph::CANONICAL);
-
-            auto find_a = node_to_cols_.find(path[i]);
-            auto find_b = node_to_cols_.find(base_path[i]);
-
-            if (find_a == node_to_cols_.end() && find_b == node_to_cols_.end()) {
-                node_to_cols_.try_emplace(path[i], nannot);
+            Row row = AnnotatedDBG::graph_to_anno_index(base_path[i]);
+            if (node_to_cols_.try_emplace(base_path[i], nannot).second) {
                 queued_rows.push_back(row);
-                queued_nodes.push_back(path[i]);
-
-                if (path[i] != base_path[i]) {
-                    node_to_cols_.emplace(base_path[i], nannot);
-                    queued_rows.push_back(row);
-                    queued_nodes.push_back(base_path[i]);
-                }
-            } else if (find_a == node_to_cols_.end() && find_b != node_to_cols_.end()) {
-                node_to_cols_.try_emplace(path[i], find_b->second);
-                if (find_b->second == nannot) {
-                    queued_rows.push_back(row);
-                    queued_nodes.push_back(path[i]);
-                }
-            } else if (find_a != node_to_cols_.end() && find_b == node_to_cols_.end()) {
-                node_to_cols_.try_emplace(base_path[i], find_a->second);
-            } else {
-                size_t label_i = std::min(find_a->second, find_b->second);
-                if (label_i != nannot) {
-                    find_a.value() = label_i;
-                    find_b.value() = label_i;
-                }
+                if (has_coordinates())
+                    label_coords_.emplace_back();
             }
         }
     }
 
-    queued_paths_.clear();
-
-    if (queued_nodes.empty())
-        return;
+    assert(!has_coordinates() || node_to_cols_.size() == label_coords_.size());
 
-    auto push_node_labels = [&](auto node_it, auto row_it, auto&& labels) {
-        assert(node_it != queued_nodes.end());
-        assert(node_to_cols_.count(*node_it));
-        assert(node_to_cols_.count(AnnotatedDBG::anno_to_graph_index(*row_it)));
-
-        size_t label_i = cache_column_set(std::move(labels));
-        node_index base_node = AnnotatedDBG::anno_to_graph_index(*row_it);
-        if (graph_.get_mode() == DeBruijnGraph::BASIC) {
-            assert(base_node == *node_it);
-            node_to_cols_[*node_it] = label_i;
-        } else if (canonical_) {
-            node_to_cols_[base_node] = label_i;
-        } else {
-            node_to_cols_[*node_it] = label_i;
-            if (base_node != *node_it && node_to_cols_.try_emplace(base_node, label_i).second
-                    && has_coordinates()) {
-                label_coords_.emplace_back(label_coords_.back());
-            }
-        }
-    };
+    queued_paths_.clear();
 
-    auto node_it = queued_nodes.begin();
     auto row_it = queued_rows.begin();
     if (has_coordinates()) {
         assert(multi_int_);
         // extract both labels and coordinates, then store them separately
         for (auto&& row_tuples : multi_int_->get_row_tuples(queued_rows)) {
+            assert(row_it != queued_rows.end());
             std::sort(row_tuples.begin(), row_tuples.end(), utils::LessFirst());
+
+            node_index base_node = AnnotatedDBG::anno_to_graph_index(*row_it);
+            auto find_base = node_to_cols_.find(base_node);
+            assert(find_base != node_to_cols_.end());
+            assert(find_base->second == nannot);
+
+            size_t coord_idx = find_base - node_to_cols_.begin();
+            assert(coord_idx < label_coords_.size());
+
             Columns labels;
             labels.reserve(row_tuples.size());
-            label_coords_.emplace_back();
-            label_coords_.back().reserve(row_tuples.size());
+            auto &label_coords = label_coords_[coord_idx];
+            label_coords.reserve(row_tuples.size());
             for (auto&& [label, coords] : row_tuples) {
                 labels.push_back(label);
-                label_coords_.back().emplace_back(coords.begin(), coords.end());
+                label_coords.emplace_back(coords.begin(), coords.end());
             }
-            push_node_labels(node_it++, row_it++, std::move(labels));
+
+            find_base.value() = cache_column_set(std::move(labels));
+
+            ++row_it;
         }
     } else {
         for (auto&& labels : annotator_.get_matrix().get_rows(queued_rows)) {
+            assert(row_it != queued_rows.end());
+
             std::sort(labels.begin(), labels.end());
-            push_node_labels(node_it++, row_it++, std::move(labels));
+
+            node_index base_node = AnnotatedDBG::anno_to_graph_index(*row_it);
+            auto find_base = node_to_cols_.find(base_node);
+            assert(find_base != node_to_cols_.end());
+            assert(find_base->second == nannot);
+
+            find_base.value() = cache_column_set(std::move(labels));
+
+            ++row_it;
         }
     }
 
+    for (const auto &[base_node, node, offset] : to_update) {
+        auto find_base = node_to_cols_.find(base_node);
+        assert(find_base != node_to_cols_.end());
+        assert(find_base->second != nannot);
+
+        size_t coord_idx = find_base - node_to_cols_.begin();
+        size_t label_i = find_base->second;
+
+        assert(!node_to_cols_.count(node) || node_to_cols_.find(node)->second != nannot);
+
+        if (node_to_cols_.try_emplace(node, label_i).second && has_coordinates()) {
+            assert(coord_idx < label_coords_.size());
+            label_coords_.emplace_back(label_coords_[coord_idx]);
+            for (auto &coords : label_coords_.back()) {
+                for (auto &c : coords) {
+                    c += offset;
+                }
+            }
+        }
+    }
+
+    assert(!has_coordinates() || node_to_cols_.size() == label_coords_.size());
+
 #ifndef NDEBUG
     for (const auto &[node, val] : node_to_cols_) {
         assert(val != nannot);
@@ -196,9 +185,6 @@ auto AnnotationBuffer::get_labels_and_coords(node_index node) const
         -> std::pair<const Columns*, const CoordinateSet*> {
     std::pair<const Columns*, const CoordinateSet*> ret_val { nullptr, nullptr };
 
-    if (canonical_)
-        node = canonical_->get_base_node(node);
-
     auto it = node_to_cols_.find(node);
 
     // if the node hasn't been seen before, or if its annotations haven't
diff --git a/metagraph/src/graph/annotated_dbg.cpp b/metagraph/src/graph/annotated_dbg.cpp
index 430365365a..9efbdd3bfe 100644
--- a/metagraph/src/graph/annotated_dbg.cpp
+++ b/metagraph/src/graph/annotated_dbg.cpp
@@ -6,6 +6,7 @@
 #include "annotation/representation/row_compressed/annotate_row_compressed.hpp"
 #include "annotation/int_matrix/base/int_matrix.hpp"
 #include "graph/representation/canonical_dbg.hpp"
+#include "graph/representation/hash/dbg_sshash.hpp"
 #include "common/aligned_vector.hpp"
 #include "common/vectors/vector_algorithm.hpp"
 #include "common/vector_map.hpp"
@@ -23,6 +24,19 @@ using Column = mtg::annot::matrix::BinaryMatrix::Column;
 typedef AnnotatedDBG::Label Label;
 typedef std::pair<Label, size_t> StringCountPair;
 
+void call_annotated_nodes_offsets(const SequenceGraph &graph,
+                                  std::string_view sequence,
+                                  const std::function<void(SequenceGraph::node_index, int64_t)> &callback) {
+    if (const auto *dbg = dynamic_cast<const DeBruijnGraph*>(&graph)) {
+        if (dbg->is_monochromatic()) {
+            dbg->map_to_contigs(sequence, callback);
+            return;
+        }
+    }
+
+    graph.map_to_nodes(sequence, [&](SequenceGraph::node_index i) { callback(i, 0); });
+}
+
 
 AnnotatedSequenceGraph
 ::AnnotatedSequenceGraph(std::shared_ptr<SequenceGraph> graph,
@@ -46,10 +60,9 @@ ::annotate_sequence(std::string_view sequence,
 
     std::vector<row_index> indices;
     indices.reserve(sequence.size());
-
-    graph_->map_to_nodes(sequence, [&](node_index i) {
+    call_annotated_nodes_offsets(*graph_, sequence, [&](node_index i, int64_t) {
         if (i > 0)
-            indices.push_back(graph_to_anno_index(i));
+            indices.emplace_back(graph_to_anno_index(i));
     });
 
     if (!indices.size())
@@ -80,9 +93,9 @@ ::annotate_sequences(const std::vector<std::pair<std::string, std::vector<Label>
         if (!indices.capacity())
             indices.reserve(data[t].first.size());
 
-        graph_->map_to_nodes(data[t].first, [&](node_index i) {
+        call_annotated_nodes_offsets(*graph_, data[t].first, [&](node_index i, int64_t) {
             if (i > 0)
-                indices.push_back(graph_to_anno_index(i));
+                indices.emplace_back(graph_to_anno_index(i));
         });
     }
 
@@ -117,10 +130,10 @@ void AnnotatedDBG::add_kmer_counts(std::string_view sequence,
     indices.reserve(sequence.size() - dbg_.get_k() + 1);
     size_t end = 0;
 
-    graph_->map_to_nodes(sequence, [&](node_index i) {
+    call_annotated_nodes_offsets(dbg_, sequence, [&](node_index i, int64_t) {
         // only insert indexes for matched k-mers and shift counts accordingly
         if (i > 0) {
-            indices.push_back(graph_to_anno_index(i));
+            indices.emplace_back(graph_to_anno_index(i));
             kmer_counts[indices.size() - 1] = kmer_counts[end++];
         }
     });
@@ -139,15 +152,30 @@ void AnnotatedDBG::add_kmer_coord(std::string_view sequence,
     if (sequence.size() < dbg_.get_k())
         return;
 
-    std::vector<row_index> indices = map_to_nodes(dbg_, sequence);
+    std::vector<row_index> indices;
+    std::vector<int64_t> offsets;
+    call_annotated_nodes_offsets(dbg_, sequence, [&](node_index i, int64_t offset) {
+        indices.emplace_back(i);
+        offsets.emplace_back(offset);
+    });
 
     std::lock_guard<std::mutex> lock(mutex_);
 
+    auto it = offsets.begin();
+    uint64_t last_coord = std::numeric_limits<uint64_t>::max();
+    int64_t last_offset = std::numeric_limits<int64_t>::max();
     for (node_index i : indices) {
         // only insert coordinates for matched k-mers and increment the coordinates
-        if (i > 0)
-            annotator_->add_label_coord(graph_to_anno_index(i), labels, coord);
+        if (i > 0) {
+            if (last_coord == std::numeric_limits<uint64_t>::max() || coord - *it != last_coord - last_offset) {
+                annotator_->add_label_coord(graph_to_anno_index(i), labels, coord - *it);
+                last_coord = coord;
+                last_offset = *it;
+            }
+        }
+
         coord++;
+        ++it;
     }
 }
 
@@ -156,10 +184,17 @@ void AnnotatedDBG::add_kmer_coords(
     assert(check_compatibility());
 
     std::vector<std::vector<row_index>> ids;
+    std::vector<std::vector<int64_t>> offsets;
     ids.reserve(data.size());
     for (const auto &[sequence, labels, _] : data) {
-        if (sequence.size() >= dbg_.get_k())
-            ids.push_back(map_to_nodes(dbg_, sequence));
+        if (sequence.size() >= dbg_.get_k()) {
+            auto &id = ids.emplace_back();
+            auto &offset = offsets.emplace_back();
+            call_annotated_nodes_offsets(dbg_, sequence, [&](node_index i, int64_t o) {
+                id.emplace_back(i);
+                offset.emplace_back(o);
+            });
+        }
     }
 
     std::lock_guard<std::mutex> lock(mutex_);
@@ -168,11 +203,20 @@ void AnnotatedDBG::add_kmer_coords(
         const auto &labels = std::get<1>(data[t]);
         uint64_t coord = std::get<2>(data[t]);
 
+        uint64_t last_coord = std::numeric_limits<uint64_t>::max();
+        int64_t last_offset = std::numeric_limits<int64_t>::max();
+        auto it = offsets[t].begin();
         for (node_index i : ids[t]) {
             // only insert coordinates for matched k-mers and increment the coordinates
-            if (i > 0)
-                annotator_->add_label_coord(graph_to_anno_index(i), labels, coord);
+            if (i > 0) {
+                if (last_coord == std::numeric_limits<uint64_t>::max() || coord - *it != last_coord - last_offset) {
+                    annotator_->add_label_coord(graph_to_anno_index(i), labels, coord - *it);
+                    last_coord = coord;
+                    last_offset = *it;
+                }
+            }
             coord++;
+            ++it;
         }
     }
 }
@@ -200,10 +244,16 @@ void AnnotatedDBG::annotate_kmer_coords(
             coords[last].reserve(sequence.size() - dbg_.get_k() + 1);
         }
 
-        graph_->map_to_nodes(sequence, [&](node_index i) {
+        uint64_t last_coord = std::numeric_limits<uint64_t>::max();
+        int64_t last_offset = std::numeric_limits<int64_t>::max();
+        call_annotated_nodes_offsets(*graph_, sequence, [&](node_index i, int64_t o) {
             if (i > 0) {
-                ids[last].push_back(graph_to_anno_index(i));
-                coords[last].emplace_back(graph_to_anno_index(i), coord);
+                if (last_coord == std::numeric_limits<uint64_t>::max() || coord - o != last_coord - last_offset) {
+                    ids[last].push_back(graph_to_anno_index(i));
+                    coords[last].emplace_back(graph_to_anno_index(i), coord - o);
+                    last_coord = coord;
+                    last_offset = o;
+                }
             }
             coord++;
         });
@@ -238,7 +288,7 @@ std::vector<Label> AnnotatedDBG::get_labels(std::string_view sequence,
     size_t num_present_kmers = 0;
     size_t num_missing_kmers = 0;
 
-    graph_->map_to_nodes(sequence, [&](node_index i) {
+    call_annotated_nodes_offsets(*graph_, sequence, [&](node_index i, int64_t) {
         if (i > 0) {
             index_counts[graph_to_anno_index(i)]++;
             num_present_kmers++;
@@ -284,7 +334,7 @@ AnnotatedDBG::get_labels(const std::vector<std::pair<row_index, size_t>> &index_
 }
 
 std::vector<Label>
-AnnotatedSequenceGraph::get_labels(node_index index) const {
+AnnotatedSequenceGraph::get_stored_labels(node_index index) const {
     assert(check_compatibility());
     assert(index != SequenceGraph::npos);
 
@@ -312,7 +362,7 @@ AnnotatedDBG::get_top_labels(std::string_view sequence,
 
     size_t num_present_kmers = 0;
 
-    graph_->map_to_nodes(sequence, [&](node_index i) {
+    call_annotated_nodes_offsets(*graph_, sequence, [&](node_index i, int64_t) {
         if (i > 0) {
             index_counts[graph_to_anno_index(i)]++;
             num_present_kmers++;
@@ -342,7 +392,13 @@ AnnotatedDBG::get_kmer_counts(std::string_view sequence,
                               size_t num_top_labels,
                               double discovery_fraction,
                               double presence_fraction) const {
-    std::vector<node_index> nodes = map_to_nodes(dbg_, sequence);
+    std::vector<node_index> nodes;
+    if (sequence.size() >= dbg_.get_k()) {
+        nodes.reserve(sequence.size() - dbg_.get_k() + 1);
+        call_annotated_nodes_offsets(*graph_, sequence, [&](node_index i, int64_t) {
+            nodes.emplace_back(i);
+        });
+    }
     return get_kmer_counts(nodes, num_top_labels, discovery_fraction, presence_fraction);
 }
 
@@ -454,19 +510,30 @@ AnnotatedDBG::get_kmer_coordinates(std::string_view sequence,
                                    size_t num_top_labels,
                                    double discovery_fraction,
                                    double presence_fraction) const {
-    std::vector<node_index> nodes = map_to_nodes(dbg_, sequence);
-    return get_kmer_coordinates(nodes, num_top_labels, discovery_fraction, presence_fraction);
+    std::vector<node_index> nodes;
+    std::vector<int64_t> offsets;
+    if (sequence.size() >= dbg_.get_k()) {
+        nodes.reserve(sequence.size() - dbg_.get_k() + 1);
+        offsets.reserve(sequence.size() - dbg_.get_k() + 1);
+        call_annotated_nodes_offsets(*graph_, sequence, [&](node_index i, int64_t o) {
+            nodes.emplace_back(i);
+            offsets.emplace_back(o);
+        });
+    }
+    return get_kmer_coordinates(nodes, num_top_labels, discovery_fraction, presence_fraction, offsets);
 }
 
 std::vector<std::tuple<Label, size_t, std::vector<SmallVector<uint64_t>>>>
 AnnotatedDBG::get_kmer_coordinates(const std::vector<node_index> &nodes,
                                    size_t num_top_labels,
                                    double discovery_fraction,
-                                   double presence_fraction) const {
+                                   double presence_fraction,
+                                   const std::vector<int64_t> &offsets) const {
     assert(discovery_fraction >= 0.);
     assert(discovery_fraction <= 1.);
     assert(presence_fraction >= 0.);
     assert(presence_fraction <= 1.);
+    assert(offsets.empty() || offsets.size() == nodes.size());
     assert(check_compatibility());
 
     if (!nodes.size())
@@ -528,8 +595,15 @@ AnnotatedDBG::get_kmer_coordinates(const std::vector<node_index> &nodes,
     for (size_t i = 0; i < rows_tuples.size(); ++i) {
         // set the non-empty tuples
         for (auto &[j, tuple] : rows_tuples[i]) {
-            if (col_counts[j])
-                std::get<2>(result[col_counts[j] - 1])[kmer_positions[i]] = std::move(tuple);
+            if (col_counts[j]) {
+                auto &coords = std::get<2>(result[col_counts[j] - 1])[kmer_positions[i]];
+                coords = std::move(tuple);
+                if (offsets.size()) {
+                    for (auto &c : coords) {
+                        c += offsets[kmer_positions[i]];
+                    }
+                }
+            }
         }
     }
 
@@ -574,7 +648,7 @@ AnnotatedDBG::get_top_label_signatures(std::string_view sequence,
     kmer_positions.reserve(num_kmers);
 
     size_t j = 0;
-    graph_->map_to_nodes(sequence, [&](node_index i) {
+    call_annotated_nodes_offsets(*graph_, sequence, [&](node_index i, int64_t o) {
         if (i > 0) {
             kmer_positions.push_back(j);
             row_indices.push_back(graph_to_anno_index(i));
diff --git a/metagraph/src/graph/annotated_dbg.hpp b/metagraph/src/graph/annotated_dbg.hpp
index 4660a907d1..2d67cba27f 100644
--- a/metagraph/src/graph/annotated_dbg.hpp
+++ b/metagraph/src/graph/annotated_dbg.hpp
@@ -28,7 +28,10 @@ class AnnotatedSequenceGraph {
 
     virtual ~AnnotatedSequenceGraph() {}
 
-    virtual std::vector<Label> get_labels(node_index index) const;
+    // Return the labels explicitly stored at this node. Some annotation schemes
+    // may not store labels at all nodes
+    // (e.g., canonical-mode graphs only annotate canonical k-mers)
+    virtual std::vector<Label> get_stored_labels(node_index index) const;
 
     // thread-safe, can be called from multiple threads concurrently
     virtual void annotate_sequence(std::string_view sequence,
@@ -72,7 +75,7 @@ class AnnotatedDBG : public AnnotatedSequenceGraph {
                  std::unique_ptr<Annotator>&& annotation,
                  bool force_fast = false);
 
-    using AnnotatedSequenceGraph::get_labels;
+    using AnnotatedSequenceGraph::get_stored_labels;
 
     const DeBruijnGraph& get_graph() const { return dbg_; }
 
@@ -149,7 +152,8 @@ class AnnotatedDBG : public AnnotatedSequenceGraph {
     get_kmer_coordinates(const std::vector<node_index> &nodes,
                          size_t num_top_labels,
                          double discovery_fraction,
-                         double presence_fraction) const;
+                         double presence_fraction,
+                         const std::vector<int64_t> &offsets = {}) const;
 
     std::vector<std::pair<Label, sdsl::bit_vector>>
     get_top_label_signatures(std::string_view sequence,
@@ -165,6 +169,10 @@ class AnnotatedDBG : public AnnotatedSequenceGraph {
     DeBruijnGraph &dbg_;
 };
 
+void call_annotated_nodes_offsets(const SequenceGraph &graph,
+                                  std::string_view sequence,
+                                  const std::function<void(SequenceGraph::node_index, int64_t)> &callback);
+
 } // namespace graph
 } // namespace mtg
 
diff --git a/metagraph/src/graph/representation/base/sequence_graph.cpp b/metagraph/src/graph/representation/base/sequence_graph.cpp
index bd6d55c485..fb26e6974c 100644
--- a/metagraph/src/graph/representation/base/sequence_graph.cpp
+++ b/metagraph/src/graph/representation/base/sequence_graph.cpp
@@ -476,6 +476,15 @@ ::call_kmers(const std::function<void(node_index,
     }, stop_early);
 }
 
+void DeBruijnGraph::map_to_contigs(std::string_view sequence,
+                                   const std::function<void(node_index, int64_t)> &callback,
+                                   const std::function<bool()> &terminate) const {
+    map_to_nodes(sequence, [&](node_index node) { callback(node, 0); }, terminate);
+}
+
+node_index DeBruijnGraph::get_contig_id(node_index node) const { return node; }
+node_index DeBruijnGraph::get_last_node_in_contig(node_index contig_id) const { return contig_id; }
+
 void DeBruijnGraph::print(std::ostream &out) const {
     std::string vertex_header("Vertex");
     vertex_header.resize(get_k(), ' ');
diff --git a/metagraph/src/graph/representation/base/sequence_graph.hpp b/metagraph/src/graph/representation/base/sequence_graph.hpp
index a1b8625b62..78d7455aa4 100644
--- a/metagraph/src/graph/representation/base/sequence_graph.hpp
+++ b/metagraph/src/graph/representation/base/sequence_graph.hpp
@@ -165,6 +165,17 @@ class DeBruijnGraph : public SequenceGraph {
     // Traverse the incoming edge
     virtual node_index traverse_back(node_index node, char prev_char) const = 0;
 
+    // If a graph has defined contigs, then map each k-mer in sequence to a
+    // representative node of the contig to which it maps and offset (traversal distance)
+    // to that representative node.
+    // If no contigs are defined, this functions identically to map_to_nodes
+    virtual void map_to_contigs(std::string_view sequence,
+                                const std::function<void(node_index, int64_t)> &callback,
+                                const std::function<bool()> &terminate = [](){ return false; }) const;
+
+    virtual node_index get_contig_id(node_index node) const;
+    virtual node_index get_last_node_in_contig(node_index contig_id) const;
+
     // Given a starting node and a sequence of edge labels, traverse the graph
     // forward. The traversal is terminated once terminate() returns true or
     // when the sequence is exhausted.
@@ -243,6 +254,8 @@ class DeBruijnGraph : public SequenceGraph {
 
     // Call all nodes that have no incoming edges
     virtual void call_source_nodes(const std::function<void(node_index)> &callback) const;
+
+    virtual bool is_monochromatic() const { return false; }
 };
 
 
diff --git a/metagraph/src/graph/representation/canonical_dbg.cpp b/metagraph/src/graph/representation/canonical_dbg.cpp
index 39b3798001..a85a4de9f8 100644
--- a/metagraph/src/graph/representation/canonical_dbg.cpp
+++ b/metagraph/src/graph/representation/canonical_dbg.cpp
@@ -161,6 +161,45 @@ void CanonicalDBG::map_to_nodes(std::string_view sequence,
     }, terminate);
 }
 
+void CanonicalDBG::map_to_contigs(std::string_view sequence,
+                                  const std::function<void(node_index, int64_t)> &callback,
+                                  const std::function<bool()> &terminate) const {
+    if (sequence.size() < get_k())
+        return;
+
+    if (const auto sshash = std::dynamic_pointer_cast<const DBGSSHash>(graph_)) {
+        sshash->map_to_contigs_with_rc<true>(sequence, [&](node_index node, int64_t offset, bool) {
+            callback(node, offset);
+        }, terminate);
+        return;
+    }
+
+    std::string rc(sequence);
+    ::reverse_complement(rc.begin(), rc.end());
+
+    std::vector<std::pair<node_index, int64_t>> rc_map;
+    rc_map.reserve(sequence.size() - get_k() + 1);
+
+    graph_->map_to_contigs(rc, [&](node_index node, int64_t offset) {
+        rc_map.emplace_back(node, offset);
+    }, terminate);
+
+    auto it = rc_map.rbegin();
+    graph_->map_to_contigs(sequence, [&](node_index node, int64_t offset) {
+        assert(it != rc_map.rend());
+        assert(node == npos || it->first == npos);
+
+        if (node != npos) {
+            callback(node, offset);
+        } else {
+            callback(it->first, it->second);
+        }
+
+        ++it;
+    }, terminate);
+    assert(it == rc_map.rend());
+}
+
 void CanonicalDBG::call_outgoing_kmers(node_index node,
                                        const std::string &spelling_hint,
                                        const OutgoingEdgeCallback &callback) const {
diff --git a/metagraph/src/graph/representation/canonical_dbg.hpp b/metagraph/src/graph/representation/canonical_dbg.hpp
index c4e4394019..f0e4566097 100644
--- a/metagraph/src/graph/representation/canonical_dbg.hpp
+++ b/metagraph/src/graph/representation/canonical_dbg.hpp
@@ -49,6 +49,10 @@ class CanonicalDBG : public DBGWrapper<DeBruijnGraph> {
                               const std::function<void(node_index)> &callback,
                               const std::function<bool()> &terminate = [](){ return false; }) const override final;
 
+    virtual void map_to_contigs(std::string_view sequence,
+                                const std::function<void(node_index, int64_t)> &callback,
+                                const std::function<bool()> &terminate = [](){ return false; }) const override final;
+
     // Traverse graph mapping sequence to the graph nodes
     // and run callback for each node until the termination condition is satisfied.
     // Guarantees that nodes are called in the same order as the input sequence
@@ -115,6 +119,8 @@ class CanonicalDBG : public DBGWrapper<DeBruijnGraph> {
 
     virtual bool operator==(const DeBruijnGraph &other) const override final;
 
+    virtual bool is_monochromatic() const override final { return graph_->is_monochromatic(); }
+
   private:
     const size_t cache_size_;
 
diff --git a/metagraph/src/graph/representation/hash/dbg_sshash.cpp b/metagraph/src/graph/representation/hash/dbg_sshash.cpp
index 07120a28e2..f1787c5be3 100644
--- a/metagraph/src/graph/representation/hash/dbg_sshash.cpp
+++ b/metagraph/src/graph/representation/hash/dbg_sshash.cpp
@@ -2,16 +2,23 @@
 
 #include <type_traits>
 
+#include <progress_bar.hpp>
+
 #include "common/seq_tools/reverse_complement.hpp"
 #include "common/threads/threading.hpp"
 #include "common/logger.hpp"
+#include "common/utils/string_utils.hpp"
 #include "common/algorithms.hpp"
 #include "kmer/kmer_extractor.hpp"
+#include "seq_io/sequence_io.hpp"
+#include "graph/representation/canonical_dbg.hpp"
 
 
 namespace mtg {
 namespace graph {
 
+const size_t kBufferSize = 10'000'000;
+
 #if _PROTEIN_GRAPH
 static constexpr uint16_t bits_per_char = sshash::aa_uint_kmer_t<uint64_t>::bits_per_char;
 #else
@@ -55,7 +62,11 @@ DBGSSHash::DBGSSHash(size_t k, Mode mode) : k_(k), num_nodes_(0), mode_(mode) {
     }
 }
 
-DBGSSHash::DBGSSHash(const std::string &input_filename, size_t k, Mode mode, size_t num_chars)
+DBGSSHash::DBGSSHash(const std::string &input_filename,
+                     size_t k,
+                     Mode mode,
+                     size_t num_chars,
+                     bool is_monochromatic)
       : DBGSSHash(k, mode) {
     if (k <= 1)
         throw std::domain_error("k must be at least 2");
@@ -89,6 +100,110 @@ DBGSSHash::DBGSSHash(const std::string &input_filename, size_t k, Mode mode, siz
         std::cout.copyfmt(orig_state);
 
     num_nodes_ = dict_size();
+
+    if (is_monochromatic) {
+        common::logger->trace("Marking colour boundaries");
+        sdsl::bit_vector id(num_nodes_);
+        {
+            ThreadPool thread_pool(get_num_threads());
+            ProgressBar progress_bar(num_nodes(),
+                                     "Parsing sequences",
+                                     std::cerr, !common::get_verbose());
+
+            auto process_sequence([&](const std::string &seq, const std::string &comment) {
+                auto indices = mtg::graph::map_to_nodes_sequentially(*this, seq);
+                assert(std::equal(indices.begin(), indices.end() - 1,
+                                  indices.begin() + 1, indices.end(),
+                                  [](node_index a, node_index b) { return a + 1 == b; }));
+                size_t pos = graph_index_to_sshash(indices[0]);
+                id[pos] = true;
+                auto split_string = utils::split_string(comment, " ");
+                size_t old_pos = pos;
+                size_t nkmers = seq.size() - k_ + 1;
+
+                for (const auto &part : split_string) {
+                    if (part[0] == 'C') {
+                        auto c_parts = utils::split_string(part, ":");
+                        assert(c_parts.size());
+                        id[pos] = true;
+                        pos += atoll(c_parts.back().c_str());
+                    }
+                }
+
+                if (pos == old_pos)
+                    pos += nkmers;
+
+                assert(pos == old_pos + nkmers);
+                return nkmers;
+            });
+
+            BatchAccumulator<std::pair<std::string, std::string>> batcher(
+                [&](std::vector<std::pair<std::string, std::string>>&& buffer) {
+                    thread_pool.enqueue([&](auto&& buffer) {
+                        size_t total_kmers = 0;
+                        for (const auto &[seq, comment] : buffer) {
+                            total_kmers += process_sequence(seq, comment);
+                        }
+                        progress_bar += total_kmers;
+                    }, std::move(buffer));
+                },
+                std::numeric_limits<size_t>::max(),
+                kBufferSize
+            );
+
+            seq_io::read_fasta_file_critical(input_filename, [&](auto *read_stream) {
+                batcher.push_and_pay(
+                    read_stream->seq.l + read_stream->comment.l,
+                    std::make_pair(
+                        std::string(read_stream->seq.s, read_stream->seq.l),
+                        std::string(read_stream->comment.s, read_stream->comment.l)
+                    )
+                );
+            });
+
+            thread_pool.join();
+        }
+
+        size_t update_batch = 10000;
+        ProgressBar progress_bar(num_nodes_,
+                                 "Marking unitig breakpoints",
+                                 std::cerr, !common::get_verbose());
+        std::atomic_thread_fence(std::memory_order_release);
+
+        std::unique_ptr<const CanonicalDBG> canonical;
+
+        if (mode_ == PRIMARY) {
+            canonical = std::make_unique<const CanonicalDBG>(std::shared_ptr<const DBGSSHash>(
+                std::shared_ptr<const DBGSSHash>{}, this
+            ));
+        }
+
+        auto is_breakpoint = [this,canonical=std::move(canonical)](node_index node) {
+            if (canonical) {
+                return !canonical->has_single_incoming(node) || !canonical->has_single_incoming(reverse_complement(node));
+            } else if (mode_ == CANONICAL) {
+                return !has_single_incoming(node) || !has_single_incoming(reverse_complement(node));
+            } else {
+                return !has_single_incoming(node);
+            }
+        };
+
+        #pragma omp parallel for num_threads(get_num_threads())
+        for (size_t p = 0; p < num_nodes_; ++p) {
+            node_index node = sshash_to_graph_index(p);
+            if (is_breakpoint(node))
+                set_bit(id.data(), p, std::memory_order_relaxed);
+
+            if (p && (p % update_batch) == 0)
+                progress_bar += update_batch;
+        }
+        std::atomic_thread_fence(std::memory_order_acquire);
+
+        progress_bar += num_nodes_ % update_batch;
+
+        monotig_id_ = bit_vector_rrr<>(std::move(id));
+        common::logger->trace("Marked {} boundaries", monotig_id_.num_set_bits());
+    }
 }
 
 std::string DBGSSHash::file_extension() const {
@@ -156,6 +271,108 @@ void DBGSSHash::map_to_nodes_with_rc<false>(std::string_view,
                                             const std::function<void(node_index, bool)>&,
                                             const std::function<bool()>&) const;
 
+void DBGSSHash::map_to_contigs(std::string_view sequence,
+                               const std::function<void(node_index, int64_t)>& callback,
+                               const std::function<bool()>& terminate) const {
+    if (!is_monochromatic()) {
+        DeBruijnGraph::map_to_contigs(sequence, callback, terminate);
+        return;
+    }
+
+    if (mode_ != CANONICAL) {
+        map_to_contigs_with_rc<false>(sequence, [&](node_index node, int64_t offset, bool) {
+            callback(node, offset);
+        });
+    } else {
+        map_to_contigs_with_rc<true>(sequence, [&](node_index node, int64_t offset, bool) {
+            callback(node, offset);
+        });
+    }
+}
+
+DBGSSHash::node_index DBGSSHash::get_contig_id(node_index node) const {
+    assert(node != npos);
+    if (is_monochromatic()) {
+        assert(monotig_id_.size() && monotig_id_[0]);
+        node_index contig_id = sshash_to_graph_index(monotig_id_.prev1(graph_index_to_sshash(node)));
+        assert(contig_id != npos);
+        assert(contig_id <= max_index());
+        return contig_id;
+    }
+
+    return DeBruijnGraph::get_contig_id(node);
+}
+
+DBGSSHash::node_index DBGSSHash::get_last_node_in_contig(node_index contig_id) const {
+    assert(contig_id != npos);
+    if (is_monochromatic()) {
+        assert(monotig_id_.size());
+        uint64_t contig_sshash_id = graph_index_to_sshash(contig_id);
+        assert(monotig_id_[contig_sshash_id]);
+
+        if (contig_sshash_id + 1 == monotig_id_.size())
+            return contig_id;
+
+        uint64_t next_contig = monotig_id_.next1(contig_sshash_id + 1);
+
+        if (next_contig == contig_sshash_id + 1)
+            return contig_id;
+
+        node_index last_node = sshash_to_graph_index(next_contig - 1);
+        assert(last_node != npos);
+        assert(last_node <= max_index());
+        return last_node;
+    }
+
+    return DeBruijnGraph::get_last_node_in_contig(contig_id);
+}
+
+template <bool with_rc>
+void DBGSSHash::map_to_contigs_with_rc(std::string_view sequence,
+                                       const std::function<void(node_index, int64_t, bool)>& callback,
+                                       const std::function<bool()>& terminate) const {
+    if (terminate() || sequence.size() < k_)
+        return;
+
+    if (!num_nodes()) {
+        for (size_t i = 0; i < sequence.size() - k_ + 1 && !terminate(); ++i) {
+            callback(npos, 0, false);
+        }
+        return;
+    }
+
+    std::visit([&](const auto &dict) {
+        map_to_nodes_with_rc_impl<with_rc>(k_, dict, sequence,
+            [&](sshash::lookup_result res) {
+                node_index node = sshash_to_graph_index(res.kmer_id);
+                if (node == npos) {
+                    res.kmer_id_in_contig = 0;
+                } else if (is_monochromatic()) {
+                    assert(monotig_id_.size() == dict_size());
+                    assert(monotig_id_[res.kmer_id] || res.kmer_id_in_contig);
+                    assert(monotig_id_[res.kmer_id - res.kmer_id_in_contig]);
+                    assert(monotig_id_.prev1(res.kmer_id) >= res.kmer_id - res.kmer_id_in_contig);
+                    res.kmer_id_in_contig = res.kmer_id - monotig_id_.prev1(res.kmer_id);
+                }
+
+                callback(node - res.kmer_id_in_contig,
+                         res.kmer_id_in_contig,
+                         res.kmer_orientation);
+            },
+            terminate
+        );
+    }, dict_);
+}
+
+template
+void DBGSSHash::map_to_contigs_with_rc<true>(std::string_view,
+                                             const std::function<void(node_index, int64_t, bool)>&,
+                                             const std::function<bool()>&) const;
+template
+void DBGSSHash::map_to_contigs_with_rc<false>(std::string_view,
+                                              const std::function<void(node_index, int64_t, bool)>&,
+                                              const std::function<bool()>&) const;
+
 void DBGSSHash::map_to_nodes(std::string_view sequence,
                              const std::function<void(node_index)>& callback,
                              const std::function<bool()>& terminate) const {
@@ -377,6 +594,8 @@ void DBGSSHash::serialize(std::ostream& out) const {
 
     if (num_nodes())
         std::visit([&](const auto &d) { saver.visit(d); }, dict_);
+
+    monotig_id_.serialize(out);
 }
 
 void DBGSSHash::serialize(const std::string& filename) const {
@@ -400,6 +619,8 @@ bool DBGSSHash::load(std::istream &in) {
     if (num_nodes_)
         std::visit([&](auto &d) { d.visit(loader); }, dict_);
 
+    monotig_id_.load(in);
+
     return true;
 }
 
diff --git a/metagraph/src/graph/representation/hash/dbg_sshash.hpp b/metagraph/src/graph/representation/hash/dbg_sshash.hpp
index 12c1a407bd..52563b184b 100644
--- a/metagraph/src/graph/representation/hash/dbg_sshash.hpp
+++ b/metagraph/src/graph/representation/hash/dbg_sshash.hpp
@@ -8,6 +8,7 @@
 #include <sdsl/uint256_t.hpp>
 
 #include "graph/representation/base/sequence_graph.hpp"
+#include "common/vectors/bit_vector_adaptive.hpp"
 
 namespace mtg::graph {
 
@@ -31,7 +32,7 @@ class DBGSSHash : public DeBruijnGraph {
                         sshash::dictionary<kmer_t<KmerInt256>>>;
 
     explicit DBGSSHash(size_t k, Mode mode = BASIC);
-    DBGSSHash(const std::string &input_filename, size_t k, Mode mode = BASIC, size_t num_chars = 0);
+    DBGSSHash(const std::string &input_filename, size_t k, Mode mode = BASIC, size_t num_chars = 0, bool is_monochromatic = false);
 
     // SequenceGraph overrides
     void add_sequence(
@@ -48,12 +49,25 @@ class DBGSSHash : public DeBruijnGraph {
             const std::function<void(node_index)>& callback,
             const std::function<bool()>& terminate = []() { return false; }) const override;
 
+    void map_to_contigs(std::string_view sequence,
+            const std::function<void(node_index, int64_t)>& callback,
+            const std::function<bool()>& terminate = []() { return false; }) const override;
+
+    node_index get_contig_id(node_index node) const override;
+    node_index get_last_node_in_contig(node_index contig_id) const override;
+
     template <bool with_rc = true>
     void map_to_nodes_with_rc(
             std::string_view sequence,
             const std::function<void(node_index, bool)>& callback,
             const std::function<bool()>& terminate = []() { return false; }) const;
 
+    template <bool with_rc = true>
+    void map_to_contigs_with_rc(
+            std::string_view sequence,
+            const std::function<void(node_index, int64_t, bool)>& callback,
+            const std::function<bool()>& terminate = []() { return false; }) const;
+
     uint64_t num_nodes() const override;
 
     bool load(std::istream& in);
@@ -72,6 +86,8 @@ class DBGSSHash : public DeBruijnGraph {
 
     Mode get_mode() const override final { return mode_; }
 
+    bool is_monochromatic() const override { return monotig_id_.size(); }
+
     node_index traverse(node_index node, char next_char) const override;
     node_index traverse_back(node_index node, char prev_char) const override;
 
@@ -116,6 +132,7 @@ class DBGSSHash : public DeBruijnGraph {
     size_t k_;
     size_t num_nodes_;
     Mode mode_;
+    bit_vector_rrr<> monotig_id_;
 
     size_t dict_size() const;
 };
diff --git a/metagraph/tests/annotation/test_aligner_labeled.cpp b/metagraph/tests/annotation/test_aligner_labeled.cpp
index bdeddccf7f..b67115a2bb 100644
--- a/metagraph/tests/annotation/test_aligner_labeled.cpp
+++ b/metagraph/tests/annotation/test_aligner_labeled.cpp
@@ -53,6 +53,7 @@ class LabeledAlignerTest : public ::testing::Test {};
 typedef ::testing::Types<std::pair<DBGHashFast, annot::ColumnCompressed<>>,
                          std::pair<DBGSuccinct, annot::ColumnCompressed<>>,
                          std::pair<DBGSSHash,   annot::ColumnCompressed<>>,
+                         std::pair<DBGSSHashMonochromatic, annot::ColumnCompressed<>>,
                          std::pair<DBGHashFast, annot::RowFlatAnnotator>,
                          std::pair<DBGSuccinct, annot::RowFlatAnnotator>,
                          std::pair<DBGSuccinct, annot::RowDiffColumnAnnotator>> FewGraphAnnotationPairTypes;
diff --git a/metagraph/tests/annotation/test_annotated_dbg.cpp b/metagraph/tests/annotation/test_annotated_dbg.cpp
index d1437aa725..5e864d6413 100644
--- a/metagraph/tests/annotation/test_annotated_dbg.cpp
+++ b/metagraph/tests/annotation/test_annotated_dbg.cpp
@@ -27,17 +27,32 @@ void check_labels(const AnnotatedDBG &anno_graph,
                   const std::string &sequence,
                   const std::vector<std::string> labels_present,
                   const std::vector<std::string> labels_not_present) {
+    const DeBruijnGraph &graph = anno_graph.get_graph();
     std::set<SequenceGraph::node_index> indices;
-    anno_graph.get_graph().map_to_nodes(
-        sequence,
-        [&](const auto &index) {
-            ASSERT_NE(SequenceGraph::npos, index);
-            indices.insert(index);
-            EXPECT_EQ(labels_present.size(), anno_graph.get_labels(index).size());
-            EXPECT_EQ(convert_to_set(labels_present),
-                      convert_to_set(anno_graph.get_labels(index)));
+    call_annotated_nodes_offsets(graph, sequence, [&](auto index, int64_t) {
+        ASSERT_NE(SequenceGraph::npos, index);
+        indices.insert(index);
+        auto cur_labels = anno_graph.get_stored_labels(index);
+        EXPECT_EQ(labels_present.size(), cur_labels.size());
+        EXPECT_EQ(convert_to_set(labels_present), convert_to_set(cur_labels));
+
+        if (graph.is_monochromatic()) {
+            DeBruijnGraph::node_index contig_id = graph.get_contig_id(index);
+            EXPECT_EQ(convert_to_set(anno_graph.get_labels(graph.get_node_sequence(contig_id))),
+                      convert_to_set(cur_labels));
+
+            DeBruijnGraph::node_index last_node = graph.get_last_node_in_contig(contig_id);
+            EXPECT_EQ(convert_to_set(anno_graph.get_labels(graph.get_node_sequence(last_node))),
+                      convert_to_set(cur_labels));
+
+            for (DeBruijnGraph::node_index node = contig_id + 1; node <= last_node; ++node) {
+                EXPECT_TRUE(anno_graph.get_stored_labels(node).empty());
+            }
         }
-    );
+    });
+
+    EXPECT_EQ(convert_to_set(labels_present),
+              convert_to_set(anno_graph.get_labels(sequence)));
 
     for (const auto &label : labels_present) {
         std::set<SequenceGraph::node_index> cur_indices;
@@ -54,7 +69,7 @@ void check_labels(const AnnotatedDBG &anno_graph,
                             std::back_inserter(diff));
         EXPECT_EQ(0u, diff.size())
             << diff.front()
-            << anno_graph.get_graph().get_node_sequence(diff.front());
+            << graph.get_node_sequence(diff.front());
     }
 }
 
@@ -985,6 +1000,7 @@ typedef ::testing::Types<std::pair<DBGBitmap, annot::ColumnCompressed<>>,
                          std::pair<DBGHashFast, annot::ColumnCompressed<>>,
                          std::pair<DBGSuccinct, annot::ColumnCompressed<>>,
                          std::pair<DBGSSHash, annot::ColumnCompressed<>>,
+                         std::pair<DBGSSHashMonochromatic, annot::ColumnCompressed<>>,
                          std::pair<DBGBitmap, annot::RowFlatAnnotator>,
                          std::pair<DBGHashString, annot::RowFlatAnnotator>,
                          std::pair<DBGHashOrdered, annot::RowFlatAnnotator>,
@@ -1015,6 +1031,7 @@ typedef ::testing::Types<std::pair<DBGBitmap, annot::ColumnCompressed<>>,
                          std::pair<DBGHashOrdered, annot::ColumnCompressed<>>,
                          std::pair<DBGHashFast, annot::ColumnCompressed<>>,
                          std::pair<DBGSSHash, annot::ColumnCompressed<>>,
+                         std::pair<DBGSSHashMonochromatic, annot::ColumnCompressed<>>,
                          std::pair<DBGBitmap, annot::RowFlatAnnotator>,
                          std::pair<DBGHashOrdered, annot::RowFlatAnnotator>,
                          std::pair<DBGHashFast, annot::RowFlatAnnotator>,
diff --git a/metagraph/tests/annotation/test_annotated_dbg_helpers.cpp b/metagraph/tests/annotation/test_annotated_dbg_helpers.cpp
index 39e387335e..8b7a8071a9 100644
--- a/metagraph/tests/annotation/test_annotated_dbg_helpers.cpp
+++ b/metagraph/tests/annotation/test_annotated_dbg_helpers.cpp
@@ -236,6 +236,7 @@ template std::unique_ptr<AnnotatedDBG> build_anno_graph<DBGHashOrdered, ColumnCo
 template std::unique_ptr<AnnotatedDBG> build_anno_graph<DBGHashFast, ColumnCompressed<>>(uint64_t, const std::vector<std::string> &, const std::vector<std::string>&, DeBruijnGraph::Mode, bool);
 template std::unique_ptr<AnnotatedDBG> build_anno_graph<DBGHashString, ColumnCompressed<>>(uint64_t, const std::vector<std::string> &, const std::vector<std::string>&, DeBruijnGraph::Mode, bool);
 template std::unique_ptr<AnnotatedDBG> build_anno_graph<DBGSSHash, ColumnCompressed<>>(uint64_t, const std::vector<std::string> &, const std::vector<std::string>&, DeBruijnGraph::Mode, bool);
+template std::unique_ptr<AnnotatedDBG> build_anno_graph<DBGSSHashMonochromatic, ColumnCompressed<>>(uint64_t, const std::vector<std::string> &, const std::vector<std::string>&, DeBruijnGraph::Mode, bool);
 
 template std::unique_ptr<AnnotatedDBG> build_anno_graph<DBGSuccinct, RowFlatAnnotator>(uint64_t, const std::vector<std::string> &, const std::vector<std::string>&, DeBruijnGraph::Mode, bool);
 template std::unique_ptr<AnnotatedDBG> build_anno_graph<DBGBitmap, RowFlatAnnotator>(uint64_t, const std::vector<std::string> &, const std::vector<std::string>&, DeBruijnGraph::Mode, bool);
diff --git a/metagraph/tests/graph/all/test_dbg_helpers.cpp b/metagraph/tests/graph/all/test_dbg_helpers.cpp
index 3af60c0cfb..4bc010875c 100644
--- a/metagraph/tests/graph/all/test_dbg_helpers.cpp
+++ b/metagraph/tests/graph/all/test_dbg_helpers.cpp
@@ -1,6 +1,10 @@
 #include "test_dbg_helpers.hpp"
 
+#include "../../annotation/test_annotated_dbg_helpers.hpp"
+#include "annotation/representation/column_compressed/annotate_column_compressed.hpp"
+
 #include "gtest/gtest.h"
+#include "graph/annotated_dbg.hpp"
 #include "graph/representation/canonical_dbg.hpp"
 #include "graph/representation/succinct/boss.hpp"
 #include "graph/representation/succinct/boss_construct.hpp"
@@ -43,6 +47,9 @@ template<> size_t max_test_k<DBGHashString>() {
 template<> size_t max_test_k<DBGSSHash>() {
     return 255 / DBGSSHash::kmer_t<uint64_t>::bits_per_char;
 }
+template<> size_t max_test_k<DBGSSHashMonochromatic>() {
+    return 255 / DBGSSHash::kmer_t<uint64_t>::bits_per_char;
+}
 
 template <class Graph>
 std::vector<std::string>
@@ -132,7 +139,9 @@ build_graph<DBGBitmap>(uint64_t k,
     return graph;
 }
 
-void writeFastaFile(const std::vector<std::string>& sequences, const std::string& outputFilename) {
+void writeFastaFile(const std::vector<std::string>& sequences,
+                    const std::vector<std::string>& headers,
+                    const std::string& outputFilename) {
     std::ofstream fastaFile(outputFilename);
 
     if (!fastaFile.is_open()) {
@@ -141,7 +150,7 @@ void writeFastaFile(const std::vector<std::string>& sequences, const std::string
     }
 
     for (size_t i = 0; i < sequences.size(); ++i) {
-        fastaFile << ">" << "\n" << sequences[i] << "\n";
+        fastaFile << ">" << headers[i] << "\n" << sequences[i] << "\n";
     }
 
     fastaFile.close();
@@ -171,7 +180,7 @@ build_graph<DBGSSHash>(uint64_t k,
         return std::make_shared<DBGSSHash>(k, mode);
 
     std::string dump_path = "../tests/data/sshash_sequences/contigs.fa";
-    writeFastaFile(contigs, dump_path);
+    writeFastaFile(contigs, std::vector<std::string>(contigs.size(), ""), dump_path);
 
     std::shared_ptr<DBGSSHash> graph;
     graph = std::make_shared<DBGSSHash>(dump_path, k, mode, num_chars);
@@ -183,6 +192,95 @@ build_graph<DBGSSHash>(uint64_t k,
     return graph;
 }
 
+template <>
+std::shared_ptr<DeBruijnGraph>
+build_graph<DBGSSHashMonochromatic>(uint64_t k,
+                                    std::vector<std::string> sequences,
+                                    DeBruijnGraph::Mode mode) {
+    if (sequences.empty())
+        return std::make_shared<DBGSSHash>(k, mode);
+
+    std::string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    std::vector<std::string> label_reserve;
+    label_reserve.reserve(alphabet.size());
+    for (char c : alphabet) {
+        label_reserve.emplace_back(1, c);
+    }
+
+    std::vector<std::string> labels;
+    labels.reserve(sequences.size());
+    for (size_t i = 0; i < sequences.size(); ++i) {
+        label_reserve[i % alphabet.size()] += std::string(i / alphabet.size(),
+                                                          alphabet[i % alphabet.size()]);
+        labels.emplace_back(label_reserve[i % alphabet.size()]);
+    }
+
+    // use DBGHashString to get contigs for SSHash
+    auto string_anno_graph = build_anno_graph<DBGHashFast, annot::ColumnCompressed<>>(k, sequences, labels, mode);
+    const auto &string_graph = string_anno_graph->get_graph();
+
+    std::vector<std::string> contigs;
+    std::vector<std::string> headers;
+    std::vector<std::string> monotigs;
+    size_t num_kmers = 0;
+    size_t num_chars = 0;
+    size_t num_kmers_monotigs = 0;
+    string_graph.call_sequences([&](const std::string &contig, const auto &path) {
+        num_kmers += path.size();
+        num_chars += contig.size();
+        contigs.emplace_back(contig);
+        auto begin = contig.begin();
+        auto end = contig.begin() + k;
+
+        auto &header = headers.emplace_back(std::to_string(contigs.size()));
+
+        auto sigs = string_anno_graph->get_top_label_signatures(contig, labels.size());
+        for (size_t i = 1; i + k <= contig.size(); ++i) {
+            for (size_t j = 0; j < sigs.size(); ++j) {
+                if (sigs[j].second[i] != sigs[j].second[i - 1]) {
+                    // we're at a breakpoint
+                    header += " C:i:" + std::to_string(end - begin + 1 - k);
+                    num_kmers_monotigs += end - begin - k + 1;
+                    monotigs.emplace_back(begin, end);
+                    begin = end - k + 1;
+                    assert(begin == contig.begin() + i);
+                    break;
+                }
+            }
+            ++end;
+        }
+
+        assert(end == contig.end());
+        if (end - begin + 1 - k > 0) {
+            header += " C:i:" + std::to_string(end - begin - k + 1);
+            num_kmers_monotigs += end - begin - k + 1;
+            monotigs.emplace_back(begin, end);
+        }
+    }, 1, mode != DeBruijnGraph::BASIC);
+
+    EXPECT_EQ(num_kmers, num_kmers_monotigs);
+
+    if (contigs.empty())
+        return std::make_shared<DBGSSHash>(k, mode);
+
+    for (const auto &contig : monotigs) {
+        EXPECT_EQ(string_anno_graph->get_labels(contig),
+                  string_anno_graph->get_labels(contig, 1.0));
+    }
+
+    std::string dump_path = "../tests/data/sshash_sequences/contigs.fa";
+    writeFastaFile(contigs, headers, dump_path);
+
+    std::shared_ptr<DBGSSHash> graph;
+    graph = std::make_shared<DBGSSHash>(dump_path, k, mode, num_chars, true);
+
+    if (mode == DeBruijnGraph::PRIMARY)
+        return std::make_shared<CanonicalDBG>(
+                std::static_pointer_cast<DeBruijnGraph>(graph), 2 /* cache size */);
+
+    return graph;
+}
+
 template <>
 std::shared_ptr<DeBruijnGraph>
 build_graph<DBGSuccinct>(uint64_t k,
@@ -344,6 +442,10 @@ template
 std::shared_ptr<DeBruijnGraph>
 build_graph_batch<DBGSSHash>(uint64_t, std::vector<std::string>, DeBruijnGraph::Mode);
 
+template
+std::shared_ptr<DeBruijnGraph>
+build_graph_batch<DBGSSHashMonochromatic>(uint64_t, std::vector<std::string>, DeBruijnGraph::Mode);
+
 template <>
 std::shared_ptr<DeBruijnGraph>
 build_graph_batch<DBGBitmap>(uint64_t k,
@@ -550,6 +652,7 @@ template bool check_graph<DBGHashOrdered>(const std::string &, DeBruijnGraph::Mo
 template bool check_graph<DBGHashFast>(const std::string &, DeBruijnGraph::Mode, bool);
 template bool check_graph<DBGHashString>(const std::string &, DeBruijnGraph::Mode, bool);
 template bool check_graph<DBGSSHash>(const std::string &, DeBruijnGraph::Mode, bool);
+template bool check_graph<DBGSSHashMonochromatic>(const std::string &, DeBruijnGraph::Mode, bool);
 
 } // namespace test
 } // namespace mtg
diff --git a/metagraph/tests/graph/all/test_dbg_helpers.hpp b/metagraph/tests/graph/all/test_dbg_helpers.hpp
index bf394da089..d770d6134b 100644
--- a/metagraph/tests/graph/all/test_dbg_helpers.hpp
+++ b/metagraph/tests/graph/all/test_dbg_helpers.hpp
@@ -53,6 +53,13 @@ class DBGSuccinctCached : public DBGSuccinct {
           : DBGSuccinct(std::forward<Args>(args)...) {}
 };
 
+class DBGSSHashMonochromatic : public DBGSSHash {
+  public:
+    template <typename... Args>
+    DBGSSHashMonochromatic(Args&&... args)
+          : DBGSSHash(std::forward<Args>(args)...) {}
+};
+
 template <class Graph>
 std::shared_ptr<DeBruijnGraph>
 build_graph(uint64_t k,
@@ -93,6 +100,7 @@ typedef ::testing::Types<DBGBitmap,
                          DBGHashOrdered,
                          DBGHashFast,
                          DBGSSHash,
+                         DBGSSHashMonochromatic,
                          DBGSuccinct,
                          DBGSuccinctIndexed<1>,
                          DBGSuccinctIndexed<2>,
diff --git a/metagraph/tests/graph/test_canonical_dbg.cpp b/metagraph/tests/graph/test_canonical_dbg.cpp
index e0b3b0b8d0..8fc5b5643c 100644
--- a/metagraph/tests/graph/test_canonical_dbg.cpp
+++ b/metagraph/tests/graph/test_canonical_dbg.cpp
@@ -38,7 +38,8 @@ typedef ::testing::Types<DBGBitmap,
                          DBGSuccinct,
                          DBGSuccinctBloom<4, 1>,
                          DBGSuccinctCached,
-                         DBGSSHash> CanonicalGraphTypes;
+                         DBGSSHash,
+                         DBGSSHashMonochromatic> CanonicalGraphTypes;
 
 TYPED_TEST_SUITE(CanonicalDBGTest, CanonicalGraphTypes);
 
diff --git a/metagraph/tests/graph/test_dbg_canonical.cpp b/metagraph/tests/graph/test_dbg_canonical.cpp
index ef88f0caa9..e7c46e2d4e 100644
--- a/metagraph/tests/graph/test_dbg_canonical.cpp
+++ b/metagraph/tests/graph/test_dbg_canonical.cpp
@@ -26,7 +26,8 @@ typedef ::testing::Types<DBGBitmap,
                          DBGSuccinct,
                          DBGSuccinctBloom<4, 1>,
                          DBGSuccinctCached,
-                         DBGSSHash> CanonicalGraphTypes;
+                         DBGSSHash,
+                         DBGSSHashMonochromatic> CanonicalGraphTypes;
 TYPED_TEST_SUITE(DeBruijnGraphCanonicalTest, CanonicalGraphTypes);