diff --git a/Code/ldpc/src/decoder/bit_flip.rs b/Code/ldpc/src/decoder/bit_flip.rs
index bd57994..8343c6a 100644
--- a/Code/ldpc/src/decoder/bit_flip.rs
+++ b/Code/ldpc/src/decoder/bit_flip.rs
@@ -1,3 +1,5 @@
+use rand::RngExt;
+
 use crate::code::LdpcCode;
 
 pub struct BitFlipDecoder<'a> {
diff --git a/Code/ldpc/src/encoder/dense.rs b/Code/ldpc/src/encoder/dense.rs
index f009ced..15c4a4a 100644
--- a/Code/ldpc/src/encoder/dense.rs
+++ b/Code/ldpc/src/encoder/dense.rs
@@ -7,6 +7,7 @@ pub struct DenseEncoder {
     pub k: usize,
     pub n: usize,
     pub col_swaps: Vec<(usize, usize)>,
+    pub rank: usize,
 }
 
 impl DenseEncoder {
@@ -33,6 +34,7 @@ impl DenseEncoder {
             k,
             n,
             col_swaps,
+            rank,
         }
     }
 
@@ -48,10 +50,25 @@ impl DenseEncoder {
             .collect();
 
         // Reverse les changement de colonnes
-        for &(c1, c2) in self.col_swaps.iter().rev() {
-            codeword.swap(c1, c2);
-        }
+        // for &(c1, c2) in self.col_swaps.iter().rev() {
+        //     codeword.swap(c1, c2);
+        // }
+        self.g_matrix
+            .apply_inverse_permutation(&mut codeword, &self.col_swaps);
 
         codeword
     }
+
+    pub fn extract_message(&self, decoded_codeword: &[u8]) -> Vec<u8> {
+        let mut working_copy = decoded_codeword.to_vec();
+
+        self.g_matrix
+            .apply_permutation(&mut working_copy, &self.col_swaps);
+
+        let mut message = Vec::with_capacity(self.k);
+        for i in 0..self.k {
+            message.push(working_copy[self.rank + i]);
+        }
+        message
+    }
 }
diff --git a/Code/ldpc/src/main.rs b/Code/ldpc/src/main.rs
index 76ebf54..0ffed2d 100644
--- a/Code/ldpc/src/main.rs
+++ b/Code/ldpc/src/main.rs
@@ -29,6 +29,6 @@ fn main() {
     // let res = Analyzer::run_batch(config);
     // Analyzer::save_csv(&res, "ldpc_analysis_results.csv");
 
-    let message = "Je";
-    simulation::run_simulation(message, 3, 6, 0.02);
+    let message = "Je suis un test";
+    simulation::run_simulation(message, 3, 6, 0.01);
 }
diff --git a/Code/ldpc/src/matrix.rs b/Code/ldpc/src/matrix.rs
index ea9605b..590773b 100644
--- a/Code/ldpc/src/matrix.rs
+++ b/Code/ldpc/src/matrix.rs
@@ -130,4 +130,16 @@ impl MatrixGF2 {
         }
         (rank, col_swaps)
     }
+
+    pub fn apply_inverse_permutation(&self, data: &mut [u8], swaps: &[(usize, usize)]) {
+        for &(c1, c2) in swaps.iter().rev() {
+            data.swap(c1, c2);
+        }
+    }
+
+    pub fn apply_permutation(&self, data: &mut [u8], swaps: &[(usize, usize)]) {
+        for &(c1, c2) in swaps.iter() {
+            data.swap(c1, c2);
+        }
+    }
 }
diff --git a/Code/ldpc/src/simulation.rs b/Code/ldpc/src/simulation.rs
index 530426d..954a083 100644
--- a/Code/ldpc/src/simulation.rs
+++ b/Code/ldpc/src/simulation.rs
@@ -39,7 +39,9 @@ pub fn run_simulation(text: &str, wc: usize, wr: usize, error_prob: f64) {
     println!("Encodage");
 
     let mut rng = rand::rng();
-    let message: Vec<u8> = (0..k).map(|_| rng.random_range(0..2)).collect();
+    // let message: Vec<u8> = (0..k).map(|_| rng.random_range(0..2)).collect();
+    let mut message = message_bits.clone();
+    message.resize(encoder.k, 0);
 
     let codeword = encoder.encode(&message);
 
@@ -71,8 +73,8 @@ pub fn run_simulation(text: &str, wc: usize, wr: usize, error_prob: f64) {
 
     match decoder.decode(&received, max_iter) {
         Some(decoded) => {
-            let decoded_message = &decoded[0..encoder.k];
-            let res_text = utils::bits_to_string(decoded_message);
+            let decoded_message_bits = encoder.extract_message(&decoded);
+            let res_text = utils::bits_to_string(&decoded_message_bits);
             if decoded == codeword {
                 println!("  -> Réussite");
             } else {
@@ -81,7 +83,8 @@ pub fn run_simulation(text: &str, wc: usize, wr: usize, error_prob: f64) {
             println!("  -> Texte recu : {}", res_text);
         }
         None => {
-            let failed_text = utils::bits_to_string(&received[0..encoder.k]);
+            let rec_bits = encoder.extract_message(&received);
+            let failed_text = utils::bits_to_string(&rec_bits);
             println!(
                 "  -> Echec : impossible decorriger après {} itérations",
                 max_iter