diff --git a/src/config.rs b/src/config.rs
index 806d2c8..a0c0404 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -392,54 +392,90 @@ fn parse_raw_config(raw_config: RawConfig) -> (Bindings, HashMap<String, String>
             }
             if let Ok(event) = Axis::from_str(event) {
                 if !bindings.movements.contains_key(&Event::Axis(event)) {
-                    bindings
-                        .movements
-                        .insert(Event::Axis(event), HashMap::from([(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."))]));
+                    bindings.movements.insert(
+                        Event::Axis(event),
+                        HashMap::from([(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        )]),
+                    );
                 } else {
                     bindings
                         .movements
                         .get_mut(&Event::Axis(event))
                         .unwrap()
-                        .insert(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."));
+                        .insert(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        );
                 }
             } else if let Ok(event) = Key::from_str(event) {
                 if !bindings.movements.contains_key(&Event::Key(event)) {
-                    bindings
-                        .movements
-                        .insert(Event::Key(event), HashMap::from([(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."))]));
+                    bindings.movements.insert(
+                        Event::Key(event),
+                        HashMap::from([(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        )]),
+                    );
                 } else {
                     bindings
                         .movements
                         .get_mut(&Event::Key(event))
                         .unwrap()
-                        .insert(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."));
+                        .insert(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        );
                 }
             }
         } else {
             let modifiers: Vec<Event> = Vec::new();
             if let Ok(event) = Axis::from_str(input.as_str()) {
                 if !bindings.movements.contains_key(&Event::Axis(event)) {
-                    bindings
-                        .movements
-                        .insert(Event::Axis(event), HashMap::from([(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."))]));
+                    bindings.movements.insert(
+                        Event::Axis(event),
+                        HashMap::from([(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        )]),
+                    );
                 } else {
                     bindings
                         .movements
                         .get_mut(&Event::Axis(event))
                         .unwrap()
-                        .insert(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."));
+                        .insert(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        );
                 }
             } else if let Ok(event) = Key::from_str(input.as_str()) {
                 if !bindings.movements.contains_key(&Event::Key(event)) {
-                    bindings
-                        .movements
-                        .insert(Event::Key(event), HashMap::from([(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."))]));
+                    bindings.movements.insert(
+                        Event::Key(event),
+                        HashMap::from([(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        )]),
+                    );
                 } else {
                     bindings
                         .movements
                         .get_mut(&Event::Key(event))
                         .unwrap()
-                        .insert(modifiers, Relative::from_str(output.as_str()).expect("Invalid movement in [movements]."));
+                        .insert(
+                            modifiers,
+                            Relative::from_str(output.as_str())
+                                .expect("Invalid movement in [movements]."),
+                        );
                 }
             }
         }
diff --git a/src/event_reader.rs b/src/event_reader.rs
index 2bcedec..ed67f68 100644
--- a/src/event_reader.rs
+++ b/src/event_reader.rs
@@ -1,5 +1,5 @@
 use crate::active_client::*;
-use crate::config::{parse_modifiers, Associations, Axis, Event, Relative, Cursor, Scroll};
+use crate::config::{parse_modifiers, Associations, Axis, Cursor, Event, Relative, Scroll};
 use crate::udev_monitor::Environment;
 use crate::virtual_devices::VirtualDevices;
 use crate::Config;
@@ -328,7 +328,13 @@ impl EventReader {
                 .unwrap()
                 .name
         );
-        tokio::join!(self.event_loop(), self.cursor_loop(), self.scroll_loop(), self.key_cursor_loop(), self.key_scroll_loop());
+        tokio::join!(
+            self.event_loop(),
+            self.cursor_loop(),
+            self.scroll_loop(),
+            self.key_cursor_loop(),
+            self.key_scroll_loop()
+        );
     }
 
     pub async fn event_loop(&self) {
@@ -1448,7 +1454,7 @@ impl EventReader {
     pub async fn key_cursor_loop(&self) {
         let (speed, acceleration, mut current_speed) = (
             if self.settings.cursor.speed == 0 {
-                return
+                return;
             } else {
                 self.settings.cursor.speed
             },
@@ -1457,7 +1463,7 @@ impl EventReader {
             } else {
                 self.settings.cursor.acceleration.abs()
             },
-            self.settings.cursor.speed as f32
+            self.settings.cursor.speed as f32,
         );
         while *self.device_is_connected.lock().await {
             {
@@ -1471,14 +1477,20 @@ impl EventReader {
                     }
                     if cursor_movement.0 != 0 {
                         let mut virt_dev = self.virt_dev.lock().await;
-                        let virtual_event_x: InputEvent =
-                            InputEvent::new_now(EventType::RELATIVE, 0, cursor_movement.0 * current_speed as i32);
+                        let virtual_event_x: InputEvent = InputEvent::new_now(
+                            EventType::RELATIVE,
+                            0,
+                            cursor_movement.0 * current_speed as i32,
+                        );
                         virt_dev.axis.emit(&[virtual_event_x]).unwrap();
                     }
                     if cursor_movement.1 != 0 {
                         let mut virt_dev = self.virt_dev.lock().await;
-                        let virtual_event_y: InputEvent =
-                            InputEvent::new_now(EventType::RELATIVE, 1, cursor_movement.1 * current_speed as i32);
+                        let virtual_event_y: InputEvent = InputEvent::new_now(
+                            EventType::RELATIVE,
+                            1,
+                            cursor_movement.1 * current_speed as i32,
+                        );
                         virt_dev.axis.emit(&[virtual_event_y]).unwrap();
                     }
                 }
@@ -1490,7 +1502,7 @@ impl EventReader {
     pub async fn key_scroll_loop(&self) {
         let (speed, acceleration, mut current_speed) = (
             if self.settings.scroll.speed == 0 {
-                return
+                return;
             } else {
                 self.settings.scroll.speed
             },
@@ -1499,7 +1511,7 @@ impl EventReader {
             } else {
                 self.settings.scroll.acceleration.abs()
             },
-            self.settings.scroll.speed as f32
+            self.settings.scroll.speed as f32,
         );
         while *self.device_is_connected.lock().await {
             {
@@ -1513,13 +1525,19 @@ impl EventReader {
                     }
                     let mut virt_dev = self.virt_dev.lock().await;
                     if scroll_movement.0 != 0 {
-                        let virtual_event_x: InputEvent =
-                            InputEvent::new_now(EventType::RELATIVE, 12, scroll_movement.0 * current_speed as i32);
+                        let virtual_event_x: InputEvent = InputEvent::new_now(
+                            EventType::RELATIVE,
+                            12,
+                            scroll_movement.0 * current_speed as i32,
+                        );
                         virt_dev.axis.emit(&[virtual_event_x]).unwrap();
                     }
                     if scroll_movement.1 != 0 {
-                        let virtual_event_y: InputEvent =
-                            InputEvent::new_now(EventType::RELATIVE, 11, scroll_movement.1 * current_speed as i32);
+                        let virtual_event_y: InputEvent = InputEvent::new_now(
+                            EventType::RELATIVE,
+                            11,
+                            scroll_movement.1 * current_speed as i32,
+                        );
                         virt_dev.axis.emit(&[virtual_event_y]).unwrap();
                     }
                 }