diff --git a/src/device/sequencer.rs b/src/device/sequencer.rs
index 0b4f2345..f246aa0c 100644
--- a/src/device/sequencer.rs
+++ b/src/device/sequencer.rs
@@ -112,52 +112,59 @@ impl Sequencer {
         let frames = scope.n_frames() as usize;
         let mut output: Vec<Option<Vec<Vec<u8>>>> = vec![None;frames];
 
-        // Read from input
+        // Read from input, write inputs to sequence and/or output
         for event in self.input_port.iter(scope) {
-
-            // Write to output
-            if self.monitoring {
-                let t = event.time as usize;
-                if output[t].is_none() {
-                    output[t] = Some(vec![]);
-                }
-                if let Some(Some(frame)) = output.get_mut(t) {
-                    frame.push(event.bytes.into())
-                }
-            }
-
-            // Write to sequence
-            if self.recording {
-                let tick = tick as u32;
-                match midly::live::LiveEvent::parse(event.bytes).unwrap() {
-                    midly::live::LiveEvent::Midi { channel: _, message } => match message {
-                        midly::MidiMessage::NoteOn { key, vel: _ } => {
-                            self.notes_on[key.as_int() as usize] = true;
+            let tick = tick as u32;
+            let msg  = midly::live::LiveEvent::parse(event.bytes).unwrap();
+            match msg {
+                midly::live::LiveEvent::Midi { channel: _, message } => match message {
+                    midly::MidiMessage::NoteOn { key, vel: _ } => {
+                        self.notes_on[key.as_int() as usize] = true;
+                        if self.monitoring {
+                            let t = event.time as usize;
+                            if output[t].is_none() {
+                                output[t] = Some(vec![]);
+                            }
+                            if let Some(Some(frame)) = output.get_mut(t) {
+                                frame.push(event.bytes.into())
+                            }
+                        }
+                        if self.recording {
                             let contains = sequence.contains_key(&tick);
                             if contains {
                                 sequence.get_mut(&tick).unwrap().push(message.clone());
                             } else {
                                 sequence.insert(tick, vec![message.clone()]);
                             }
-                        },
-                        midly::MidiMessage::NoteOff { key, vel: _ } => {
-                            self.notes_on[key.as_int() as usize] = false;
+                        }
+                    },
+                    midly::MidiMessage::NoteOff { key, vel: _ } => {
+                        self.notes_on[key.as_int() as usize] = false;
+                        if self.monitoring {
+                            let t = event.time as usize;
+                            if output[t].is_none() {
+                                output[t] = Some(vec![]);
+                            }
+                            if let Some(Some(frame)) = output.get_mut(t) {
+                                frame.push(event.bytes.into())
+                            }
+                        }
+                        if self.recording {
                             let contains = sequence.contains_key(&tick);
                             if contains {
                                 sequence.get_mut(&tick).unwrap().push(message.clone());
                             } else {
                                 sequence.insert(tick, vec![message.clone()]);
                             }
-                        },
-                        _ => {}
+                        }
                     },
                     _ => {}
-                }
+                },
+                _ => {}
             }
-
         }
 
-        // Play from sequence
+        // Read from sequence
         if self.playing == TransportState::Rolling {
             let frame = transport.pos.frame() as usize;
             let quant = self.timebase.fpb() as usize * self.steps / self.resolution;
@@ -182,6 +189,7 @@ impl Sequencer {
             }
         }
 
+        // Write from monitor and/or sequence
         let mut writer = self.output_port.writer(scope);
         for t in 0..scope.n_frames() {
             if let Some(Some(frame)) = output.get_mut(t as usize) {
@@ -194,41 +202,6 @@ impl Sequencer {
             }
         }
 
-        ////
-
-        if self.playing == TransportState::Rolling {
-        }
-        for event in self.input_port.iter(scope) {
-            if self.monitoring {
-                writer.write(&event).expect(&format!("{event:?}"))
-            }
-            if self.recording {
-                match midly::live::LiveEvent::parse(event.bytes).unwrap() {
-                    midly::live::LiveEvent::Midi { channel: _, message } => match message {
-                        midly::MidiMessage::NoteOn { key, vel: _ } => {
-                            self.notes_on[key.as_int() as usize] = true;
-                            let contains = sequence.contains_key(&(tick as u32));
-                            if contains {
-                                sequence.get_mut(&(tick as u32)).unwrap().push(message.clone());
-                            } else {
-                                sequence.insert(tick as u32, vec![message.clone()]);
-                            }
-                        },
-                        midly::MidiMessage::NoteOff { key, vel: _ } => {
-                            self.notes_on[key.as_int() as usize] = false;
-                            let contains = sequence.contains_key(&(tick as u32));
-                            if contains {
-                                sequence.get_mut(&(tick as u32)).unwrap().push(message.clone());
-                            } else {
-                                sequence.insert(tick as u32, vec![message.clone()]);
-                            }
-                        },
-                        _ => {}
-                    },
-                    _ => {}
-                }
-            }
-        }
         Control::Continue
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 5a312c60..3d65ae4e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -23,6 +23,8 @@ fn main () -> Result<(), Box<dyn Error>> {
     let timebase  = transport.state.lock().unwrap().timebase();
     crate::device::run(Chain::new("Chain#0000", vec![
         Box::new(Sequencer::new("Phrase#000", &timebase)?),
-        Box::new(Plugin::new("Plugin#000")?),
+        Box::new(Sequencer::new("Phrase#001", &timebase)?),
+        //Box::new(Sequencer::new("Phrase#002", &timebase)?),
+        //Box::new(Plugin::new("Plugin#000")?),
     ])?)
 }