diff --git a/Cargo.lock b/Cargo.lock
index ad1ee090f..cf5afc858 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1511,6 +1511,7 @@ dependencies = [
  "proptest",
  "rand",
  "regex",
+ "thiserror",
  "topological-sort",
  "walkdir",
 ]
diff --git a/text/Cargo.toml b/text/Cargo.toml
index 10554d3ad..2689da69b 100644
--- a/text/Cargo.toml
+++ b/text/Cargo.toml
@@ -15,6 +15,7 @@ topological-sort = "0.2"
 regex.workspace = true
 chrono.workspace = true
 libc.workspace = true
+thiserror = "1.0"
 notify-debouncer-full = "0.3"
 diff = "0.1"
 dirs = "5.0"
@@ -99,6 +100,10 @@ path = "./paste.rs"
 name = "pr"
 path = "./pr.rs"
 
+[[bin]]
+name = "sed"
+path = "./sed.rs"
+
 [[bin]]
 name = "tsort"
 path = "./tsort.rs"
diff --git a/text/sed.rs b/text/sed.rs
new file mode 100644
index 000000000..7c4376c98
--- /dev/null
+++ b/text/sed.rs
@@ -0,0 +1,2486 @@
+//
+// Copyright (c) 2024 Hemi Labs, Inc.
+//
+// This file is part of the posixutils-rs project covered under
+// the MIT License.  For the full license text, please see the LICENSE
+// file in the root directory of this project.
+// SPDX-License-Identifier: MIT
+//
+
+use clap::{command, Parser};
+use gettextrs::{bind_textdomain_codeset, gettext, setlocale, textdomain, LocaleCategory};
+use libc::{
+    ioctl, regcomp, regex_t, regexec, regmatch_t, winsize, REG_EXTENDED, STDERR_FILENO,
+    STDIN_FILENO, STDOUT_FILENO, TIOCGWINSZ,
+};
+use std::sync::Mutex;
+use std::{
+    collections::{HashMap, HashSet},
+    ffi::CString,
+    fmt::{self, Debug},
+    fs::File,
+    io::{BufRead, BufReader, Error, ErrorKind, Write},
+    mem::MaybeUninit,
+    ops::Range,
+    path::PathBuf,
+};
+
+static ERE: Mutex<bool> = Mutex::new(false);
+
+#[derive(Parser, Debug, Clone)]
+#[command(version, about = gettext("sed - stream editor"))]
+struct Args {
+    #[arg(short = 'E', help=gettext("Match using extended regular expressions."))]
+    ere: bool,
+
+    #[arg(short = 'n', help=gettext("Suppress the default output. Only lines explicitly selected for output are written."))]
+    quiet: bool,
+
+    #[arg(short = 'e', help=gettext("Add the editing commands specified by the script option-argument to the end of the script of editing commands."))]
+    script: Vec<String>,
+
+    #[arg(short = 'f', name = "SCRIPT_FILE", help=gettext("Add the editing commands in the file script_file to the end of the script of editing commands."))]
+    script_file: Vec<PathBuf>,
+
+    #[arg(help=gettext("A pathname of a file whose contents are read and edited."))]
+    file: Vec<String>,
+}
+
+impl Args {
+    // Get ordered script sources from [-e script] and [-f script_file] manually.
+    fn get_raw_script() -> Result<String, SedError> {
+        let mut raw_scripts: Vec<String> = vec![];
+
+        let args: Vec<String> = std::env::args().skip(1).collect();
+        let mut args_iter = args.iter();
+
+        while let Some(arg) = args_iter.next() {
+            match arg.as_str() {
+                "-e" => {
+                    // Can unwrap because `-e` is already validated by `clap`.
+                    let e_script = args_iter.next().unwrap();
+                    for raw_script_line in e_script.split('\n') {
+                        raw_scripts.push(raw_script_line.to_string());
+                    }
+                    if let Some(script) = raw_scripts.last_mut() {
+                        *script += "\n;";
+                    }
+                }
+                "-f" => {
+                    // Can unwrap because `-f` is already validated by `clap`.
+                    let script_file =
+                        File::open(args_iter.next().unwrap()).map_err(SedError::Io)?;
+                    let reader = BufReader::new(script_file);
+                    for line in reader.lines() {
+                        let raw_script = line.map_err(SedError::Io)?;
+                        raw_scripts.push(raw_script);
+                    }
+                    if let Some(script) = raw_scripts.last_mut() {
+                        *script += "\n;";
+                    }
+                }
+                _ => continue,
+            }
+        }
+
+        Ok(raw_scripts.join("\n"))
+    }
+
+    /// Creates [`Sed`] from [`Args`], if [`Script`]
+    /// parsing is failed, then returns error
+    fn try_to_sed(mut self: Args) -> Result<Sed, SedError> {
+        let mut raw_script = Self::get_raw_script()?;
+
+        if raw_script.is_empty() {
+            if self.file.is_empty() {
+                return Err(SedError::NoScripts);
+            } else {
+                // Neither [-e script] nor [-f script_file] is supplied and [file...] is not empty
+                // then consider first [file...] as single script.
+                for raw_script_line in self.file.remove(0).split('\n') {
+                    raw_script.push_str(raw_script_line);
+                }
+            }
+        }
+
+        // If no [file...] were supplied or single file is considered to to be script, then
+        // sed must read input from STDIN.
+        if self.file.is_empty() {
+            self.file.push("-".to_string());
+        }
+
+        let script = Script::parse(raw_script)?;
+        script.check_labels()?;
+
+        Ok(Sed {
+            ere: self.ere,
+            quiet: self.quiet,
+            script,
+            input_sources: self.file,
+            pattern_space: String::new(),
+            hold_space: String::new(),
+            current_file: None,
+            current_line: 0,
+            has_replacements_since_t: false,
+            last_regex: None,
+            is_last_line: false,
+            current_end: None,
+            next_line: String::new(),
+        })
+    }
+}
+
+/// Errors that can be returned by [`Sed`] and its inner functions
+#[derive(thiserror::Error, Debug)]
+enum SedError {
+    /// Sed didn't get script for processing input files
+    #[error("none script was supplied")]
+    NoScripts,
+    /// [`Script`] doesn't contain label that used in
+    /// [`Command::BranchToLabel`] or [`Command::Test`]
+    #[error("script doesn't contain label '{}'", .0)]
+    NoLabel(String),
+    /// [`Command::Replace`] pattern is empty and script doesn't has last regex
+    #[error("no previous regular expression")]
+    NoRegex,
+    /// Files, stdin read/write errors
+    #[error("{0}")]
+    Io(#[from] std::io::Error),
+    /// Sed can`t parse raw script string.
+    /// Can't parse string, reason is:
+    #[error("{}{}", .0, format_error_position(*(.1)))]
+    ScriptParse(String, Option<(usize, usize)>),
+    /// Runtime error when processing file
+    #[error("read {}: {}", .0, .1)]
+    Runtime(String, String),
+}
+
+/// Define line number or range limits of [`Address`]
+/// for applying [`Command`]
+#[derive(Clone)]
+enum AddressToken {
+    /// Line number
+    Number(usize),
+    /// Last line
+    Last,
+    /// Context related line number that
+    /// calculated from this BRE match
+    Pattern(regex_t, String),
+    /// Used for handling char related exceptions, when parsing [`AddressRange`]
+    Delimiter,
+}
+
+impl PartialEq for AddressToken {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (AddressToken::Number(a), AddressToken::Number(b)) => a == b,
+            (AddressToken::Last, AddressToken::Last) => true,
+            (AddressToken::Pattern(..), AddressToken::Pattern(..)) => true,
+            (AddressToken::Delimiter, AddressToken::Delimiter) => true,
+            _ => false,
+        }
+    }
+}
+
+impl Eq for AddressToken {}
+
+impl Debug for AddressToken {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            AddressToken::Number(n) => f
+                .debug_struct("AddressToken::Number")
+                .field("0", n)
+                .finish(),
+            AddressToken::Last => f.debug_struct("AddressToken::Last").finish(),
+            AddressToken::Pattern(_, pattern) => f
+                .debug_struct(&format!("AddressToken::Pattern({pattern})"))
+                .finish(),
+            AddressToken::Delimiter => f.debug_struct("AddressToken::Delimiter").finish(),
+        }
+    }
+}
+
+/// List of [`AddressToken`]s that defines line position or range
+#[derive(Debug, Clone)]
+struct AddressRange {
+    /// Address range limits
+    limits: Vec<AddressToken>,
+    /// Defines what range limits is passed
+    /// in current processing file for current [`Command`]
+    passed: Option<(bool, bool)>,
+    /// Defines what range limits is currently raised
+    /// in current processing file for current [`Command`]
+    on_limits: Option<(bool, bool)>,
+    /// Inverse fulfillment of [`AddressRange`] conditions
+    is_negative: bool,
+}
+
+impl AddressRange {
+    fn new(limits: Vec<AddressToken>, is_negative: bool) -> Result<Option<Self>, SedError> {
+        let state = match limits.len() {
+            i if i > 2 => {
+                return Err(SedError::ScriptParse(
+                    "address isn't empty, position or range".to_string(),
+                    None,
+                ))
+            }
+            2 => Some((false, false)),
+            0 => return Ok(None),
+            _ => None,
+        };
+
+        Ok(Some(Self {
+            limits,
+            passed: state,
+            on_limits: state,
+            is_negative,
+        }))
+    }
+}
+
+/// Address define line position or range for
+/// applying [`Command`]
+#[derive(Debug, Clone)]
+struct Address(
+    /// List of [`AddressRange`]s. If conditions for every
+    /// item in this list are met then [`Command`] with
+    /// this [`Address`] is processed
+    Vec<AddressRange>,
+);
+
+/// [`Command::Replace`] optional flags
+#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd)]
+enum ReplaceFlag {
+    /// Substitute for the nth occurrence only of the
+    /// BRE found within the pattern space
+    ReplaceNth(usize), // n
+    /// Globally substitute for all non-overlapping
+    /// instances of the BRE rather than just the first one
+    ReplaceAll, // g
+    /// Write the pattern space to standard output if
+    /// a replacement was made
+    PrintPatternIfReplace, // p
+    /// Write. Append the pattern space to wfile if a
+    /// replacement was made
+    AppendToIfReplace(PathBuf), // w
+}
+
+/// Newtype for implementing [`Debug`] trait for regex_t
+#[derive(Clone)]
+struct Regex(regex_t);
+
+impl Debug for Regex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Regex").finish()
+    }
+}
+
+/// Atomic parts of [`Script`], that can process input
+/// files line by line
+#[derive(Debug, Clone)]
+enum Command {
+    /// Execute a list of sed editing commands only
+    /// when the pattern space is selected
+    Block(Option<Address>, Vec<Command>), // {
+    /// Write text to standard output as described previously
+    PrintTextAfter(Option<Address>, String), // a
+    /// Branch to the : command verb bearing the label
+    /// argument. If label is not specified, branch to
+    /// the end of the script
+    BranchToLabel(Option<Address>, Option<String>), // b
+    /// Delete the pattern space. With a 0 or 1 address
+    /// or at the end of a 2-address range, place text
+    /// on the output and start the next cycle
+    DeletePatternAndPrintText(Option<Address>, String), // c
+    /// Delete the pattern space and start the next cycle (d)
+    /// If the pattern space contains no <newline>,
+    /// delete the pattern space and start new cycle (D)
+    DeletePattern(Option<Address>, bool), // d/D
+    /// Replace the contents of the pattern
+    /// space by the contents of the hold space
+    ReplacePatternWithHold(Option<Address>), // g
+    /// Append to the pattern space a <newline>
+    /// followed by the contents of the hold space
+    AppendHoldToPattern(Option<Address>), // G
+    /// Replace the contents of the hold space
+    /// with the contents of the pattern space
+    ReplaceHoldWithPattern(Option<Address>), // h
+    /// Append to the hold space a <newline> followed
+    /// by the contents of the pattern space
+    AppendPatternToHold(Option<Address>), // H
+    /// Write text to standard output
+    PrintTextBefore(Option<Address>, String), // i
+    /// Write the pattern space to standard
+    /// output in a visually unambiguous form
+    PrintPatternBinary(Option<Address>), // I
+    /// Write the pattern space to standard output
+    /// and replace pattern space with next line,
+    /// then continue current cycle
+    PrintPatternAndReplaceWithNext(Option<Address>), // n
+    /// Append the next line of input, less its
+    /// terminating <newline>, to the pattern space
+    AppendNextToPattern(Option<Address>), // N
+    /// Write the pattern space to standard output (p).
+    /// Write the pattern space, up to the first <newline>,
+    /// to standard output (P).
+    PrintPattern(Option<Address>, bool), // p/P
+    /// Branch to the end of the script and quit without
+    /// starting a new cycle
+    Quit(Option<Address>), // q
+    /// Copy the contents of rfile to standard output
+    PrintFile(Option<Address>, PathBuf), // r
+    /// Substitute the replacement string for instances
+    /// of the BRE in the pattern space
+    Replace(Option<Address>, Regex, String, String, Vec<ReplaceFlag>), // s
+    /// Test. Branch to the : command verb bearing the
+    /// label if any substitutions have been made since
+    /// the most recent reading of an input line or
+    /// 't' execution
+    Test(Option<Address>, Option<String>), // t
+    /// Append (write) the pattern space to wfile
+    AppendPatternToFile(Option<Address>, PathBuf), // w
+    /// Exchange the contents of the pattern and hold spaces
+    ExchangeSpaces(Option<Address>), // x
+    /// Replace all occurrences of characters in string1
+    /// with the corresponding characters in string2
+    ReplaceCharSet(Option<Address>, String, String), // y
+    /// Do nothing. This command bears a label to which
+    /// the b and t commands branch.
+    BearBranchLabel(String), // :
+    /// Write the following to standard output:
+    /// "%d\n", <current line number>
+    PrintStandard(Option<Address>), // =
+    /// Ignore remainder of the line (treat it as a comment)
+    IgnoreComment, // #
+    /// Char sequence that can`t be recognised as `Command`
+    _Unknown,
+}
+
+impl Command {
+    fn get_mut_address(&mut self) -> Option<(&mut Option<Address>, usize)> {
+        let (address, i) = match self {
+            Command::Block(address, ..) => (address, 2),
+            Command::PrintTextAfter(address, ..) => (address, 1),
+            Command::BranchToLabel(address, ..) => (address, 2),
+            Command::DeletePatternAndPrintText(address, ..) => (address, 2),
+            Command::DeletePattern(address, ..) => (address, 2),
+            Command::ReplacePatternWithHold(address) => (address, 2),
+            Command::AppendHoldToPattern(address) => (address, 2),
+            Command::ReplaceHoldWithPattern(address) => (address, 2),
+            Command::AppendPatternToHold(address) => (address, 2),
+            Command::PrintTextBefore(address, ..) => (address, 1),
+            Command::PrintPatternBinary(address) => (address, 2),
+            Command::PrintPatternAndReplaceWithNext(address) => (address, 2),
+            Command::PrintPattern(address, ..) => (address, 2),
+            Command::Quit(address) => (address, 1),
+            Command::PrintFile(address, ..) => (address, 1),
+            Command::Replace(address, ..) => (address, 2),
+            Command::Test(address, ..) => (address, 2),
+            Command::AppendPatternToFile(address, ..) => (address, 2),
+            Command::ExchangeSpaces(address) => (address, 2),
+            Command::ReplaceCharSet(address, ..) => (address, 2),
+            Command::PrintStandard(address) => (address, 1),
+            _ => return None,
+        };
+
+        Some((address, i))
+    }
+
+    /// If [`Command`] address has more [`AddressToken`]
+    /// then it can have, return error
+    fn check_address(&mut self) -> Result<(), SedError> {
+        let Some((address, max_len)) = self.get_mut_address() else {
+            return Ok(());
+        };
+        if address.is_none() {
+            return Ok(());
+        }
+        for condition in &address.as_ref().unwrap().0 {
+            if condition.limits.len() > max_len {
+                let message = match max_len {
+                    0 => unreachable!(),
+                    1 => "isn't position",
+                    2 => "isn't position or range",
+                    _ => "has more boundaries than can be handled",
+                };
+                return Err(SedError::ScriptParse(
+                    format!("address {} in command {:?}", message, self),
+                    None,
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    /// Check if [`Command`] apply conditions are met for current line
+    fn need_execute(
+        &mut self,
+        line_number: usize,
+        line: &str,
+        last_line: bool,
+    ) -> Result<bool, SedError> {
+        let Some((address, _)) = self.get_mut_address() else {
+            return Ok(true);
+        };
+
+        if address.is_none() {
+            return Ok(true);
+        }
+
+        let mut need_execute = true;
+        for range in address.as_mut().unwrap().0.iter_mut() {
+            if let Some(AddressToken::Pattern(..)) = range.limits.first() {
+                if let Some(AddressToken::Pattern(..)) = range.limits.get(1) {
+                    if range.passed == Some((true, true)) {
+                        range.passed = Some((false, false));
+                    }
+                }
+            }
+
+            let mut reached_now = vec![];
+            for (i, token) in range.limits.iter().enumerate() {
+                reached_now.push(match token {
+                    AddressToken::Number(position) => *position == line_number + 1,
+                    AddressToken::Pattern(re, pattern) => {
+                        !(match_pattern(*re, pattern.clone(), line, line_number + 1)?.is_empty())
+                    }
+                    AddressToken::Last => match i {
+                        0 => last_line,
+                        1 => false,
+                        _ => unreachable!(),
+                    },
+                    _ => unreachable!(),
+                });
+            }
+
+            match range.limits.len() {
+                1 => need_execute &= reached_now[0],
+                2 => {
+                    let (mut old_a, mut old_b) = range.passed.unwrap();
+                    if !old_a && old_b {
+                        range.passed = Some((false, false));
+                        (old_a, old_b) = range.passed.unwrap();
+                    }
+                    range.passed = Some((reached_now[0] || old_a, reached_now[1] || old_b));
+                    let (a, b) = range.passed.unwrap();
+                    range.on_limits = Some((reached_now[0], reached_now[1]));
+                    let mut result = (old_a && !old_b && reached_now[1]) || (a && !b);
+                    if range.is_negative {
+                        result = !result;
+                    }
+                    need_execute &= result;
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        Ok(need_execute)
+    }
+}
+
+/// Function [`regexec`] can return from 1 to 9 range that can be nested.
+/// [`delete_nested_ranges`] function deletes ranges that contain another ranges.
+fn delete_nested_ranges(mut ranges: Vec<(usize, Range<usize>)>) -> Vec<(usize, Range<usize>)> {
+    let mut result: Vec<(usize, Range<usize>)> = Vec::new();
+
+    ranges.sort_by(|(_, a), (_, b)| (a.end - a.start).cmp(&(b.end - b.start)));
+    for (i, Range { start, end }) in ranges.into_iter() {
+        if result.iter().any(|(_, r)| r.start >= start && end >= r.end) {
+            continue;
+        }
+        result.push((i, start..end));
+    }
+
+    result
+}
+
+/// Function [`regexec`] can return from 1 to 9 range. Some
+/// of them cam be invalid for usage. So this function filter
+/// invalid ranges.
+fn filter_groups(groups: &mut Vec<(usize, Range<usize>)>, pattern: &str, haystack: &str) {
+    groups.retain(|(_, m)| {
+        if m.start != m.end {
+            true
+        } else {
+            m.start == 0 || m.start == haystack.len()
+        }
+    });
+    if pattern != "^" && pattern != "^$" {
+        groups.retain(|(_, r)| *r != (0..0));
+    }
+    let end_range = haystack.len()..haystack.len();
+    if pattern != "$" && pattern != "^$" {
+        groups.retain(|(_, r)| *r != end_range);
+    }
+    if (pattern == "^$" && !haystack.is_empty()) || !["^$", "^", "$"].contains(&pattern) {
+        groups.retain(|(_, r)| *r != (0..0) && *r != end_range);
+    }
+}
+
+/// Filter groups of [`Range<usize>`] for replace in
+/// pattern space when patterns like "^\{1,13\}$" appears
+fn filter_groups_when_line_size_check_in_pattern(
+    match_subranges: &mut [Vec<(usize, Range<usize>)>],
+    pattern: &str,
+) {
+    if ["^", "$", r#"\{"#, r#"\{"#]
+        .iter()
+        .all(|pat| pattern.contains(pat))
+    {
+        let mut lengths = vec![];
+        let mut i = 0;
+        loop {
+            let Some(slice) = pattern.get(i..) else {
+                break;
+            };
+            let Some(mut a) = slice.find(r#"\{"#) else {
+                break;
+            };
+            let Some(mut b) = slice.find(r#"\}"#) else {
+                break;
+            };
+            a += i;
+            b += i;
+            let max_len = if let Some(comma_pos) = pattern.get(a..).unwrap().find(",") {
+                if let Some(s) = pattern.get((comma_pos + a + 1)..b) {
+                    s.parse::<usize>().ok()
+                } else {
+                    Some(pattern.len())
+                }
+            } else {
+                let s = pattern.get((a + 2)..b).unwrap();
+                s.parse::<usize>().ok()
+            };
+            if let Some(max_len) = max_len {
+                lengths.push(max_len);
+            }
+
+            i = b + 2;
+        }
+
+        for length in &lengths {
+            match_subranges.iter_mut().for_each(|groups| {
+                groups.retain(|(_, r)| r.end <= *length);
+            });
+        }
+    }
+}
+
+fn delete_groups_duplicates(
+    match_subranges: Vec<Vec<(usize, Range<usize>)>>,
+) -> Vec<HashMap<usize, Range<usize>>> {
+    let match_subranges = match_subranges.into_iter().collect::<HashSet<_>>();
+    match_subranges
+        .into_iter()
+        .map(delete_nested_ranges)
+        .map(|m| m.into_iter().enumerate().map(|(i, (_, r))| (i + 1, r)))
+        .map(|m| m.into_iter().collect::<HashMap<_, _>>())
+        .filter(|m| !m.is_empty())
+        .collect::<Vec<_>>()
+}
+
+fn sort_groups(match_subranges: &mut [HashMap<usize, Range<usize>>]) {
+    match_subranges.sort_by(|a, b| {
+        a.iter()
+            .next()
+            .unwrap()
+            .1
+            .start
+            .cmp(&b.iter().next().unwrap().1.start)
+    });
+}
+
+/// Get [`Vec<Range<usize>>`] from finding match in haystack with RE
+///
+/// Arguments:
+/// [`haystack`] - &[`str`] for searching pattern matches
+/// [`re`] - pattern for search in haystack
+/// [`line_number`] - current line number in input file, used in error message
+fn match_pattern(
+    re: regex_t,
+    pattern: String,
+    haystack: &str,
+    line_number: usize,
+) -> Result<Vec<HashMap<usize, std::ops::Range<usize>>>, SedError> {
+    let match_t: regmatch_t = unsafe { MaybeUninit::zeroed().assume_init() };
+    let mut match_subranges = vec![];
+    let mut i = 0;
+    let mut last_offset = 0;
+    let c_input = CString::new(haystack).map_err(|err| {
+        SedError::ScriptParse(
+            format!(
+                "line {} contains nul byte in {} position",
+                line_number,
+                err.nul_position()
+            ),
+            None,
+        )
+    })?;
+    let mut c_input = c_input.as_ptr();
+    while i <= haystack.len() {
+        let mut pmatch = vec![match_t; 9];
+        unsafe {
+            c_input = c_input.add(last_offset);
+            let _ = regexec(&re as *const regex_t, c_input, 9, pmatch.as_mut_ptr(), 0);
+        }
+
+        let mut groups = pmatch
+            .to_vec()
+            .iter()
+            .enumerate()
+            .filter(|(_, m)| !((m.rm_so < 0) && (m.rm_eo < 0)))
+            .map(|(j, m)| (j + 1, ((m.rm_so as usize) + i)..((m.rm_eo as usize) + i)))
+            .collect::<Vec<_>>();
+
+        filter_groups(&mut groups, &pattern, haystack);
+        last_offset = groups
+            .iter()
+            .map(|(_, r)| r.end - r.start)
+            .max()
+            .unwrap_or(0);
+        if last_offset == 0 {
+            last_offset = 1;
+        }
+        i += last_offset;
+        match_subranges.push(groups);
+    }
+    filter_groups_when_line_size_check_in_pattern(&mut match_subranges, &pattern);
+    let mut match_subranges = delete_groups_duplicates(match_subranges);
+    sort_groups(&mut match_subranges);
+
+    Ok(match_subranges)
+}
+
+/// Parse sequence of digits as [`usize`]
+fn parse_number(chars: &[char], i: &mut usize) -> Result<Option<usize>, SedError> {
+    let mut number_str = String::new();
+    loop {
+        let Some(ch) = chars.get(*i) else {
+            return Err(SedError::ScriptParse(
+                "script ended unexpectedly".to_string(),
+                None,
+            ));
+        };
+        if !ch.is_ascii_digit() {
+            break;
+        }
+        number_str.push(*ch);
+        *i += 1;
+    }
+
+    if number_str.is_empty() {
+        return Ok(None);
+    }
+
+    let number = number_str.parse::<usize>().map_err(|_| {
+        let position = get_current_line_and_col(chars, *i);
+        SedError::ScriptParse("can't parse number".to_string(), position)
+    })?;
+    Ok(Some(number))
+}
+
+/// Get pattern from chars by start..end range and validate it
+fn get_pattern_token(
+    chars: &[char],
+    start: usize,
+    end: Option<usize>,
+    splitter: char,
+    position: Option<(usize, usize)>,
+) -> Result<String, SedError> {
+    let Some(end) = end else {
+        return Err(SedError::ScriptParse(
+            "unterminated address regex".to_string(),
+            position,
+        ));
+    };
+
+    let Some(pattern) = chars.get(start..end) else {
+        return Err(SedError::ScriptParse(
+            "unterminated address regex".to_string(),
+            position,
+        ));
+    };
+
+    let mut pattern = pattern.iter().collect::<String>();
+    if splitter == '/' {
+        pattern = pattern.replace(r"\/", "/");
+    }
+
+    if pattern == "\\"
+        || pattern.contains('\n')
+        || pattern
+            .chars()
+            .collect::<Vec<_>>()
+            .windows(2)
+            .any(|chars| chars[0] == '\\' && !"().*$^".contains(chars[1]))
+    {
+        return Err(SedError::ScriptParse(
+            "pattern can't consist more than 1 line".to_string(),
+            position,
+        ));
+    }
+
+    Ok(pattern)
+}
+
+/// Parse [`Address`] BRE as [`AddressToken`]
+fn parse_pattern_token(
+    chars: &[char],
+    i: &mut usize,
+    tokens: &mut Vec<AddressToken>,
+) -> Result<(), SedError> {
+    let position = get_current_line_and_col(chars, *i);
+    *i += 1;
+    let Some(ch) = chars.get(*i) else {
+        return Err(SedError::ScriptParse(
+            "unterminated address regex".to_string(),
+            position,
+        ));
+    };
+
+    if "\\\n".contains(*ch) {
+        return Err(SedError::ScriptParse(
+            format!("pattern spliter is '{}'", ch),
+            position,
+        ));
+    }
+
+    let splitter = ch;
+    let mut next_position = None;
+    let mut j = *i + 1;
+    while j < chars.len() {
+        let Some(ch) = chars.get(j) else {
+            return Err(SedError::ScriptParse(
+                "unterminated address regex".to_string(),
+                position,
+            ));
+        };
+        if ch == splitter {
+            let Some(previous) = chars.get(j - 1) else {
+                return Err(SedError::ScriptParse(
+                    "unterminated address regex".to_string(),
+                    position,
+                ));
+            };
+            if *previous == '\\' && *splitter == '/' {
+                j += 1;
+                continue;
+            }
+            next_position = Some(j);
+            break;
+        }
+        j += 1;
+    }
+
+    let pattern = get_pattern_token(chars, *i + 1, next_position, *splitter, position)?;
+    let re = compile_regex(pattern.clone())?;
+    tokens.push(AddressToken::Pattern(re, pattern));
+    if let Some(next_position) = next_position {
+        *i = next_position;
+    }
+
+    Ok(())
+}
+
+/// Highlight future [`Address`] string and split it on [`AddressToken`]s
+fn to_address_tokens(chars: &[char], i: &mut usize) -> Result<Vec<AddressToken>, SedError> {
+    let mut tokens = vec![];
+    loop {
+        let Some(ch) = chars.get(*i) else {
+            return Err(SedError::ScriptParse(
+                "script ended unexpectedly".to_string(),
+                None,
+            ));
+        };
+        match ch {
+            ch if ch.is_ascii_digit() => {
+                let Some(number) = parse_number(chars, i)? else {
+                    unreachable!();
+                };
+                tokens.push(AddressToken::Number(number));
+                continue;
+            }
+            '\\' => parse_pattern_token(chars, i, &mut tokens)?,
+            '$' => tokens.push(AddressToken::Last),
+            ',' => tokens.push(AddressToken::Delimiter),
+            ' ' => {}
+            _ => break,
+        }
+        *i += 1;
+    }
+
+    Ok(tokens)
+}
+
+/// Convert [`AddressToken`]s to [`Address`]
+fn tokens_to_address(
+    tokens: Vec<AddressToken>,
+    is_negative: bool,
+) -> Result<Option<Address>, SedError> {
+    if tokens
+        .iter()
+        .enumerate()
+        .filter(|(i, _)| i % 2 == 1)
+        .any(|(_, token)| !matches!(token, AddressToken::Delimiter))
+        || tokens.last() == Some(&AddressToken::Delimiter)
+    {
+        return Err(SedError::ScriptParse(
+            "address bound can be only one pattern, number or '$'".to_string(),
+            None,
+        ));
+    }
+
+    let tokens = tokens
+        .into_iter()
+        .filter(|token| !matches!(token, AddressToken::Delimiter))
+        .collect::<Vec<_>>();
+    if let Some(range) = AddressRange::new(tokens, is_negative)? {
+        if range
+            .limits
+            .iter()
+            .any(|token| AddressToken::Number(0) == *token)
+        {
+            return Err(SedError::ScriptParse(
+                "address lower bound must be bigger than 0".to_string(),
+                None,
+            ));
+        }
+        return Ok(Some(Address(vec![range])));
+    }
+    Ok(None)
+}
+
+/// Get current line and column in script parse process
+fn get_current_line_and_col(chars: &[char], i: usize) -> Option<(usize, usize)> {
+    let mut j = 0;
+    let lines_positions = chars
+        .split(|c| *c == '\n')
+        .map(|line| {
+            let k = j;
+            j += line.len() + 1;
+            (line, k)
+        })
+        .collect::<Vec<_>>();
+    let (line, _) = lines_positions
+        .iter()
+        .enumerate()
+        .find(|(_, (_, line_start))| {
+            if i >= *line_start {
+                return false;
+            }
+            true
+        })?;
+    let line = line.saturating_sub(1);
+    let col = i - lines_positions[line].1 + 1;
+    Some((line, col))
+}
+
+/// Format string for current script line and column
+fn format_error_position(position: Option<(usize, usize)>) -> String {
+    if let Some((line, col)) = position {
+        format!(" (line: {}, col: {})", line, col)
+    } else {
+        String::new()
+    }
+}
+
+/// Parse count argument of future [`Command`]
+fn parse_address(
+    chars: &[char],
+    i: &mut usize,
+    address: &mut Option<Address>,
+) -> Result<(), SedError> {
+    let tokens = to_address_tokens(chars, i)?;
+    let mut is_negative = false;
+    loop {
+        let Some(ch) = chars.get(*i) else {
+            break;
+        };
+        match ch {
+            '!' => {
+                is_negative = true;
+                *i += 1;
+                break;
+            }
+            ' ' => (),
+            _ => break,
+        }
+        *i += 1;
+    }
+    match tokens_to_address(tokens, is_negative) {
+        Ok(new_address) => *address = new_address,
+        Err(SedError::ScriptParse(message, position)) => {
+            let position = if position.is_some() {
+                position
+            } else {
+                get_current_line_and_col(chars, *i)
+            };
+            return Err(SedError::ScriptParse(message, position));
+        }
+        _ => unreachable!(),
+    }
+    Ok(())
+}
+
+/// Parse text attribute of a, c, i [`Command`]s that formated as:
+/// a\
+/// text
+fn parse_text_attribute(chars: &[char], i: &mut usize) -> Result<Option<String>, SedError> {
+    *i += 1;
+    let Some(ch) = chars.get(*i) else {
+        return Err(SedError::ScriptParse(
+            "script ended unexpectedly".to_string(),
+            None,
+        ));
+    };
+    if *ch != '\\' {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            "text must be separated with '\\'".to_string(),
+            position,
+        ));
+    }
+    *i += 1;
+    let mut text = String::new();
+    loop {
+        let Some(ch) = chars.get(*i) else {
+            break;
+        };
+        match *ch {
+            '\n' => {
+                *i += 1;
+                break;
+            }
+            '\\' => {
+                *i += 1;
+                continue;
+            }
+            _ => (),
+        }
+        text.push(*ch);
+        *i += 1;
+    }
+    if text.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(text))
+    }
+}
+
+/// Parse label, xfile attributes of b, r, t, w [`Command`]s that formated as:
+/// b [label], r  rfile
+fn parse_word_attribute(chars: &[char], i: &mut usize) -> Result<Option<String>, SedError> {
+    let mut label = String::new();
+    loop {
+        let Some(ch) = chars.get(*i) else {
+            break;
+        };
+        match ch {
+            '\n' | ';' => {
+                *i -= 1;
+                break;
+            }
+            _ => label.push(*ch),
+        }
+        *i += 1;
+        if *i > chars.len() {
+            break;
+        }
+    }
+    let label = label.trim().to_string();
+    if label.contains(' ') {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            "label can't contain ' '".to_string(),
+            position,
+        ));
+    }
+    Ok(if label.is_empty() { None } else { Some(label) })
+}
+
+/// Parse rfile attribute of r [`Command`]
+fn parse_path_attribute(chars: &[char], i: &mut usize) -> Result<PathBuf, SedError> {
+    *i += 1;
+    let mut path = String::new();
+    loop {
+        let Some(ch) = chars.get(*i) else {
+            break;
+        };
+        match ch {
+            '\n' | ';' => {
+                *i -= 1;
+                break;
+            }
+            _ => path.push(*ch),
+        }
+        *i += 1;
+        if *i >= chars.len() {
+            break;
+        }
+    }
+    let path = path.trim();
+    if path.is_empty() {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            "missing filename in r/R/w/W commands".to_string(),
+            position,
+        ));
+    }
+    let file = PathBuf::from(path);
+    if file.exists() {
+        if file.is_file() {
+            Ok(file)
+        } else {
+            Err(SedError::Io(Error::new(
+                ErrorKind::InvalidInput,
+                format!("{} isn't file", file.display()),
+            )))
+        }
+    } else {
+        Ok(file)
+    }
+}
+
+/// Parse `{ ... }` like [`Script`] part
+fn parse_block(chars: &[char], i: &mut usize) -> Result<Vec<Command>, SedError> {
+    let block_limits = chars
+        .iter()
+        .enumerate()
+        .skip(*i)
+        .filter(|pair| *pair.1 == '{' || *pair.1 == '}')
+        .collect::<Vec<_>>();
+
+    let mut j = 0;
+    let mut k = 0;
+    loop {
+        let Some(ch) = block_limits.get(k) else {
+            break;
+        };
+        match ch.1 {
+            '{' => j += 1,
+            '}' => j -= 1,
+            _ => unreachable!(),
+        }
+        if j <= 0 {
+            break;
+        }
+        k += 1;
+        if k >= block_limits.len() {
+            break;
+        }
+    }
+
+    let commands = if j == 0 {
+        let block = chars[(*i + 1)..block_limits[k].0]
+            .iter()
+            .collect::<String>();
+        match Script::parse(block) {
+            Ok(script) => script.0,
+            Err(err) => {
+                return if let SedError::ScriptParse(message, Some(position)) = err {
+                    let (line, col) = position;
+                    let (block_start_line, block_start_col) =
+                        get_current_line_and_col(chars, *i + 1).unwrap_or((0, 0));
+                    let position = (
+                        block_start_line + line,
+                        if line == 0 {
+                            block_start_col + col
+                        } else {
+                            col
+                        },
+                    );
+                    return Err(SedError::ScriptParse(message, Some(position)));
+                } else {
+                    Err(err)
+                };
+            }
+        }
+    } else {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            "'{' not have pair for closing block".to_string(),
+            position,
+        ));
+    };
+    *i = block_limits[k].0;
+    Ok(commands)
+}
+
+/// Parse s, y [`Command`]s that formated as:
+/// x/string1/string2/
+fn parse_replace_command(
+    chars: &[char],
+    i: &mut usize,
+    command: String,
+) -> Result<(String, String), SedError> {
+    *i += 1;
+    let first_position = *i + 1;
+    let Some(splitter) = chars.get(*i) else {
+        return Err(SedError::ScriptParse(
+            "script ended unexpectedly".to_string(),
+            None,
+        ));
+    };
+    if splitter.is_alphanumeric() || " \n;{".contains(*splitter) {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            format!("unterminated `{}' command", command),
+            position,
+        ));
+    }
+    *i += 1;
+    let mut splitters = chars
+        .iter()
+        .enumerate()
+        .skip(*i)
+        .filter(|pair| pair.1 == splitter)
+        .map(|pair| pair.0)
+        .collect::<Vec<_>>();
+
+    if *splitter == '/' {
+        splitters.retain(|j| {
+            if let Some(previous_ch) = chars.get(j.checked_sub(1).unwrap_or(0)) {
+                *previous_ch != '\\'
+            } else {
+                true
+            }
+        })
+    }
+
+    let position = get_current_line_and_col(chars, *i);
+    let parse_error = Err(SedError::ScriptParse(
+        format!("unterminated `{}' command", command),
+        position,
+    ));
+    if splitters.len() < 2 {
+        return parse_error;
+    };
+    let Some(pattern) = chars.get(first_position..splitters[0]) else {
+        return parse_error;
+    };
+    let Some(replacement) = chars.get((splitters[0] + 1)..splitters[1]) else {
+        return parse_error;
+    };
+    if pattern.contains(&'\n') || replacement.contains(&'\n') {
+        return parse_error;
+    }
+
+    *i = splitters[1] + 1;
+    let pattern = pattern.iter().collect::<String>();
+    let replacement = replacement.iter().collect::<String>();
+    let result = (pattern.replace("\\/", "/"), replacement.replace("\\/", "/"));
+
+    Ok(result)
+}
+
+/// Parse [`Command::Replace`] flags
+fn parse_replace_flags(chars: &[char], i: &mut usize) -> Result<Vec<ReplaceFlag>, SedError> {
+    let mut flags = vec![];
+    let mut flag_map = HashMap::from([('n', 0), ('g', 0), ('p', 0), ('w', 0)]);
+    let mut w_start_position = None;
+    while let Some(ch) = chars.get(*i) {
+        match ch {
+            _ if ch.is_ascii_digit() => {
+                let n = ch.to_digit(10).unwrap() as usize;
+                *flag_map.get_mut(&'n').unwrap() += 1;
+                flags.push(ReplaceFlag::ReplaceNth(n));
+            }
+            'g' => {
+                *flag_map.get_mut(&'g').unwrap() += 1;
+                flags.push(ReplaceFlag::ReplaceAll)
+            }
+            'p' => {
+                *flag_map.get_mut(&'p').unwrap() += 1;
+                flags.push(ReplaceFlag::PrintPatternIfReplace)
+            }
+            'w' => {
+                if w_start_position.is_none() {
+                    w_start_position = Some(*i);
+                }
+                *flag_map.get_mut(&'w').unwrap() += 1;
+                flags.push(ReplaceFlag::AppendToIfReplace(PathBuf::new()));
+                *i += 1;
+                break;
+            }
+            ' ' => {}
+            _ => {
+                *i -= 1;
+                break;
+            }
+        }
+        *i += 1;
+    }
+
+    let eq_w = |f| matches!(f, ReplaceFlag::AppendToIfReplace(_));
+    let w_flag_position = flags.iter().cloned().position(eq_w);
+    let is_w_last = || w_flag_position.unwrap() == (flags.len() - 1);
+    if w_flag_position.is_some() && !is_w_last() {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            "w flag must be last flag".to_string(),
+            position,
+        ));
+    } else if flag_map.values().any(|k| *k > 1) && is_w_last() {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            "flags can't be repeated".to_string(),
+            position,
+        ));
+    }
+    if let Some(w_start_position) = w_start_position {
+        *i = w_start_position;
+        let path = parse_path_attribute(chars, i)?;
+        flags.push(ReplaceFlag::AppendToIfReplace(path));
+    }
+
+    let is_replace_nth = |f| matches!(f, ReplaceFlag::ReplaceNth(_));
+    if flags.iter().cloned().any(is_replace_nth) && flags.contains(&ReplaceFlag::ReplaceAll) {
+        let position = get_current_line_and_col(chars, *i);
+        return Err(SedError::ScriptParse(
+            "n and g flags can't be used together".to_string(),
+            position,
+        ));
+    }
+    Ok(flags)
+}
+
+/// Compiles [`pattern`] as [`regex_t`]
+fn compile_regex(pattern: String) -> Result<regex_t, SedError> {
+    #[cfg(target_os = "macos")]
+    let mut pattern = pattern.replace("\\\\", "\\");
+    #[cfg(all(unix, not(target_os = "macos")))]
+    let pattern = pattern.replace("\\\\", "\\");
+    let mut cflags = 0;
+    let ere = ERE.lock().unwrap();
+    if *ere {
+        cflags |= REG_EXTENDED;
+    }
+
+    // macOS version of [regcomp](regcomp) from `libc` provides additional check
+    // for empty regex. In this case, an error
+    // [REG_EMPTY](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/regcomp.3.html)
+    // will be returned. Therefore, an empty pattern is replaced with ".*".
+    #[cfg(target_os = "macos")]
+    {
+        pattern = if pattern == "" {
+            String::from(".*")
+        } else {
+            pattern
+        };
+    }
+
+    let c_pattern = CString::new(pattern.clone()).map_err(|err| {
+        SedError::ScriptParse(
+            format!(
+                "pattern '{}' contains nul byte in {} position",
+                pattern,
+                err.nul_position()
+            ),
+            None,
+        )
+    })?;
+    let mut regex = unsafe { std::mem::zeroed::<regex_t>() };
+
+    if unsafe { regcomp(&mut regex, c_pattern.as_ptr(), cflags) } == 0 {
+        Ok(regex)
+    } else {
+        Err(SedError::ScriptParse(
+            format!("can't compile pattern '{}'", pattern),
+            None,
+        ))
+    }
+}
+
+fn screen_width() -> Option<usize> {
+    let mut ws: *mut winsize = std::ptr::null_mut();
+    if unsafe { ioctl(STDIN_FILENO, TIOCGWINSZ, &mut ws) != 0 }
+        && unsafe { ioctl(STDOUT_FILENO, TIOCGWINSZ, &mut ws) != 0 }
+        && unsafe { ioctl(STDERR_FILENO, TIOCGWINSZ, &mut ws) != 0 }
+    {
+        return None;
+    }
+    Some(unsafe { *ws }.ws_col as usize)
+}
+
+fn print_multiline_binary(line: &str) {
+    let line = line
+        .chars()
+        .flat_map(|ch| {
+            if b"\x07\x08\x09\x0B\x0C\x0D".contains(&(ch as u8)) {
+                match ch as u8 {
+                    b'\x07' => vec!['\\', 'a'],
+                    b'\x08' => vec!['\\', 'b'],
+                    b'\x09' => vec!['\\', 't'],
+                    b'\x0B' => vec!['\\', 'v'],
+                    b'\x0C' => vec!['\\', 'f'],
+                    b'\x0D' => vec!['\\', 'r'],
+                    _ => unreachable!(),
+                }
+            } else if ch == '\n' {
+                vec![ch]
+            } else if ch.is_ascii() {
+                format!(r#"\x{:02x}"#, ch as u8).chars().collect::<Vec<_>>()
+            } else {
+                vec![ch]
+            }
+        })
+        .collect::<String>();
+    if let Some(width) = screen_width() {
+        if width >= 1 {
+            let line = line.chars().collect::<Vec<_>>();
+            let mut chunks = line.chunks(width - 1).peekable();
+            loop {
+                let Some(chunk) = chunks.next() else {
+                    break;
+                };
+                if chunk.strip_suffix(&['\n']).is_some() {
+                    if chunks.peek().is_some() {
+                        println!("\\\n");
+                    } else {
+                        println!("$\n");
+                    }
+                } else if chunks.peek().is_some() {
+                    println!("\\");
+                } else {
+                    println!("$");
+                }
+            }
+        }
+    } else if let Some(line) = line.strip_suffix(&['\n']) {
+        println!("{}$", line);
+    } else {
+        print!("{}$", line);
+    }
+}
+
+/// Find first label in [`Script`] that has duplicates
+fn find_first_repeated_label(vec: Vec<String>) -> Option<String> {
+    let mut counts = HashMap::new();
+    for item in &vec {
+        *counts.entry(item).or_insert(0) += 1;
+    }
+
+    // Collect elements with count > 1
+    counts
+        .into_iter()
+        .filter(|&(_, count)| count > 1)
+        .map(|(item, _)| item.clone())
+        .next()
+}
+
+// Skip [`Script`] fragment from '#' to '\n' chars (comment)
+fn skip_comment(chars: &[char], i: &mut usize) {
+    if let Some(p) = chars.iter().skip(*i).position(|ch| *ch == '\n') {
+        *i = p;
+    } else {
+        *i = chars.len()
+    }
+}
+
+/// Filter comments (line ends after '#') in raw script
+fn filter_comments(raw_script: impl AsRef<str>) -> String {
+    let mut raw_script_without_comments = String::new();
+    for line in raw_script.as_ref().lines() {
+        let mut j = 0;
+        let chars = line.chars().collect::<Vec<_>>();
+        let mut split_positions = vec![0];
+        loop {
+            let Some(remain) = chars.get(j..) else {
+                break;
+            };
+            let Some(a) = remain.iter().position(|ch| ['s', 'y'].contains(ch)) else {
+                break;
+            };
+            let mut b = a;
+            if parse_replace_command(remain, &mut b, String::new()).is_err() {
+                break;
+            }
+            split_positions.push(j + a);
+            j += b;
+            split_positions.push(j);
+        }
+        split_positions.push(line.len());
+        let mut is_s = false;
+        for pair in split_positions.windows(2) {
+            let part = line.get(pair[0]..pair[1]).unwrap_or("");
+            if !is_s && part.contains('#') {
+                raw_script_without_comments += part.split('#').next().unwrap_or("");
+                break;
+            } else {
+                raw_script_without_comments += part;
+            }
+            is_s = !is_s;
+        }
+        raw_script_without_comments += "\n";
+    }
+    raw_script_without_comments
+}
+
+/// Contains [`Command`] sequence of all [`Sed`] session
+/// that applied all to every line of input files
+#[derive(Debug)]
+struct Script(Vec<Command>);
+
+impl Script {
+    /// Try parse raw script string to sequence of [`Command`]s
+    /// formated as [`Script`]
+    fn parse(raw_script: impl AsRef<str>) -> Result<Script, SedError> {
+        let mut commands = vec![];
+        let mut address = None;
+        let mut i = 0;
+        let mut last_commands_count = 0;
+        let mut command_added = false;
+        let chars = filter_comments(&raw_script).chars().collect::<Vec<_>>();
+
+        if let Some(slice) = raw_script.as_ref().get(0..2) {
+            if slice.get(0..1) == Some("#") && slice.get(1..2) == Some("n") {
+                commands.push(Command::IgnoreComment);
+            }
+        }
+
+        loop {
+            let Some(ch) = chars.get(i) else {
+                break;
+            };
+            match *ch {
+                ' ' | '\n' => {}
+                ';' => {
+                    if address.is_some() && !command_added {
+                        let position = get_current_line_and_col(&chars, i);
+                        return Err(SedError::ScriptParse(
+                            "address hasn't command".to_string(),
+                            position,
+                        ));
+                    }
+                    address = None;
+                    command_added = false
+                }
+                '}' => {
+                    let position = get_current_line_and_col(&chars, i);
+                    return Err(SedError::ScriptParse(
+                        "unneccessary '}'".to_string(),
+                        position,
+                    ));
+                }
+                _ if command_added => {
+                    let position = get_current_line_and_col(&chars, i);
+                    return Err(SedError::ScriptParse(
+                        "commands must be delimited with ';'".to_string(),
+                        position,
+                    ));
+                }
+                ch if ch.is_ascii_digit() || "\\$".contains(ch) => {
+                    parse_address(&chars, &mut i, &mut address)?;
+                    continue;
+                }
+                '{' => {
+                    commands.push(Command::Block(
+                        address.clone(),
+                        parse_block(&chars, &mut i)?,
+                    ));
+                }
+                'a' => {
+                    if let Some(text) = parse_text_attribute(&chars, &mut i)? {
+                        commands.push(Command::PrintTextAfter(address.clone(), text));
+                    } else {
+                        let position = get_current_line_and_col(&chars, i);
+                        return Err(SedError::ScriptParse(
+                            "missing text argument".to_string(),
+                            position,
+                        ));
+                    }
+                }
+                'b' => {
+                    i += 1;
+                    let label = parse_word_attribute(&chars, &mut i)?;
+                    commands.push(Command::BranchToLabel(address.clone(), label));
+                }
+                'c' => {
+                    if let Some(text) = parse_text_attribute(&chars, &mut i)? {
+                        commands.push(Command::DeletePatternAndPrintText(address.clone(), text));
+                    } else {
+                        let position = get_current_line_and_col(&chars, i);
+                        return Err(SedError::ScriptParse(
+                            "missing text argument".to_string(),
+                            position,
+                        ));
+                    }
+                }
+                'd' => commands.push(Command::DeletePattern(address.clone(), false)),
+                'D' => commands.push(Command::DeletePattern(address.clone(), true)),
+                'g' => commands.push(Command::ReplacePatternWithHold(address.clone())),
+                'G' => commands.push(Command::AppendHoldToPattern(address.clone())),
+                'h' => commands.push(Command::ReplaceHoldWithPattern(address.clone())),
+                'H' => commands.push(Command::AppendPatternToHold(address.clone())),
+                'i' => {
+                    if let Some(text) = parse_text_attribute(&chars, &mut i)? {
+                        commands.push(Command::PrintTextBefore(address.clone(), text));
+                    } else {
+                        let position = get_current_line_and_col(&chars, i);
+                        return Err(SedError::ScriptParse(
+                            "missing text argument".to_string(),
+                            position,
+                        ));
+                    }
+                }
+                'I' => commands.push(Command::PrintPatternBinary(address.clone())),
+                'n' => commands.push(Command::PrintPatternAndReplaceWithNext(address.clone())),
+                'N' => commands.push(Command::AppendNextToPattern(address.clone())),
+                'p' => commands.push(Command::PrintPattern(address.clone(), false)),
+                'P' => commands.push(Command::PrintPattern(address.clone(), true)),
+                'q' => commands.push(Command::Quit(address.clone())),
+                'r' => {
+                    let rfile = parse_path_attribute(&chars, &mut i)?;
+                    commands.push(Command::PrintFile(address.clone(), rfile))
+                }
+                's' => {
+                    let (pattern, replacement) =
+                        parse_replace_command(&chars, &mut i, "s".to_string())?;
+                    let re = compile_regex(pattern.clone())?;
+                    let flags = parse_replace_flags(&chars, &mut i)?;
+                    commands.push(Command::Replace(
+                        address.clone(),
+                        Regex(re),
+                        pattern.clone(),
+                        replacement.clone(),
+                        flags,
+                    ));
+                }
+                't' => {
+                    i += 1;
+                    let label = parse_word_attribute(&chars, &mut i)?;
+                    commands.push(Command::Test(address.clone(), label));
+                }
+                'w' => {
+                    match parse_path_attribute(&chars, &mut i) {
+                        Ok(wfile) => {
+                            commands.push(Command::AppendPatternToFile(address.clone(), wfile));
+                        }
+                        Err(SedError::ScriptParse(msg, _)) if msg.starts_with("missing") => {}
+                        Err(err) => return Err(err),
+                    };
+                }
+                'x' => commands.push(Command::ExchangeSpaces(address.clone())),
+                'y' => {
+                    let (string1, string2) =
+                        parse_replace_command(&chars, &mut i, "y".to_string())?;
+                    if string1.len() != string2.len() {
+                        let position = get_current_line_and_col(&chars, i);
+                        return Err(SedError::ScriptParse(
+                            "number of characters in the two arrays does not match".to_string(),
+                            position,
+                        ));
+                    }
+                    commands.push(Command::ReplaceCharSet(address.clone(), string1, string2));
+                }
+                ':' => {
+                    i += 1;
+                    let Some(label) = parse_word_attribute(&chars, &mut i)? else {
+                        let position = get_current_line_and_col(&chars, i);
+                        return Err(SedError::ScriptParse(
+                            "label doesn't have name".to_string(),
+                            position,
+                        ));
+                    };
+                    commands.push(Command::BearBranchLabel(label))
+                }
+                '=' => commands.push(Command::PrintStandard(address.clone())),
+                '#' => skip_comment(&chars, &mut i),
+                _ => {
+                    let position = get_current_line_and_col(&chars, i);
+                    return Err(SedError::ScriptParse(
+                        format!("unknown character '{}'", ch),
+                        position,
+                    ));
+                }
+            }
+
+            if last_commands_count < commands.len() {
+                last_commands_count = commands.len();
+                command_added = true;
+            }
+            i += 1;
+        }
+
+        for cmd in commands.iter_mut() {
+            cmd.check_address()?;
+        }
+
+        commands = flatten_commands(commands);
+
+        Ok(Script(commands))
+    }
+
+    /// Raise error if "b" or "t" commands without ":<label>" pair
+    fn check_labels(&self) -> Result<(), SedError> {
+        let labels = self
+            .0
+            .iter()
+            .cloned()
+            .filter_map(|cmd| match cmd {
+                Command::BearBranchLabel(label) => Some(label),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        let cmd_labels_set = self
+            .0
+            .iter()
+            .cloned()
+            .filter_map(|cmd| match cmd {
+                Command::BranchToLabel(_, label) | Command::Test(_, label) => label,
+                _ => None,
+            })
+            .collect::<HashSet<_>>();
+
+        let labels_set = labels.iter().cloned().collect::<HashSet<_>>();
+        if let Some(label) = cmd_labels_set.difference(&labels_set).next() {
+            return Err(SedError::ScriptParse(
+                format!("can't find label for jump to `{}'", label),
+                None,
+            ));
+        } else if labels.len() > labels_set.len() {
+            let label = match find_first_repeated_label(labels) {
+                Some(label) => format!("label {}", label),
+                None => "some label".to_string(),
+            };
+            return Err(SedError::ScriptParse(
+                format!("{} is repeated", label),
+                None,
+            ));
+        }
+        Ok(())
+    }
+}
+
+/// Replace every [`Command::Block`] with inner [`Command`]
+/// set and adding [`AddressRange`] for every inner [`Command`]
+fn flatten_commands(mut commands: Vec<Command>) -> Vec<Command> {
+    let is_block = |cmd: &Command| matches!(cmd, Command::Block(..));
+
+    while commands.iter().any(is_block) {
+        commands = commands
+            .into_iter()
+            .flat_map(|cmd| {
+                if let Command::Block(block_address, mut block_commands) = cmd {
+                    let Some(block_address) = block_address else {
+                        return block_commands;
+                    };
+                    block_commands.iter_mut().for_each(|cmd| {
+                        if let Some((address, _)) = cmd.get_mut_address() {
+                            if let Some(address) = address {
+                                address.0.extend(block_address.0.clone());
+                            } else {
+                                *address = Some(block_address.clone());
+                            }
+                        }
+                    });
+                    block_commands
+                } else {
+                    vec![cmd]
+                }
+            })
+            .collect::<Vec<_>>();
+    }
+
+    commands
+}
+
+/// Returns all positions of '&' in [Vec<char>]
+fn get_ampersand_positions(chars: Vec<char>) -> Vec<usize> {
+    let pairs = chars.windows(2).enumerate();
+    let mut ampersand_positions = pairs
+        .filter_map(|(i, chars)| {
+            if chars[0] != '\\' && chars[1] == '&' {
+                return Some(i + 1);
+            }
+            None
+        })
+        .rev()
+        .collect::<Vec<_>>();
+
+    if let Some(ch) = chars.first() {
+        if *ch == '&' {
+            ampersand_positions.push(0);
+        }
+    }
+    ampersand_positions
+}
+
+/// Returns all groups positions (like "\1") in [Vec<char>]
+fn get_group_positions(chars: Vec<char>) -> Vec<(usize, usize)> {
+    let pairs = chars.windows(2).enumerate();
+    let mut group_positions = pairs
+        .filter_map(|(i, chars)| {
+            if chars[0] == '\\' && chars[1].is_ascii_digit() {
+                return Some((i, chars[1].to_digit(10).unwrap() as usize));
+            }
+            None
+        })
+        .rev()
+        .collect::<Vec<_>>();
+
+    if let Some(ch) = chars.first() {
+        if ch.is_ascii_digit() {
+            group_positions.push((0, ch.to_digit(10).unwrap() as usize));
+        }
+    }
+    group_positions
+}
+
+/// Construct replace string and replace
+/// ranges with new content in pattern space
+fn update_pattern_space(
+    pattern_space: &mut String,
+    replacement: &str,
+    ranges: &HashMap<usize, Range<usize>>,
+) -> bool {
+    let pairs = replacement.chars().collect::<Vec<_>>();
+    let ampersand_positions = get_ampersand_positions(pairs.clone());
+    let group_positions = get_group_positions(pairs);
+    let mut local_replacement = replacement.to_string();
+    if let Some((_, range)) = ranges.iter().next() {
+        let value = (*pattern_space).get(range.clone());
+        for position in ampersand_positions.clone() {
+            local_replacement.replace_range(position..(position + 1), value.unwrap());
+        }
+    }
+
+    if ranges.is_empty() {
+        return false;
+    }
+
+    let main_range = ranges.iter().map(|(_, r)| r.start).min().unwrap()
+        ..ranges.iter().map(|(_, r)| r.end).max().unwrap();
+
+    if !group_positions.is_empty() {
+        for (position, group) in group_positions {
+            let replace_str = if let Some(range) = ranges.get(&group) {
+                pattern_space.get(range.clone()).unwrap()
+            } else {
+                &"".to_string()
+            };
+            local_replacement.replace_range(position..(position + 2), replace_str);
+        }
+        local_replacement = local_replacement.replace("\\", "");
+        pattern_space.replace_range(main_range.clone(), &local_replacement);
+    } else if !ranges.is_empty() {
+        local_replacement = local_replacement.replace("\\", "");
+        pattern_space.replace_range(main_range.clone(), &local_replacement);
+        return true;
+    }
+    false
+}
+
+/// Execute [`Command::Replace`] for current [`Sed`] line
+fn execute_replace(
+    pattern_space: &mut String,
+    command: Command,
+    line_number: usize,
+) -> Result<bool, SedError> {
+    let mut replace = false;
+    let Command::Replace(_, re, pattern, replacement, flags) = command else {
+        unreachable!();
+    };
+    let match_subranges = match_pattern(re.0, pattern, pattern_space, line_number)?;
+    let is_replace_n = |f: &ReplaceFlag| {
+        let ReplaceFlag::ReplaceNth(_) = f.clone() else {
+            return false;
+        };
+        true
+    };
+    if !match_subranges.is_empty()
+        && !flags.iter().any(is_replace_n)
+        && !flags.contains(&ReplaceFlag::ReplaceAll)
+    {
+        replace = update_pattern_space(pattern_space, &replacement, &match_subranges[0]);
+    } else if let Some(ReplaceFlag::ReplaceNth(n)) =
+        flags.iter().find(|f: &&ReplaceFlag| is_replace_n(f))
+    {
+        if let Some(ranges) = match_subranges.get(*n - 1) {
+            replace = update_pattern_space(pattern_space, &replacement, ranges);
+        }
+    } else if flags.contains(&ReplaceFlag::ReplaceAll) {
+        for ranges in match_subranges.iter().rev() {
+            let r = update_pattern_space(pattern_space, &replacement, ranges);
+            if !replace {
+                replace = r;
+            }
+        }
+    }
+
+    if flags.contains(&ReplaceFlag::PrintPatternIfReplace) && !match_subranges.is_empty() && replace
+    {
+        println!("{}", *pattern_space);
+    }
+
+    if let Some(wfile) = flags.iter().find_map(|flag| {
+        let ReplaceFlag::AppendToIfReplace(wfile) = flag else {
+            return None;
+        };
+        Some(wfile)
+    }) {
+        if replace && wfile.components().next().is_some() {
+            if let Ok(mut file) = std::fs::OpenOptions::new()
+                .append(true)
+                .create(true)
+                .open(wfile)
+                .map_err(SedError::Io)
+            {
+                let _ = file.write(pattern_space.as_bytes());
+            }
+        }
+    }
+
+    Ok(replace)
+}
+
+/// Set of states that are returned from [`Sed::execute`]
+/// for controling [`Sed`] [`Script`] execution loop for
+/// current input file
+#[derive(Debug)]
+enum ControlFlowInstruction {
+    /// End [`Sed`] [`Command`] execution loop for current file
+    Break,
+    /// Skip end of [`Script`], go to next line of current input
+    /// file and start again [`Script`], [`Sed`] cycle
+    Continue,
+    /// If string exist then go to label in [`Script`], else go
+    /// to end of [`Script`] (end current cycle)
+    Goto(Option<String>),
+    /// Not read next line in current input file and start new cycle
+    NotReadNext,
+    /// Read next line in current input file and continue current cycle
+    ReadNext,
+    /// Append next line to current pattern space and continue current cycle  
+    AppendNext,
+    // /// Skip print after cycle
+    // SkipPrint
+}
+
+/// Main program structure. Process input
+/// files by [`Script`] [`Command`]s
+struct Sed {
+    /// Use extended regular expresions
+    ere: bool,
+    /// Suppress default behavior of editing [`Command`]s
+    /// to print result
+    quiet: bool,
+    /// [`Script`] that applied for every line of every input file
+    script: Script,
+    /// List of input files that need process with [`Script`]
+    input_sources: Vec<String>,
+    /// Buffer with current line of processed input file,
+    /// but it can be changed with [`Command`]s in cycle limits.
+    /// Сleared every cycle
+    pattern_space: String,
+    /// Buffer that can be filled with certain [`Command`]s during
+    /// [`Script`] processing. It's not cleared after the cycle is
+    /// complete
+    hold_space: String,
+    /// Current processed input file
+    current_file: Option<Box<dyn BufRead>>,
+    /// Current line of current processed input file
+    current_line: usize,
+    /// [`true`] if since last t at least one replacement [`Command`]
+    /// was performed in cycle limits
+    has_replacements_since_t: bool,
+    /// Last regex_t in applied [`Command`]  
+    last_regex: Option<Regex>,
+    /// Next line for processing
+    next_line: String,
+    /// Indicate that current processed line is last
+    is_last_line: bool,
+    /// Contains chars '\n\r' line end of current line for processed file
+    current_end: Option<String>,
+}
+
+impl Sed {
+    /// Executes one command for `line` string argument
+    /// and updates [`Sed`] state
+    fn execute(
+        &mut self,
+        command_position: usize,
+    ) -> Result<Option<ControlFlowInstruction>, SedError> {
+        let Some(command) = self.script.0.get(command_position) else {
+            return Ok(Some(ControlFlowInstruction::Continue));
+        };
+        let mut instruction = None;
+        let current_command = command.clone();
+        match current_command {
+            Command::PrintTextAfter(_, text) => {
+                // a
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.pattern_space += &("\n".to_string() + &text);
+                self.current_end = Some("\n".to_string());
+            }
+            Command::BranchToLabel(_, label) => {
+                // b
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                instruction = Some(ControlFlowInstruction::Goto(label.clone()));
+            }
+            Command::DeletePatternAndPrintText(address, text) => {
+                // c
+                let _ = self.execute_c(command_position, address, text);
+            }
+            Command::DeletePattern(_, to_first_line) => {
+                // dD
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                instruction = self.execute_d(to_first_line);
+            }
+            Command::ReplacePatternWithHold(_) => {
+                // g
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                if let Some(hold_space) = self.hold_space.strip_suffix('\n') {
+                    self.current_end = Some("\n".to_string());
+                    self.pattern_space = hold_space.to_string();
+                } else {
+                    self.pattern_space = self.hold_space.clone();
+                }
+            }
+            Command::AppendHoldToPattern(_) => {
+                // G
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.execute_upper_g();
+            }
+            Command::ReplaceHoldWithPattern(_) => {
+                // h
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.hold_space = self.pattern_space.clone()
+                    + self.current_end.clone().unwrap_or_default().as_str();
+            }
+            Command::AppendPatternToHold(_) => {
+                // H
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                if self.hold_space.strip_suffix("\n").is_none() {
+                    self.hold_space = self.hold_space.clone() + "\n";
+                }
+                self.hold_space += &(self.pattern_space.clone()
+                    + self.current_end.clone().unwrap_or_default().as_str());
+            }
+            Command::PrintTextBefore(_, text) => {
+                // i
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                println!("{text}");
+            }
+            Command::PrintPatternBinary(_) => {
+                // I
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                print_multiline_binary(&self.pattern_space);
+            }
+            Command::PrintPatternAndReplaceWithNext(_) => {
+                // n
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                instruction = Some(ControlFlowInstruction::ReadNext);
+            }
+            Command::AppendNextToPattern(_address) => {
+                // N
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                instruction = Some(ControlFlowInstruction::AppendNext);
+            }
+            Command::PrintPattern(_, to_first_line) => {
+                // pP
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.execute_p(to_first_line);
+            }
+            Command::Quit(_) => {
+                // q
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                instruction = Some(ControlFlowInstruction::Break);
+            }
+            Command::PrintFile(_, rfile) => {
+                // r
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.execute_r(rfile);
+            }
+            Command::Replace(address, ref regex, pattern, replacement, flags) => {
+                // s
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.execute_s(address, regex, pattern, replacement, flags)?;
+            }
+            Command::Test(_, label) => {
+                // t
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                if self.has_replacements_since_t {
+                    instruction = Some(ControlFlowInstruction::Goto(label.clone()));
+                }
+                self.has_replacements_since_t = false;
+            }
+            Command::AppendPatternToFile(_, wfile) => {
+                // w
+                if !self.need_execute(command_position)? || wfile.components().next().is_none() {
+                    return Ok(None);
+                }
+                self.execute_w(wfile)?;
+            }
+            Command::ExchangeSpaces(_) => {
+                // x
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.execute_x();
+            }
+            Command::ReplaceCharSet(_, string1, string2) => {
+                // y
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                self.execute_y(string1, string2);
+            }
+            Command::PrintStandard(_) => {
+                // =
+                if !self.need_execute(command_position)? {
+                    return Ok(None);
+                }
+                if !self.quiet {
+                    println!("{}", self.current_line + 1);
+                }
+            }
+            Command::IgnoreComment if !self.quiet => {
+                // #
+                self.quiet = true;
+            }
+            Command::_Unknown => {}
+            Command::Block(..) => unreachable!(),
+            _ => {}
+        }
+        Ok(instruction)
+    }
+
+    fn execute_c(
+        &mut self,
+        command_position: usize,
+        address: Option<Address>,
+        text: String,
+    ) -> Result<(), SedError> {
+        if address.is_none() {
+            self.pattern_space.clear();
+            self.current_end = None;
+            println!("{text}");
+        } else {
+            let mut need_execute = self.need_execute(command_position)?;
+            if need_execute {
+                println!("{text}");
+            }
+            loop {
+                need_execute = self.need_execute(command_position)?;
+                if need_execute {
+                    let mut line = self.next_line.clone();
+                    self.next_line = self.read_line()?;
+                    self.current_line += 1;
+                    if line.is_empty() {
+                        break;
+                    }
+                    if let Some(l) = line.strip_suffix("\n") {
+                        line = l.to_string();
+                        self.current_end = Some("\n".to_string());
+                    } else {
+                        self.current_end = None;
+                    }
+                    self.pattern_space = line;
+                } else {
+                    break;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn execute_d(&mut self, to_first_line: bool) -> Option<ControlFlowInstruction> {
+        // D
+        if to_first_line && self.pattern_space.contains('\n') {
+            self.pattern_space = self
+                .pattern_space
+                .chars()
+                .skip_while(|ch| *ch == '\n')
+                .collect::<String>();
+            Some(ControlFlowInstruction::NotReadNext)
+        } else {
+            // d
+            self.pattern_space.clear();
+            Some(ControlFlowInstruction::Continue)
+        }
+    }
+
+    fn execute_upper_g(&mut self) {
+        self.pattern_space = self.pattern_space.clone()
+            + &self.current_end.clone().unwrap_or_default()
+            + &self.hold_space;
+        if self.hold_space.is_empty() {
+            self.pattern_space += "\n";
+        }
+        if self.pattern_space.strip_suffix('\n').is_some() {
+            self.pattern_space.pop();
+            self.current_end = Some("\n".to_string());
+        } else {
+            self.current_end = None;
+        }
+    }
+
+    fn execute_p(&mut self, to_first_line: bool) {
+        if !self.pattern_space.is_empty() {
+            if to_first_line {
+                let end = self
+                    .pattern_space
+                    .chars()
+                    .enumerate()
+                    .find(|(_, ch)| *ch == '\n')
+                    .map(|pair| pair.0)
+                    .unwrap_or(self.pattern_space.len());
+                print!("{}", &self.pattern_space[0..end]);
+            } else {
+                print!("{}", self.pattern_space);
+            }
+        }
+        if let Some(end) = &self.current_end {
+            print!("{end}");
+        }
+    }
+
+    fn execute_r(&mut self, rfile: PathBuf) {
+        if let Ok(file) = File::open(rfile) {
+            let reader = BufReader::new(file);
+            for line in reader.lines() {
+                let Ok(line) = line else {
+                    break;
+                };
+                self.pattern_space += "\n";
+                self.pattern_space += &line;
+            }
+            if self.current_end.is_none() {
+                self.current_end = Some("\n".to_string());
+            }
+        } else {
+            self.current_end = Some("\n".to_string());
+        }
+    }
+
+    fn execute_s(
+        &mut self,
+        address: Option<Address>,
+        regex: &Regex,
+        pattern: String,
+        replacement: String,
+        flags: Vec<ReplaceFlag>,
+    ) -> Result<(), SedError> {
+        let mut regex = regex.clone();
+        if pattern.is_empty() {
+            if let Some(last_regex) = &self.last_regex {
+                regex = last_regex.clone();
+            } else {
+                return Err(SedError::NoRegex);
+            }
+        }
+        self.has_replacements_since_t = execute_replace(
+            &mut self.pattern_space,
+            Command::Replace(address, regex.clone(), pattern, replacement, flags),
+            self.current_line,
+        )?;
+        self.last_regex = Some(regex.clone());
+        Ok(())
+    }
+
+    fn execute_w(&mut self, wfile: PathBuf) -> Result<(), SedError> {
+        let _ = match std::fs::OpenOptions::new()
+            .append(true)
+            .create(true)
+            .open(wfile.clone())
+        {
+            Ok(mut file) => file.write(self.pattern_space.as_bytes()),
+            Err(err) => {
+                return Err(SedError::Io(Error::new(
+                    ErrorKind::NotFound,
+                    format!(
+                        "can't find '{}': {}",
+                        wfile.display(),
+                        err.to_string().to_lowercase()
+                    ),
+                )));
+            }
+        };
+        Ok(())
+    }
+
+    fn execute_x(&mut self) {
+        if let Some(hold_space) = self.hold_space.strip_suffix('\n') {
+            let tmp = hold_space.to_string();
+            self.hold_space =
+                self.pattern_space.clone() + self.current_end.clone().unwrap_or_default().as_str();
+            self.current_end = Some("\n".to_string());
+            self.pattern_space = tmp;
+        } else {
+            let tmp = self.hold_space.clone();
+            self.hold_space =
+                self.pattern_space.clone() + self.current_end.clone().unwrap_or_default().as_str();
+            self.pattern_space = tmp.clone();
+            self.current_end = if !tmp.is_empty() {
+                None
+            } else {
+                Some("\n".to_string())
+            };
+        }
+    }
+
+    fn execute_y(&mut self, string1: String, string2: String) {
+        let mut replace_positions = vec![];
+        for (a, b) in string1.chars().zip(string2.chars()) {
+            let positions = self
+                .pattern_space
+                .chars()
+                .enumerate()
+                .filter_map(|(i, ch)| if ch == a { Some(i) } else { None })
+                .collect::<Vec<_>>();
+            replace_positions.push((b.to_string(), positions));
+        }
+        for (ch, positions) in replace_positions {
+            for position in positions {
+                self.pattern_space
+                    .replace_range(position..(position + 1), &ch);
+            }
+        }
+        self.pattern_space = self.pattern_space.replace("\\n", "\n");
+        self.has_replacements_since_t = true;
+    }
+
+    /// Read next line from current file
+    fn read_line(&mut self) -> Result<String, SedError> {
+        let Some(current_file) = self.current_file.as_mut() else {
+            return Err(SedError::Io(std::io::Error::new(
+                ErrorKind::NotFound,
+                "current file is none",
+            )));
+        };
+        let mut line = String::new();
+        if let Err(err) = current_file.read_line(&mut line) {
+            return Err(SedError::Io(err));
+        }
+        Ok(line)
+    }
+
+    fn need_execute(&mut self, command_position: usize) -> Result<bool, SedError> {
+        let Some(command) = self.script.0.get_mut(command_position) else {
+            return Ok(false);
+        };
+
+        let need_execute =
+            command.need_execute(self.current_line, &self.pattern_space, self.is_last_line)?;
+
+        Ok(need_execute)
+    }
+
+    /// Executes all commands of [`Sed`]'s [`Script`] for `line` string argument
+    fn process_line(&mut self) -> Result<Option<ControlFlowInstruction>, SedError> {
+        let mut global_instruction = None;
+        let mut i = 0;
+        let script_len = self.script.0.len();
+        while i < script_len {
+            if let Some(instruction) = self.execute(i)? {
+                global_instruction = None;
+                match instruction {
+                    ControlFlowInstruction::Goto(label) => {
+                        if let Some(label) = label {
+                            let label_position = self.script.0.iter().position(|cmd| {
+                                if let Command::BearBranchLabel(l) = cmd {
+                                    label == *l
+                                } else {
+                                    false
+                                }
+                            });
+                            if let Some(label_position) = label_position {
+                                i = label_position;
+                            } else {
+                                return Err(SedError::NoLabel(label));
+                            }
+                        } else {
+                            break;
+                        }
+                    }
+                    ControlFlowInstruction::Break => {
+                        global_instruction = Some(ControlFlowInstruction::Break);
+                        break;
+                    }
+                    ControlFlowInstruction::Continue => {
+                        if self.pattern_space.is_empty() {
+                            return Ok(None);
+                        } else {
+                            break;
+                        }
+                    }
+                    ControlFlowInstruction::NotReadNext => {
+                        self.hold_space.clear();
+                        i = 0;
+                    }
+                    ControlFlowInstruction::AppendNext => {
+                        let mut line = self.next_line.clone();
+                        self.next_line = self.read_line()?;
+                        self.current_line += 1;
+                        if line.is_empty() {
+                            return Ok(None);
+                        }
+                        if let Some(l) = line.strip_suffix("\n") {
+                            self.current_end = Some("\n".to_string());
+                            line = l.to_string();
+                        } else {
+                            self.current_end = None;
+                        }
+                        self.pattern_space += "\n";
+                        self.pattern_space += &line;
+                    }
+                    ControlFlowInstruction::ReadNext => {
+                        let mut line = self.next_line.clone();
+                        self.next_line = self.read_line()?;
+                        self.current_line += 1;
+                        if line.is_empty() {
+                            break;
+                        }
+                        if !self.quiet {
+                            print!("{}", self.pattern_space);
+                            print!("{}", self.current_end.clone().unwrap_or_default());
+                        }
+                        if let Some(l) = line.strip_suffix("\n") {
+                            line = l.to_string();
+                        }
+                        self.current_end = Some("\n".to_string());
+                        self.pattern_space = line;
+                    }
+                }
+            }
+
+            i += 1;
+        }
+
+        if !self.quiet {
+            if !self.pattern_space.is_empty() {
+                print!("{}", self.pattern_space.trim_end_matches('\r'));
+            }
+            if let Some(end) = &self.current_end {
+                print!("{end}");
+            }
+        }
+
+        Ok(global_instruction)
+    }
+
+    /// Executes all commands of [`Sed`]'s [`Script`]
+    /// for all content of `reader` file argument
+    fn process_input(&mut self) -> Result<(), SedError> {
+        self.pattern_space.clear();
+        self.hold_space.clear();
+        self.current_line = 0;
+        self.is_last_line = false;
+        let mut line;
+        self.current_end = None;
+        self.next_line = self.read_line()?;
+        loop {
+            line = self.next_line.clone();
+            self.next_line = self.read_line()?;
+            self.is_last_line = self.next_line.is_empty();
+            if line.is_empty() {
+                break;
+            }
+            if let Some(l) = line.strip_suffix("\n") {
+                self.current_end = Some("\n".to_string());
+                line = l.to_string();
+            } else {
+                self.current_end = None;
+            }
+            self.has_replacements_since_t = false;
+            self.pattern_space = line;
+            if let Some(ControlFlowInstruction::Break) = self.process_line()? {
+                break;
+            }
+            self.current_line += 1;
+        }
+
+        Ok(())
+    }
+
+    /// Main [`Sed`] function. Executes all commands of
+    /// own [`Script`] for all content of all input files
+    fn sed(&mut self) -> Result<(), SedError> {
+        *ERE.lock().unwrap() = self.ere;
+        for mut input in self.input_sources.drain(..).collect::<Vec<_>>() {
+            self.current_file = Some(if input == "-" {
+                Box::new(BufReader::new(std::io::stdin()))
+            } else {
+                match File::open(&input) {
+                    Ok(file) => Box::new(BufReader::new(file)),
+                    Err(err) => {
+                        if input == "-" {
+                            input = "stdin".to_string();
+                        }
+                        eprintln!("sed: read {input}: {err}");
+                        continue;
+                    }
+                }
+            });
+            match self.process_input() {
+                Ok(_) => {}
+                Err(err) => {
+                    if input == "-" {
+                        input = "stdin".to_string();
+                    }
+                    return Err(SedError::Runtime(input, format!("{}", err)));
+                }
+            };
+        }
+
+        Ok(())
+    }
+}
+
+/// Exit code:
+///     0 - Successful completion.
+///     >0 - An error occurred.
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    setlocale(LocaleCategory::LcAll, "");
+    let project_name = std::env::var("PROJECT_NAME")
+        .ok()
+        .unwrap_or("posixutil-text".to_string());
+    textdomain(&*project_name)?;
+    bind_textdomain_codeset(&*project_name, "UTF-8")?;
+
+    let args = Args::parse();
+
+    let exit_code = Args::try_to_sed(args)
+        .and_then(|mut sed| sed.sed())
+        .map(|_| 0)
+        .unwrap_or_else(|err| {
+            eprintln!("sed: {err}");
+            1
+        });
+
+    std::process::exit(exit_code);
+}
diff --git a/text/tests/sed/assets/abc b/text/tests/sed/assets/abc
new file mode 100644
index 000000000..8baef1b4a
--- /dev/null
+++ b/text/tests/sed/assets/abc
@@ -0,0 +1 @@
+abc
diff --git a/text/tests/sed/assets/cba b/text/tests/sed/assets/cba
new file mode 100644
index 000000000..59d2d1ca6
--- /dev/null
+++ b/text/tests/sed/assets/cba
@@ -0,0 +1 @@
+cba
diff --git a/text/tests/sed/assets/newfile b/text/tests/sed/assets/newfile
new file mode 100644
index 000000000..0d059da4d
--- /dev/null
+++ b/text/tests/sed/assets/newfile
@@ -0,0 +1 @@
+abcabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdfabccdf
\ No newline at end of file
diff --git a/text/tests/sed/assets/script_a b/text/tests/sed/assets/script_a
new file mode 100644
index 000000000..0040d6424
--- /dev/null
+++ b/text/tests/sed/assets/script_a
@@ -0,0 +1 @@
+s/a/ab/g
\ No newline at end of file
diff --git a/text/tests/sed/assets/script_all_newlines b/text/tests/sed/assets/script_all_newlines
new file mode 100644
index 000000000..b28b04f64
--- /dev/null
+++ b/text/tests/sed/assets/script_all_newlines
@@ -0,0 +1,3 @@
+
+
+
diff --git a/text/tests/sed/assets/script_b b/text/tests/sed/assets/script_b
new file mode 100644
index 000000000..92450be7c
--- /dev/null
+++ b/text/tests/sed/assets/script_b
@@ -0,0 +1 @@
+s/b/bc/g
\ No newline at end of file
diff --git a/text/tests/sed/assets/script_blanks b/text/tests/sed/assets/script_blanks
new file mode 100644
index 000000000..a7a770307
--- /dev/null
+++ b/text/tests/sed/assets/script_blanks
@@ -0,0 +1,3 @@
+   s/a/ab/g;
+   s/b/bc/g;
+   s/c/ca/g
\ No newline at end of file
diff --git a/text/tests/sed/assets/script_c b/text/tests/sed/assets/script_c
new file mode 100644
index 000000000..301ee0d10
--- /dev/null
+++ b/text/tests/sed/assets/script_c
@@ -0,0 +1 @@
+s/c/ca/g
\ No newline at end of file
diff --git a/text/tests/sed/assets/script_semicolons b/text/tests/sed/assets/script_semicolons
new file mode 100644
index 000000000..2007fe1e2
--- /dev/null
+++ b/text/tests/sed/assets/script_semicolons
@@ -0,0 +1,3 @@
+;;;s/a/ab/g
+;;;s/b/bc/g
+;;;s/c/ca/g
\ No newline at end of file
diff --git a/text/tests/sed/assets/script_some_newlines b/text/tests/sed/assets/script_some_newlines
new file mode 100644
index 000000000..350c97206
--- /dev/null
+++ b/text/tests/sed/assets/script_some_newlines
@@ -0,0 +1,5 @@
+s/a/ab/g;
+s/b/bc/g;
+s/c/ca/g
+
+
diff --git a/text/tests/sed/mod.rs b/text/tests/sed/mod.rs
new file mode 100644
index 000000000..8f4048d51
--- /dev/null
+++ b/text/tests/sed/mod.rs
@@ -0,0 +1,2275 @@
+//
+// Copyright (c) 2024 Hemi Labs, Inc.
+//
+// This file is part of the posixutils-rs project covered under
+// the MIT License.  For the full license text, please see the LICENSE
+// file in the root directory of this project.
+// SPDX-License-Identifier: MIT
+//
+
+use plib::testing::{run_test, TestPlan};
+
+fn sed_test(
+    args: &[&str],
+    test_data: &str,
+    expected_output: &str,
+    expected_err: &str,
+    expected_exit_code: i32,
+) {
+    let str_args: Vec<String> = args.iter().map(|s| String::from(*s)).collect();
+
+    run_test(TestPlan {
+        cmd: String::from("sed"),
+        args: str_args,
+        stdin_data: String::from(test_data),
+        expected_out: String::from(expected_output),
+        expected_err: String::from(expected_err),
+        expected_exit_code,
+    });
+}
+
+const ABC_INPUT: &str = "abc\n";
+const SCRIPT_A: &str = "s/a/ab/g";
+const SCRIPT_B: &str = "s/b/bc/g";
+const SCRIPT_C: &str = "s/c/ca/g";
+const SCRIPT_SOME_NEWLINES: &str = "s/a/ab/g;\ns/b/bc/g;\ns/c/ca/g\n\n\n";
+const SCRIPT_ALL_NEWLINES: &str = "\n\n\n";
+const SCRIPT_BLANKS: &str = "   s/a/ab/g;\n   s/b/bc/g;\n   s/c/ca/g";
+const SCRIPT_SEMICOLONS: &str = ";;;s/a/ab/g\n;;;s/b/bc/g\n;;;s/c/ca/g";
+
+const ABC_FILE: &str = "tests/sed/assets/abc";
+const CBA_FILE: &str = "tests/sed/assets/cba";
+const SCRIPT_A_FILE: &str = "tests/sed/assets/script_a";
+const SCRIPT_B_FILE: &str = "tests/sed/assets/script_b";
+const SCRIPT_C_FILE: &str = "tests/sed/assets/script_c";
+const SCRIPT_SOME_NEWLINES_FILE: &str = "tests/sed/assets/script_some_newlines";
+const SCRIPT_ALL_NEWLINES_FILE: &str = "tests/sed/assets/script_all_newlines";
+const SCRIPT_BLANKS_FILE: &str = "tests/sed/assets/script_blanks";
+const SCRIPT_SEMICOLONS_FILE: &str = "tests/sed/assets/script_blanks";
+
+#[cfg(test)]
+mod tests {
+    use crate::sed::*;
+
+    #[test]
+    fn test_no_arguments() {
+        sed_test(&[], "", "", "sed: none script was supplied\n", 1);
+    }
+
+    #[test]
+    fn test_single_script_input_stdin() {
+        sed_test(&[SCRIPT_A], ABC_INPUT, "abbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_single_script_input_file() {
+        sed_test(&[SCRIPT_A, ABC_FILE], "", "abbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_e_script_input_stdin() {
+        sed_test(&["-e", SCRIPT_A], ABC_INPUT, "abbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_e_script_input_file() {
+        sed_test(&["-e", SCRIPT_A, ABC_FILE], "", "abbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_f_script_input_stdin() {
+        sed_test(&["-f", SCRIPT_A_FILE], ABC_INPUT, "abbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_f_script_input_file() {
+        sed_test(&["-f", SCRIPT_A_FILE, ABC_FILE], "", "abbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_e_f_scripts_input_stdin() {
+        sed_test(
+            &["-e", SCRIPT_A, "-f", SCRIPT_B_FILE],
+            ABC_INPUT,
+            "abcbcc\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_e_f_scripts_input_file() {
+        sed_test(
+            &["-e", SCRIPT_A, "-f", SCRIPT_B_FILE, ABC_FILE],
+            "",
+            "abcbcc\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_input_explicit_stdin() {
+        sed_test(&[SCRIPT_A, "-"], ABC_INPUT, "abbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_ignore_stdin_without_dash() {
+        sed_test(&[SCRIPT_A, CBA_FILE], ABC_INPUT, "cbab\n", "", 0);
+    }
+
+    #[test]
+    fn test_input_file_and_explicit_stdin() {
+        // Reorderind STDIN and input file
+        sed_test(&[SCRIPT_A, "-", CBA_FILE], ABC_INPUT, "abbc\ncbab\n", "", 0);
+        sed_test(&[SCRIPT_A, CBA_FILE, "-"], ABC_INPUT, "cbab\nabbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_single_script_multiple_input_files() {
+        // Reorderind input files
+        sed_test(&[SCRIPT_A, ABC_FILE, CBA_FILE], "", "abbc\ncbab\n", "", 0);
+        sed_test(&[SCRIPT_A, CBA_FILE, ABC_FILE], "", "cbab\nabbc\n", "", 0);
+    }
+
+    #[test]
+    fn test_e_scripts_multiple_input_files() {
+        // Reorderind input files
+        sed_test(
+            &["-e", SCRIPT_A, "-e", SCRIPT_B, ABC_FILE, CBA_FILE],
+            "",
+            "abcbcc\ncbcabc\n",
+            "",
+            0,
+        );
+        sed_test(
+            &["-e", SCRIPT_A, "-e", SCRIPT_B, CBA_FILE, ABC_FILE],
+            "",
+            "cbcabc\nabcbcc\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_e_scripts_multiple_input_files_mixed_order() {
+        // Reorderind input files
+        sed_test(
+            &[ABC_FILE, "-e", SCRIPT_A, CBA_FILE, "-e", SCRIPT_B],
+            "",
+            "abcbcc\ncbcabc\n",
+            "",
+            0,
+        );
+        sed_test(
+            &[CBA_FILE, "-e", SCRIPT_A, ABC_FILE, "-e", SCRIPT_B],
+            "",
+            "cbcabc\nabcbcc\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_f_scripts_multiple_input_files() {
+        // Reorderind input files
+        sed_test(
+            &["-f", SCRIPT_A_FILE, "-f", SCRIPT_B_FILE, ABC_FILE, CBA_FILE],
+            "",
+            "abcbcc\ncbcabc\n",
+            "",
+            0,
+        );
+        sed_test(
+            &["-f", SCRIPT_A_FILE, "-f", SCRIPT_B_FILE, CBA_FILE, ABC_FILE],
+            "",
+            "cbcabc\nabcbcc\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_f_scripts_multiple_input_files_mixed_order() {
+        // Reorderind input files
+        sed_test(
+            &[ABC_FILE, "-f", SCRIPT_A_FILE, CBA_FILE, "-f", SCRIPT_B_FILE],
+            "",
+            "abcbcc\ncbcabc\n",
+            "",
+            0,
+        );
+        sed_test(
+            &[CBA_FILE, "-f", SCRIPT_A_FILE, ABC_FILE, "-f", SCRIPT_B_FILE],
+            "",
+            "cbcabc\nabcbcc\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_e_scripts_unique_order_unique_results() {
+        sed_test(
+            &["-e", SCRIPT_A, "-e", SCRIPT_B, "-e", SCRIPT_C],
+            ABC_INPUT,
+            "abcabcaca\n",
+            "",
+            0,
+        );
+        sed_test(
+            &["-e", SCRIPT_A, "-e", SCRIPT_C, "-e", SCRIPT_B],
+            ABC_INPUT,
+            "abcbcca\n",
+            "",
+            0,
+        );
+        sed_test(
+            &["-e", SCRIPT_B, "-e", SCRIPT_A, "-e", SCRIPT_C],
+            ABC_INPUT,
+            "abbcaca\n",
+            "",
+            0,
+        );
+        sed_test(
+            &["-e", SCRIPT_B, "-e", SCRIPT_C, "-e", SCRIPT_A],
+            ABC_INPUT,
+            "abbcabcab\n",
+            "",
+            0,
+        );
+        sed_test(
+            &["-e", SCRIPT_C, "-e", SCRIPT_A, "-e", SCRIPT_B],
+            ABC_INPUT,
+            "abcbccabc\n",
+            "",
+            0,
+        );
+        sed_test(
+            &["-e", SCRIPT_C, "-e", SCRIPT_B, "-e", SCRIPT_A],
+            ABC_INPUT,
+            "abbccab\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_f_scripts_unique_order_unique_results() {
+        sed_test(
+            &[
+                "-f",
+                SCRIPT_A_FILE,
+                "-f",
+                SCRIPT_B_FILE,
+                "-f",
+                SCRIPT_C_FILE,
+            ],
+            ABC_INPUT,
+            "abcabcaca\n",
+            "",
+            0,
+        );
+        sed_test(
+            &[
+                "-f",
+                SCRIPT_A_FILE,
+                "-f",
+                SCRIPT_C_FILE,
+                "-f",
+                SCRIPT_B_FILE,
+            ],
+            ABC_INPUT,
+            "abcbcca\n",
+            "",
+            0,
+        );
+        sed_test(
+            &[
+                "-f",
+                SCRIPT_B_FILE,
+                "-f",
+                SCRIPT_A_FILE,
+                "-f",
+                SCRIPT_C_FILE,
+            ],
+            ABC_INPUT,
+            "abbcaca\n",
+            "",
+            0,
+        );
+        sed_test(
+            &[
+                "-f",
+                SCRIPT_B_FILE,
+                "-f",
+                SCRIPT_C_FILE,
+                "-f",
+                SCRIPT_A_FILE,
+            ],
+            ABC_INPUT,
+            "abbcabcab\n",
+            "",
+            0,
+        );
+        sed_test(
+            &[
+                "-f",
+                SCRIPT_C_FILE,
+                "-f",
+                SCRIPT_A_FILE,
+                "-f",
+                SCRIPT_B_FILE,
+            ],
+            ABC_INPUT,
+            "abcbccabc\n",
+            "",
+            0,
+        );
+        sed_test(
+            &[
+                "-f",
+                SCRIPT_C_FILE,
+                "-f",
+                SCRIPT_B_FILE,
+                "-f",
+                SCRIPT_A_FILE,
+            ],
+            ABC_INPUT,
+            "abbccab\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_mixed_e_f_scripts() {
+        // -e script -f script -e script
+        sed_test(
+            &["-e", SCRIPT_A, "-f", SCRIPT_B_FILE, "-e", SCRIPT_C],
+            ABC_INPUT,
+            "abcabcaca\n",
+            "",
+            0,
+        );
+        // -f script -e script -f script
+        sed_test(
+            &["-f", SCRIPT_A_FILE, "-e", SCRIPT_C, "-f", SCRIPT_B_FILE],
+            ABC_INPUT,
+            "abcbcca\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_script_some_newlines() {
+        sed_test(
+            &["-e", SCRIPT_SOME_NEWLINES],
+            ABC_INPUT,
+            "abcabcaca\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_script_all_newlines() {
+        sed_test(&[SCRIPT_ALL_NEWLINES], ABC_INPUT, ABC_INPUT, "", 0);
+    }
+
+    #[test]
+    fn test_e_script_some_newlines() {
+        sed_test(
+            &["-e", SCRIPT_SOME_NEWLINES],
+            ABC_INPUT,
+            "abcabcaca\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_e_script_all_newlines() {
+        sed_test(&["-e", SCRIPT_ALL_NEWLINES], ABC_INPUT, ABC_INPUT, "", 0);
+    }
+
+    #[test]
+    fn test_f_script_some_newlines() {
+        sed_test(
+            &["-f", SCRIPT_SOME_NEWLINES_FILE],
+            ABC_INPUT,
+            "abcabcaca\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_f_script_all_newlines() {
+        sed_test(
+            &["-f", SCRIPT_ALL_NEWLINES_FILE],
+            ABC_INPUT,
+            ABC_INPUT,
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_single_script_ignore_blank_chars() {
+        sed_test(&["-e", SCRIPT_BLANKS], ABC_INPUT, "abcabcaca\n", "", 0);
+    }
+
+    #[test]
+    fn test_e_script_ignore_blank_chars() {
+        sed_test(&["-e", SCRIPT_BLANKS], ABC_INPUT, "abcabcaca\n", "", 0);
+    }
+
+    #[test]
+    fn test_f_script_ignore_blank_chars() {
+        sed_test(&["-f", SCRIPT_BLANKS_FILE], ABC_INPUT, "abcabcaca\n", "", 0);
+    }
+
+    #[test]
+    fn test_single_script_ignore_semicolon_chars() {
+        sed_test(&[SCRIPT_SEMICOLONS], ABC_INPUT, "abcabcaca\n", "", 0);
+    }
+
+    #[test]
+    fn test_e_script_ignore_semicolon_chars() {
+        sed_test(&["-e", SCRIPT_SEMICOLONS], ABC_INPUT, "abcabcaca\n", "", 0);
+    }
+
+    #[test]
+    fn test_f_script_ignore_semicolon_chars() {
+        sed_test(
+            &["-f", SCRIPT_SEMICOLONS_FILE],
+            ABC_INPUT,
+            "abcabcaca\n",
+            "",
+            0,
+        );
+    }
+
+    #[test]
+    fn test_delimiters() {
+        let test_data = [
+            // correct
+            (";;;;", "abc\ndef\n@#$\n", "abc\ndef\n@#$\n", ""),
+            (";\n;\n;;", "abc\ndef\n@#$\n", "abc\ndef\n@#$\n", ""),
+            // wrong
+            (
+                ";\\;\\;;",
+                "abc\ndef\n@#$",
+                "",
+                "sed: pattern can't consist more than 1 line (line: 0, col: 2)\n",
+            ),
+            (
+                ";\\ ;;;",
+                "abc\ndef\n@#$",
+                "",
+                "sed: unterminated address regex (line: 0, col: 2)\n",
+            ),
+            (
+                "gh",
+                "abc\ndef\n@#$",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+            (
+                "g h",
+                "abc\ndef\n@#$",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "g; h \n gh \n g h ; gh \\",
+                "abc\ndef\n@#$",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_address_correct() {
+        let test_data = [
+            // correct
+            ("1,10 p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\na\nb\nb\nc\nc\nd\nd\ne\ne\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nq\nh\nw\n", ""),                    
+            ("1,10p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\na\nb\nb\nc\nc\nd\nd\ne\ne\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nq\nh\nw\n", ""),
+            ("1,10 p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\na\nb\nb\nc\nc\nd\nd\ne\ne\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nq\nh\nw\n", ""),
+            ("10 p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nt\nw\nq\nh\nw\n", ""),
+            ("1,$p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\na\nb\nb\nc\nc\nd\nd\ne\ne\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nw\nq\nq\nh\nh\nw\nw\n", ""),                 
+            ("1,$ p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\na\nb\nb\nc\nc\nd\nd\ne\ne\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nw\nq\nq\nh\nh\nw\nw\n", ""),            
+            ("$ p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\nw\n", ""),
+            ("$ p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\nw\n", ""),
+            ("$,$p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\nw\n", ""),
+            ("$,$ p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\nw\n", ""),                  
+            ("1, 10 p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\na\nb\nb\nc\nc\nd\nd\ne\ne\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nq\nh\nw\n", ""),                
+            ("1 ,10 p", "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw\n", "a\na\nb\nb\nc\nc\nd\nd\ne\ne\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nq\nh\nw\n", "")        
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_address_wrong() {
+        let test_data = [
+            // wrong
+            (
+                "1, p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address bound can be only one pattern, number or '$' (line: 0, col: 4)\n",
+            ),
+            (
+                ",10 p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: unknown character ',' (line: 0, col: 1)\n",
+            ),
+            (
+                ", p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: unknown character ',' (line: 0, col: 1)\n",
+            ),
+            (
+                ",,p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: unknown character ',' (line: 0, col: 1)\n",
+            ),
+            (
+                "1,2,3,4,5 p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address isn't empty, position or range (line: 0, col: 11)\n",
+            ),
+            (
+                "0,-10 p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address bound can be only one pattern, number or '$' (line: 0, col: 3)\n",
+            ),
+            (
+                "1,10; p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address hasn't command (line: 0, col: 5)\n",
+            ),
+            (
+                "0 10 p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address bound can be only one pattern, number or '$' (line: 0, col: 6)\n",
+            ),
+            (
+                "1,+3p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address bound can be only one pattern, number or '$' (line: 0, col: 3)\n",
+            ),
+            (
+                "/5/,+3p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: unknown character '/' (line: 0, col: 1)\n",
+            ),
+            (
+                "7;+ p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address hasn't command (line: 0, col: 2)\n",
+            ),
+            (
+                "+++ p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: unknown character '+' (line: 0, col: 1)\n",
+            ),
+            (
+                "p; -2 p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: unknown character '-' (line: 0, col: 4)\n",
+            ),
+            (
+                "3 ---- 2p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: unknown character '-' (line: 0, col: 3)\n",
+            ),
+            (
+                "1 2 3 p",
+                "a\nb\nc\nd\ne\nf\ng\nm\nn\nt\nw\nq\nh\nw",
+                "",
+                "sed: address bound can be only one pattern, number or '$' (line: 0, col: 7)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_address_with_bre() {
+        let test_data = [
+            // correct
+            (
+                r"\/abc/,10 p",
+                "a\nb\nc\nd\nabc\nf\ng\nm\nn\nt\nw\nq\nh\nw\n",
+                "a\nb\nc\nd\nabc\nabc\nf\nf\ng\ng\nm\nm\nn\nn\nt\nt\nw\nq\nh\nw\n",
+                "",
+            ),
+            (
+                r"\/abc/ p",
+                "a\nb\nc\nd\nabc\nf\ng\nm\nn\nt\nw\nq\nh\nw\n",
+                "a\nb\nc\nd\nabc\nabc\nf\ng\nm\nn\nt\nw\nq\nh\nw\n",
+                "",
+            ),
+            (
+                r"\@abc@ p",
+                "a\nb\nc\nd\nabc\nf\ng\nm\nn\nt\nw\nq\nh\nw\n",
+                "a\nb\nc\nd\nabc\nabc\nf\ng\nm\nn\nt\nw\nq\nh\nw\n",
+                "",
+            ),
+            (
+                r"\/ab\/c/ p",
+                "aaa\nbbb\nab/c\nabc\nbc\n\n",
+                "aaa\nbbb\nab/c\nab/c\nabc\nbc\n\n",
+                "",
+            ),
+            (
+                r"\/abc/,\!cdf! p",
+                "abt\nrbc\nabc\n\ncde\nedf\ncdf\ncdf\nwert\nbfb\n",
+                "abt\nrbc\nabc\nabc\n\n\ncde\ncde\nedf\nedf\ncdf\ncdf\ncdf\nwert\nbfb\n",
+                "",
+            ),
+            // wrong
+            (
+                "\\/abc/10 p",
+                "abc\ndef\n@#$",
+                "",
+                "sed: address bound can be only one pattern, number or '$' (line: 0, col: 10)\n",
+            ),
+            (
+                "@abc@ p",
+                "abc\ndef\n@#$",
+                "",
+                "sed: unknown character '@' (line: 0, col: 1)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_block() {
+        let test_data = [
+            // correct
+            ("{}", "abc\ndef\n@@##%%#^\n", "abc\ndef\n@@##%%#^\n", ""),
+            ("{ }", "abc\ndef\n@@##%%#^\n", "abc\ndef\n@@##%%#^\n", ""),
+            (
+                "{ \n \n \n }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "{ { \n }; {}; {\n}; { }; }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "{ { \n }; {}; {\n}; { } }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "{ { { { { { { { {} } } } } } } } }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "{ { { { { { { { {}; }; }; }; }; }; }; }; }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "1,10 { 5,10 p }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "1,10 { 5,10 { 7,10 p } }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "1,10 { 5,7 { 7,15 p } }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "1,10 { 10,15 { 15,20 p } }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            // wrong
+            (
+                "{ { \n } {} {\n} { } }",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 4)\n",
+            ),
+            (
+                "15,10 { 10,5 { 5,1 p } }",
+                "abc\ndef\n@@##%%#^\n",
+                "abc\ndef\n@@##%%#^\n",
+                "",
+            ),
+            (
+                "{",
+                "abc\ndef\n@@##%%#^",
+                "",
+                "sed: '{' not have pair for closing block (line: 0, col: 1)\n",
+            ),
+            (
+                "}",
+                "abc\ndef\n@@##%%#^",
+                "",
+                "sed: unneccessary '}' (line: 0, col: 1)\n",
+            ),
+            (
+                "{ { { { { { {} } } } } } } } }",
+                "abc\ndef\n@@##%%#^",
+                "",
+                "sed: unneccessary '}' (line: 0, col: 28)\n",
+            ),
+            (
+                "{ { { { { { { { {} } } } } } }",
+                "abc\ndef\n@@##%%#^",
+                "",
+                "sed: '{' not have pair for closing block (line: 0, col: 1)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_a() {
+        let test_data = [
+            // correct
+            (
+                "a\\text",
+                "abc\ndef\n@#$\n",
+                "abc\ntext\ndef\ntext\n@#$\ntext\n",
+                "",
+            ),
+            (
+                "a\\   text\\in\\sed",
+                "abc\ndef\n@#$",
+                "abc\n   textinsed\ndef\n   textinsed\n@#$\n   textinsed\n",
+                "",
+            ),
+            (
+                "a\\ text text ; text",
+                "abc\ndef\n@#$",
+                "abc\n text text ; text\ndef\n text text ; text\n@#$\n text text ; text\n",
+                "",
+            ),
+            // wrong
+            (
+                "a\\",
+                "abc\ndef\n@#$",
+                "",
+                "sed: missing text argument (line: 1, col: 1)\n",
+            ),
+            (
+                "a  \text",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "a\text",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "a\text\\in\\sed",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "a\\ text text \n text ",
+                "abc\ndef\n@#$",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 2)\n",
+            ),
+            (
+                "atext",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "a text",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_b() {
+        let test_data = [
+            // correct
+            ("b", "aa\naa\n", "aa\naa\n", ""),
+            ("b label; :label", "aa\naa\n", "aa\naa\n", ""),
+            ("b label1; :label1", "aa\naa\n", "aa\naa\n", ""),
+            ("b lab2el1abc; :lab2el1abc", "aa\naa\n", "aa\naa\n", ""),
+            ("b loop_; :loop_", "aa\naa\n", "aa\naa\n", ""),
+            ("b _start; :_start", "aa\naa\n", "aa\naa\n", ""),
+            ("b my_label; :my_label", "aa\naa\n", "aa\naa\n", ""),
+            ("b #%$?@&*; :#%$?@&*", "aa\naa\n", "aa\naa\n", ""),
+            ("b 1label; :1label", "aa\naa\n", "aa\naa\n", ""),
+            ("b 1234; :1234", "aa\naa\n", "aa\naa\n", ""),
+            ("b #%$?@&*;", "aa\naa", "aa\naa", ""),
+            // wrong
+            ("b; :label", "aa\naa\n", "aa\naa\n", ""),
+            (
+                "b label#; :label#",
+                "aa\naa\n",
+                "",
+                "sed: can't find label for jump to `label'\n",
+            ),
+            (
+                "b ab\ncd; :ab\ncd",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 1)\n",
+            ),
+            (
+                "b label",
+                "aa\naa",
+                "",
+                "sed: can't find label for jump to `label'\n",
+            ),
+            (
+                "b label#",
+                "aa\naa",
+                "",
+                "sed: can't find label for jump to `label'\n",
+            ),
+            (
+                "b 1label",
+                "aa\naa",
+                "",
+                "sed: can't find label for jump to `1label'\n",
+            ),
+            (
+                "b 1234",
+                "aa\naa",
+                "",
+                "sed: can't find label for jump to `1234'\n",
+            ),
+            (
+                "b g",
+                "aa\naa",
+                "",
+                "sed: can't find label for jump to `g'\n",
+            ),
+            (
+                "b; label",
+                "aa\naa",
+                "",
+                "sed: unknown character 'l' (line: 0, col: 4)\n",
+            ),
+            (
+                "b :label",
+                "aa\naa",
+                "",
+                "sed: can't find label for jump to `:label'\n",
+            ),
+            (
+                "b label :label",
+                "aa\naa",
+                "",
+                "sed: label can't contain ' ' (line: 0, col: 14)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_c() {
+        let test_data = [
+            // correct
+            ("c\\text", "abc\ndef\n@#$", "text\ntext\ntext\n", ""),
+            (
+                "c\\   text\\in\\sed",
+                "abc\ndef\n@#$",
+                "   textinsed\n   textinsed\n   textinsed\n",
+                "",
+            ),
+            (
+                "c\\ text text ; text",
+                "abc\ndef\n@#$",
+                " text text ; text\n text text ; text\n text text ; text\n",
+                "",
+            ),
+            ("c\\r", "abc\ndef\n@#$", "r\nr\nr\n", ""),
+            ("1 c\\r", "abc\ndef\n@#$", "r\ndef\n@#$", ""),
+            ("1,2 c\\r", "abc\ndef\n@#$", "r\n@#$", ""),
+            // wrong
+            (
+                "0 c\\r",
+                "abc\ndef\n@#$",
+                "",
+                "sed: address lower bound must be bigger than 0 (line: 0, col: 3)\n",
+            ),
+            (
+                "0,2 c\\r",
+                "abc\ndef\n@#$",
+                "",
+                "sed: address lower bound must be bigger than 0 (line: 0, col: 5)\n",
+            ),
+            (
+                "c\\",
+                "abc\ndef\n@#$",
+                "",
+                "sed: missing text argument (line: 1, col: 1)\n",
+            ),
+            (
+                "c  \text",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "c\text",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "c\text\\in\\sed",
+                "abc\ndef\n@#$",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "c\\ text text \n text ",
+                "abc\ndef\n@#$",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_d() {
+        let test_data = [
+            // correct
+            ("d", "abc\ncdf\nret", "", ""),
+            ("d; d", "abc\ncdf\nret", "", ""),
+            // wrong
+            (
+                "d b",
+                "abc\ncdf\nret",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "d d",
+                "abc\ncdf\nret",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "dd",
+                "abc\ncdf\nret",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_upper_d() {
+        let test_data = [
+            // correct
+            ("1 h; D; 2 G", "abc\ncdf", "", ""),
+            // wrong
+            (
+                "D b",
+                "abc\ncdf",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "D D",
+                "abc\ncdf",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "DD",
+                "abc\ncdf",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_g() {
+        let test_data = [
+            // correct
+            ("1 h; 2 g", "abc\ncdf", "abc\nabc\n", ""),
+            // wrong
+            (
+                "0 g; 1 h",
+                "abc\ncdf",
+                "",
+                "sed: address lower bound must be bigger than 0 (line: 0, col: 3)\n",
+            ),
+            (
+                "g g",
+                "abc\ncdf",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_upper_g() {
+        let test_data = [
+            // correct
+            ("1 H; 2 G", "abc\ncdf\n", "abc\ncdf\n\nabc\n", ""),
+            // wrong
+            (
+                "0 G",
+                "abc\ncdf",
+                "",
+                "sed: address lower bound must be bigger than 0 (line: 0, col: 3)\n",
+            ),
+            (
+                "G G",
+                "abc\ncdf",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_h() {
+        let test_data = [
+            // correct
+            (
+                "1 h; 2 g; 3 h; 4 g",
+                "abc\ncdf\naaa\nbbb",
+                "abc\nabc\naaa\naaa\n",
+                "",
+            ),
+            ("1 h; 2 h; 3 g", "abc\ncdf\naaa", "abc\ncdf\ncdf\n", ""),
+            // wrong
+            (
+                "0 h; 1 h",
+                "abc\ncdf\naaa\nbbb",
+                "",
+                "sed: address lower bound must be bigger than 0 (line: 0, col: 3)\n",
+            ),
+            (
+                "h g",
+                "abc\ncdf\naaa",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "h h",
+                "abc\ncdf\naaa",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "hh",
+                "abc\ncdf\naaa\nbbb",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_upper_h() {
+        let test_data = [
+            // correct
+            (
+                "1 H; 2 g; 3 H; 4 g",
+                "abc\ncdf\naaa\nbbb",
+                "abc\n\nabc\naaa\n\nabc\naaa\n",
+                "",
+            ),
+            (
+                "1 H; 2 H; 3 g",
+                "abc\ncdf\naaa",
+                "abc\ncdf\n\nabc\ncdf\n",
+                "",
+            ),
+            // wrong
+            (
+                "0 H; 1 H",
+                "abc\ncdf\naaa",
+                "",
+                "sed: address lower bound must be bigger than 0 (line: 0, col: 3)\n",
+            ),
+            (
+                "H g",
+                "abc\ncdf\naaa",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "H H",
+                "abc\ncdf\naaa\nbbb",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "HH",
+                "abc\ncdf\naaa\nbbb",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_i() {
+        let test_data = [
+            // correct
+            (
+                "i\\text",
+                "abc\ncdf\n\n",
+                "text\nabc\ntext\ncdf\ntext\n\n",
+                "",
+            ),
+            (
+                "i\\text\\in\\sed",
+                "abc\ncdf\n\n",
+                "textinsed\nabc\ntextinsed\ncdf\ntextinsed\n\n",
+                "",
+            ),
+            (
+                "i\\text text ; text ",
+                "abc\ncdf\n\n",
+                "text text ; text \nabc\ntext text ; text \ncdf\ntext text ; text \n\n",
+                "",
+            ),
+            // wrong
+            (
+                "i\\",
+                "abc\ncdf\n\n",
+                "",
+                "sed: missing text argument (line: 1, col: 1)\n",
+            ),
+            (
+                "i  \text",
+                "abc\ncdf\n\n",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "i\text",
+                "abc\ncdf\n\n",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "i\text\\in\\sed",
+                "abc\ncdf\n\n",
+                "",
+                "sed: text must be separated with '\\' (line: 0, col: 2)\n",
+            ),
+            (
+                "i\\ text text \n text ",
+                "abc\ncdf\n\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_upper_i() {
+        let test_data = [
+            // correct
+            (
+                "I",
+                "\x01\x02\x03\x04\x05\x06\x07\x08\x09\n\x0B\x0C\x0D\x0E\x0F",
+                "\\x01\\x02\\x03\\x04\\x05\\x06\\a\\b\\t$\\v\\f\\r\\x0e\\x0f$",
+                "",
+            ),
+            // wrong
+            (
+                "I g",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "I I",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "II",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(
+                &["-n", "-e", script],
+                input,
+                output,
+                err,
+                !err.is_empty() as i32,
+            );
+        }
+    }
+
+    #[test]
+    fn test_n() {
+        let test_data = [
+            // correct
+            ("n", "abc", "abc", ""),
+            ("n; p", "abc\ncdf\n", "abc\ncdf\ncdf\n", ""),
+            ("g; n; g; n; g; n", "abc\ncdf\nret", "\n\n\n", ""),
+            // wrong
+            (
+                "n g",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "n n",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "nn",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_upper_n() {
+        let test_data = [
+            // correct
+            ("N", "abc", "", ""),
+            ("N; p", "abc\ncdf\n", "abc\ncdf\nabc\ncdf\n", ""),
+            ("g; N; g; N; N", "abc\ncdf\nret", "", ""),
+            // wrong
+            (
+                "N g",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "N N",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "NN",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_p() {
+        let test_data = [
+            // correct
+            ("p", "abc\ncdf\nret\n", "abc\nabc\ncdf\ncdf\nret\nret\n", ""),
+            ("g; p", "abc\ncdf\nret\n", "\n\n\n\n\n\n", ""),
+            ("N; p", "abc\ncdf\n", "abc\ncdf\nabc\ncdf\n", ""),
+            (
+                "1 h; 2 G; p",
+                "abc\n123\n",
+                "abc\nabc\n123\nabc\n123\nabc\n",
+                "",
+            ),
+            // wrong
+            (
+                "p g",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "p p",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "pp",
+                "",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_upper_p() {
+        let test_data = [
+            // correct
+            ("P", "abc\n123\n", "abc\nabc\n123\n123\n", ""),
+            ("1 h; 2 G; P", "abc\n123\n", "abc\nabc\n123\n123\nabc\n", ""),
+            // wrong
+            (
+                "P g",
+                "abc\n123",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "P P",
+                "abc\n123",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "PP",
+                "abc\n123",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_q() {
+        let test_data = [
+            // correct
+            ("q", "abc\n123", "abc\n", ""),
+            ("q; q", "abc\n123", "abc\n", ""),
+            // wrong
+            (
+                "q g",
+                "abc\n123",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "q q",
+                "abc\n123",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "qq",
+                "abc\n123",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_r() {
+        let test_data = [
+            // correct
+            (
+                "r ./tests/sed/assets/script_some_newlines",
+                "abc\ncdf",
+                "abc\ns/a/ab/g;\ns/b/bc/g;\ns/c/ca/g\n\n\ncdf\ns/a/ab/g;\ns/b/bc/g;\ns/c/ca/g\n\n\n",
+                "",
+            ),
+            ("r./tests/sed/assets/abc", "", "", ""),
+            ("r./tests/sed/assets/abc", "a", "a\nabc\n", ""),
+            ("r./text/tests/s\x03ed/assets/abc", "abc", "abc\n", ""),
+            ("r aer", "abc\ncdf", "abc\ncdf\n", ""),
+            ("r./text/ard/assets/abc", "abc\ncdf", "abc\ncdf\n", ""),
+            // wrong
+            ("r", "abc\ncdf", "", "sed: missing filename in r/R/w/W commands (line: 0, col: 1)\n"),
+            ("r #@/?", "abc\ncdf", "", "sed: missing filename in r/R/w/W commands (line: 0, col: 2)\n"),
+            ("r #@/?\nl", "abc\ncdf", "", "sed: missing filename in r/R/w/W commands (line: 0, col: 2)\n")
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_s() {
+        let test_data = [
+            // correct
+            ("s/b/r/", "abc\nbbb\nbcb\nrbt\n", "arc\nrbb\nrcb\nrrt\n", ""),
+            (
+                "s/b/r/g",
+                "abc\nbbb\nbcb\nrbt\n",
+                "arc\nrrr\nrcr\nrrt\n",
+                "",
+            ),
+            (
+                "s|b|r|g",
+                "abc\nbbb\nbcb\nrbt\n",
+                "arc\nrrr\nrcr\nrrt\n",
+                "",
+            ),
+            (
+                "s/[[:alpha:]]/r/",
+                "abc\nbbb\nbcb\nrbt\n@#$\n",
+                "rbc\nrbb\nrcb\nrbt\n@#$\n",
+                "",
+            ),
+            (
+                "s/\\(a\\)\\(x\\)/\\1\\2/",
+                "abc\nbbb\nbcb\nrbt\n@#$\n",
+                "abc\nbbb\nbcb\nrbt\n@#$\n",
+                "",
+            ),
+            (
+                "s/[[:alpha:]]/r/",
+                "abc\nbbb\nbcb\nrbt\n",
+                "rbc\nrbb\nrcb\nrbt\n",
+                "",
+            ),
+            (
+                "s///",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: read stdin: no previous regular expression\n",
+            ),
+            // wrong
+            (
+                "s/a/b/c/d/",
+                "abc\nbbb\nbcb\nrbt\n@#$\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 7)\n",
+            ),
+            (
+                "s//a//c//",
+                "abc\nbbb\nbcb\nrbt\n@#$\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 6)\n",
+            ),
+            (
+                "s/\\(\\(x\\)/\\1\\2/",
+                "abc\nbbb\nbcb\nrbt\n@#$",
+                "",
+                "sed: can't compile pattern '\\(\\(x\\)'\n",
+            ),
+            (
+                "s\na\nb\n",
+                "abc\nbbb\nbcb\nrbt\n@#$",
+                "",
+                "sed: unterminated `s' command (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_s_with_right_flags() {
+        let test_data = [
+            // correct
+            ("s/b/r/6", "abcbbdfbdbdfbfb\n", "abcbbdfbdbdfrfb\n", ""),
+            ("s/b/r/g", "abcbbdfbdbdfbfb\n", "arcrrdfrdrdfrfr\n", ""),
+            (
+                "s/b/r/p",
+                "abcbbdfbdbdfbfb\n",
+                "arcbbdfbdbdfbfb\narcbbdfbdbdfbfb\n",
+                "",
+            ),
+            (
+                "s/b/r/w ./tests/sed/assets/r",
+                "abcbbdfbdbdfbfb\n",
+                "arcbbdfbdbdfbfb\n",
+                "",
+            ),
+            (
+                "s/b/r/6p",
+                "abcbbdfbdbdfbfb\n",
+                "abcbbdfbdbdfrfb\nabcbbdfbdbdfrfb\n",
+                "",
+            ),
+            (
+                "s/[[:alpha:]]/r/g",
+                "abc\nbbb\nbcb\nrbt\n@#$\n",
+                "rrr\nrrr\nrrr\nrrr\n@#$\n",
+                "",
+            ),
+            (
+                "s/b/r/gp",
+                "abcbbdfbdbdfbfb\n",
+                "arcrrdfrdrdfrfr\narcrrdfrdrdfrfr\n",
+                "",
+            ),
+            (
+                "s/b/r/p6",
+                "abcbbdfbdbdfbfb\n",
+                "abcbbdfbdbdfrfb\nabcbbdfbdbdfrfb\n",
+                "",
+            ),
+            (
+                "s/b/r/pw ./tests/sed/assets/r",
+                "abcbbdfbdbdfbfb\n",
+                "arcbbdfbdbdfbfb\narcbbdfbdbdfbfb\n",
+                "",
+            ),
+            (
+                "s/b/r/6pw ./tests/sed/assets/r",
+                "abcbbdfbdbdfbfb\n",
+                "abcbbdfbdbdfrfb\nabcbbdfbdbdfrfb\n",
+                "",
+            ),
+            (
+                "s/b/r/gpw ./tests/sed/assets/r",
+                "abcbbdfbdbdfbfb\n",
+                "arcrrdfrdrdfrfr\narcrrdfrdrdfrfr\n",
+                "",
+            ),
+            (
+                "s/b/r/ p",
+                "abc\nbbb\nbcb\nrbt",
+                "arc\narc\nrbb\nrbb\nrcb\nrcb\nrrt\nrrt",
+                "",
+            ),
+            (
+                "s/b/r/ p w ./r",
+                "abc\nbbb\nbcb\nrbt",
+                "arc\narc\nrbb\nrbb\nrcb\nrcb\nrrt\nrrt",
+                "",
+            ),
+            (
+                "s/b/r/w g6",
+                "abc\nbbb\nbcb\nrbt\n",
+                "arc\nrbb\nrcb\nrrt\n",
+                "",
+            ),
+            ("s/b/r/wpg6", "abc\nbbb\nbcb\nrbt", "arc\nrbb\nrcb\nrrt", ""),
+            ("s/b/r/w6", "abc\nbbb\nbcb\nrbt", "arc\nrbb\nrcb\nrrt", ""),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_s_with_wrong_flags() {
+        let test_data = [
+            // wrong
+            (
+                "s/b/r/ w",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: missing filename in r/R/w/W commands (line: 0, col: 8)\n",
+            ),
+            (
+                "s/b/r/-6",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 7)\n",
+            ),
+            (
+                "s/b/r/-6p",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 7)\n",
+            ),
+            (
+                "s/b/r/p-6",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 8)\n",
+            ),
+            (
+                "s/b/r/g-6",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 8)\n",
+            ),
+            (
+                "s/b/r/6g",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: n and g flags can't be used together (line: 0, col: 8)\n",
+            ),
+            (
+                "s/b/r/6pg",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: n and g flags can't be used together (line: 0, col: 9)\n",
+            ),
+            (
+                "s/b/r/w./REA;DME.md",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 15)\n",
+            ),
+            (
+                "s/b/r/w ./REA;DME.md",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 16)\n",
+            ),
+            (
+                "s/b/r/w ./REA;DME.md p",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 16)\n",
+            ),
+            (
+                "s/b/r/6gpw ./tests/sed/assets/r",
+                "abc\nbbb\nbcb\nrbt",
+                "",
+                "sed: n and g flags can't be used together (line: 0, col: 31)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_t() {
+        let test_data = [
+            // correct
+            ("t", "aa\naaa\n\n", "aa\naaa\n\n", ""),
+            ("t label; :label", "aa\naaa\n\n", "aa\naaa\n\n", ""),
+            ("t label1; :label1", "", "", ""),
+            ("t lab2el1abc; :lab2el1abc", "", "", ""),
+            ("t loop_; :loop_", "", "", ""),
+            ("t _start; :_start", "", "", ""),
+            ("t my_label; :my_label", "", "", ""),
+            ("t #%$?@&*; :#%$?@&*", "aa\naaa\n\n", "aa\naaa\n\n", ""),
+            ("t 1label; :1label", "aa\naaa\n\n", "aa\naaa\n\n", ""),
+            ("t 1234; :1234", "aa\naaa\n\n", "aa\naaa\n\n", ""),
+            ("t #%$?@&*;", "", "", ""),
+            // wrong
+            ("t; :label", "aa\naaa\n\n", "aa\naaa\n\n", ""),
+            (
+                "t label#; :label#",
+                "aa\naaa\n\n",
+                "",
+                "sed: can't find label for jump to `label'\n",
+            ),
+            (
+                "t label;",
+                "",
+                "",
+                "sed: can't find label for jump to `label'\n",
+            ),
+            (
+                "t :label",
+                "",
+                "",
+                "sed: can't find label for jump to `:label'\n",
+            ),
+            (
+                "t label#",
+                "",
+                "",
+                "sed: can't find label for jump to `label'\n",
+            ),
+            (
+                "t 1label",
+                "",
+                "",
+                "sed: can't find label for jump to `1label'\n",
+            ),
+            (
+                "t 1234",
+                "",
+                "",
+                "sed: can't find label for jump to `1234'\n",
+            ),
+            ("t g", "", "", "sed: can't find label for jump to `g'\n"),
+            (
+                "t; label",
+                "aa\naaa\n\n",
+                "",
+                "sed: unknown character 'l' (line: 0, col: 4)\n",
+            ),
+            (
+                "t label :label",
+                "aa\naaa\n\n",
+                "",
+                "sed: label can't contain ' ' (line: 0, col: 14)\n",
+            ),
+            (
+                "t ab\ncd; :ab\ncd",
+                "aa\naaa\n\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 1)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_w() {
+        let test_data = [
+            // correct
+            ("w ./tests/sed/assets/newfile", "abc\ncdf\n", "abc\ncdf\n", ""),
+            ("w atyfv", "abc\ncdf\n", "abc\ncdf\n", ""),
+            ("w./tests/sed/assets/r", "", "", ""),
+            ("w./tests/sed/assets/newfile", "a\n", "a\n", ""),
+            ("w ; h", "abc\ncdf\n", "abc\ncdf\n", ""),
+            // wrong
+            (
+                "w./tests/s\x04ed/assets/abc",
+                "a\n",
+                "",
+                "sed: read stdin: can't find './tests/s\u{4}ed/assets/abc': no such file or directory (os error 2)\n",
+            ),
+            (
+                "w./tests/ard/assets/abc",
+                "a\n",
+                "",
+                "sed: read stdin: can't find './tests/ard/assets/abc': no such file or directory (os error 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_x() {
+        let test_data = [
+            // correct
+            (
+                "h; s/.* /abc/; p; x",
+                "def \nref \nmut \n \n",
+                "abc\ndef \nabc\nref \nabc\nmut \nabc\n \n",
+                "",
+            ),
+            ("1 h; 2 x; 3 x", "abc\ncdf\nret", "abc\nabc\ncdf\n", ""),
+            // wrong
+            (
+                "x h",
+                "abc\ncdf\nret",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "x x",
+                "abc\ncdf\nret",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "xx",
+                "abc\ncdf\nret",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_y() {
+        let test_data = [
+            // correct
+            (
+                "y/abc/cdf/",
+                "abc\naaa\nbbb\ncrt\n",
+                "cdf\nccc\nddd\nfrt\n",
+                "",
+            ),
+            (
+                "y/abc/aaa/",
+                "abc\naaa\nbbb\ncrt\n",
+                "aaa\naaa\naaa\nart\n",
+                "",
+            ),
+            ("y///", "abc\naaa\n\n", "abc\naaa\n\n", ""),
+            // wrong
+            (
+                "y/abc/aaaa/",
+                "abc\naaa\n\n",
+                "",
+                "sed: number of characters in the two arrays does not match (line: 0, col: 12)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_line_numeration() {
+        let test_data = [
+            // correct
+            (
+                "=",
+                "abc\ncdf\nefg\nret\n",
+                "1\nabc\n2\ncdf\n3\nefg\n4\nret\n",
+                "",
+            ),
+            ("=", "\n\n\n", "1\n\n2\n\n3\n\n", ""),
+            // wrong
+            (
+                "= g",
+                "abc\ncdf\nefg\nret\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "= =",
+                "abc\ncdf\nefg\nret\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 3)\n",
+            ),
+            (
+                "==",
+                "abc\ncdf\nefg\nret\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 0, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_comment() {
+        let test_data = [
+            // correct
+            ("#n", "abc\ncdf\naaa", "", ""),
+            // wrong
+            (
+                "a\\#text\ntext",
+                "abc\ncdf\naaa\n",
+                "",
+                "sed: missing text argument (line: 1, col: 1)\n",
+            ),
+            (
+                "{ #\\ }\n{ #\n }\n#h",
+                "abc\ncdf\n",
+                "",
+                "sed: '{' not have pair for closing block (line: 0, col: 1)\n",
+            ),
+            (
+                r#"{ # }\n{ # }\n{ \n# }"#,
+                "abc\ncdf\naaa",
+                "",
+                "sed: '{' not have pair for closing block (line: 0, col: 1)\n",
+            ),
+            (
+                "a\\text#abc\ntext",
+                "abc\ncdf\n",
+                "",
+                "sed: commands must be delimited with ';' (line: 1, col: 2)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_combinations_1() {
+        let test_data = [
+            // correct
+            (":x ; \\/=$/ { N ; s/=$=//g ; bx }", "abc=$=\ncdf=$=\nret=$=\nget=$=\n", "abc\ncdf\nret\nget\n", ""),
+            ("1,3 { p ; p } ; 1,2 { p ; p } ; {p ; p}", "abc\ncdf\nret\nget\n",
+            "abc\nabc\nabc\nabc\nabc\nabc\nabc\ncdf\ncdf\ncdf\ncdf\ncdf\ncdf\ncdf\nret\nret\nret\nret\nret\nget\nget\nget\n", ""),
+            ("\\/1/b else ; s/a/z/ ; :else ; y/123/456/", "", "", ""),
+            ("\\/1/s/a/z/ ; y/123/456/", "1aaa\n123aa\n", "4zaa\n456za\n", ""),
+            ("\\/start/,\\/end/p", "a\nb\nc\nstart\nt\n\nu\nend\nert\nqwerty\n", "a\nb\nc\nstart\nstart\nt\nt\n\n\nu\nu\nend\nend\nert\nqwerty\n", ""),
+            ("\\/start/,$p", "a\nb\nc\nstart\nt\n\nu\nend\nert\nqwerty\n", "a\nb\nc\nstart\nstart\nt\nt\n\n\nu\nu\nend\nend\nert\nert\nqwerty\nqwerty\n", ""),
+            ("1,\\/end/p", "a\nb\nc\nstart\nt\n\nu\nend\nert\nqwerty\n", "a\na\nb\nb\nc\nc\nstart\nstart\nt\nt\n\n\nu\nu\nend\nend\nert\nqwerty\n", ""),
+            ("2,4 !p", "a\nb\nc\nstart\nt\n\nu\nend\nert\nqwerty\n", "a\na\nb\nc\nstart\nt\nt\n\n\nu\nu\nend\nend\nert\nert\nqwerty\nqwerty\n", ""),
+            ("2,4 !{p}", "a\nb\nc\nstart\nt\n\nu\nend\nert\nqwerty\n", "a\na\nb\nc\nstart\nt\nt\n\n\nu\nu\nend\nend\nert\nert\nqwerty\nqwerty\n", ""),
+            //wrong
+            ("\\/pattern/- p", "a\nb\nc\nstart\nt\n\nu\nend\nert\nqwerty", "", "sed: unknown character '-' (line: 0, col: 11)\n")
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_combinations_2() {
+        let test_data = [
+            // correct
+            (r#"s/^[^[:space:]]*[[:space:]]*//"#, "apple pie is sweet\n123abc test123\nhello world\n",
+            "pie is sweet\ntest123\nworld\n", ""),
+            (r#"s/^[[:alnum:]]*[[:space:]]*//"#, "apple pie is sweet\n123abc test123\nhello world\n",
+            "pie is sweet\ntest123\nworld\n", ""),
+            (r#"s/\([[:alnum:]]*\)/\1/1"#, "apple pie is sweet\n123abc test123\nhello world\n",
+            "apple pie is sweet\n123abc test123\nhello world\n", ""),
+            ("\\:start:,\\,stop, p", "a\nb\nc\nstart\nt\n\nu\nend\nert\nqwerty\n",
+            "a\nb\nc\nstart\nstart\nt\nt\n\n\nu\nu\nend\nend\nert\nert\nqwerty\nqwerty\n", ""),
+            ("\\`'$PATTERN'`p", "'$PATTERN'\nabc\n\n'$PATTERN'\nret'$PATTERN'abc\n",
+            "'$PATTERN'\n'$PATTERN'\nabc\n\n'$PATTERN'\n'$PATTERN'\nret'$PATTERN'abc\nret'$PATTERN'abc\n", ""),
+            ("s/param=.*/param=new_value\n/", "param=abc\nparam=\nparam abc\n",
+            "", "sed: unterminated `s' command (line: 0, col: 3)\n"),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_combinations_3() {
+        let test_data = [
+            // correct
+            (
+                "y:ABCDEFGHIJKLMNOPQRSTUVWXYZ:abcdefghijklmnopqrstuvwxyz:",
+                "ABC\n\n1234\nabcdefg",
+                "abc\n\n1234\nabcdefg",
+                "",
+            ),
+            (
+                "\\/^$/d;G",
+                "Line 1\n\nLine 2\nLine 3\n\n\nLine 4\n",
+                "Line 1\n\nLine 2\n\nLine 3\n\nLine 4\n\n",
+                "",
+            ),
+            (
+                r#"\/^$/{p;h;};\/./{x;\/./p;}"#,
+                "line1\n\nline2\nline3",
+                "\n\n\n\nline2\nline2\n",
+                "",
+            ),
+            (
+                "\\/./{H;$d;};x;\\/[AAA|BBB|CCC]/b;d",
+                "line1\nAAA\nline2\nBBB\nline3\n",
+                "line1\nAAA\nAAA\nline2\nline2\nBBB\n",
+                "",
+            ),
+            (
+                "\\/Iowa/,\\/Montana/p",
+                "Hello\nIowa is here\nMontana is next\nEnd\n",
+                "Hello\nIowa is here\nIowa is here\nMontana is next\nMontana is next\nEnd\n",
+                "",
+            ),
+            (
+                r#"\/\/\//N;\/\/\//d"#,
+                "line1\nline2\n//\nline3",
+                "line1\nline2\n",
+                "",
+            ),
+            (
+                "$=",
+                "line1\nline2\nline3\n",
+                "line1\nline2\n3\nline3\n",
+                "",
+            ),
+            (
+                "s/.\n$/\n/",
+                "line1\nline2\n",
+                "",
+                "sed: unterminated `s' command (line: 0, col: 3)\n",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_combinations_4() {
+        let test_data = [
+            // correct
+            ("1{$q;};${h;d;}; x", "line1\nline2\nline3", "\nline1\n", ""),
+            ("$h; $d; x", "line1\nline2\nline3", "\nline1\n", ""),
+            (
+                r#"s/\(.*\)foo\(.*foo\)/\1bar\2/"#,
+                "thisfooisfoo",
+                "thisbarisfoo",
+                "",
+            ),
+            (
+                "s/scarlet/red/g;s/ruby/red/g;s/puce/red/g",
+                "The scarlet sky turned ruby as the puce evening settled.",
+                "The red sky turned red as the red evening settled.",
+                "",
+            ),
+            (
+                r#":a;s/\(^|[^0-9.]\)\([0-9]+\)\([0-9]{3}\)/\1\2,\3/g;ta"#,
+                "1234567890\nhello123456789\n1000",
+                "1234567890\nhello123456789\n1000",
+                "",
+            ),
+            (
+                "n;n;n;n;G;",
+                "line1\nline2\nline3\nline4\n",
+                "line1\nline2\nline3\nline4\n",
+                "",
+            ),
+            (
+                "s/^[ \t]* //;s/[ \t]*$//",
+                "    hello world    ",
+                "hello world",
+                "",
+            ),
+            (
+                "s/^M.$/\n/",
+                "hello\nM\nabc\n",
+                "",
+                "sed: unterminated `s' command (line: 0, col: 3)\n",
+            ),
+            (
+                "s/\x0D.$/\n/",
+                "hello\x0D\n",
+                "",
+                "sed: unterminated `s' command (line: 0, col: 3)\n",
+            ),
+            (
+                r#"s/\(^[*][[:space:]]\)/   \1/"#,
+                "* Item 1\n* Another item\nNormal text",
+                "   * Item 1\n   * Another item\nNormal text",
+                "",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_combinations_5() {
+        let test_data = [
+            // correct
+            ("\\/./,\\/^$/p", "\n\nline1\nline2\n\nline3\n", "\n\nline1\nline1\nline2\nline2\n\n\nline3\nline3\n", ""),
+            ("\\/string [[:digit:]]* /p", "string 123 \nstring abc \nstring 456 \n", 
+            "string 123 \nstring 123 \nstring abc \nstring 456 \nstring 456 \n", ""),
+            ("\\/,.*/ p", "hello, world\nhello world\n\n", "hello, world\nhello, world\nhello world\n\n", ""),
+            ("\\:ac: p", ":ac:\n:bc:\n:ac:\n", ":ac:\n:ac:\n:bc:\n:ac:\n:ac:\n", ""),
+            ("1,\\,stop, p", "first line\nsecond stop\nthird line\n", "first line\nfirst line\nsecond stop\nsecond stop\nthird line\n", ""),
+            ("s/WORD/Hello World/p ; p", "WORD is here\nthis is not word\n",
+            "Hello World is here\nHello World is here\nHello World is here\nthis is not word\nthis is not word\n", ""),
+            ("s/SUBST/program\\/lib\\/module\\/lib.so/", "this is a test SUBST\nwe use SUBST here as well",
+            "this is a test program/lib/module/lib.so\nwe use program/lib/module/lib.so here as well", ""),
+            ("s/.*/[&]/", "This is a test\nAnother test line\n", "[This is a test]\n[Another test line]\n", ""),
+            // wrong
+            (
+                r#"s/#.*//;s/[[:blank:]]*$//;\/^$/ d;p"#, 
+                "# This is a comment\nLine with trailing spaces     \nAnother line\n", 
+                "Line with trailing spaces\nLine with trailing spaces\nAnother line\nAnother line\n", 
+                ""
+            )
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_combinations_6() {
+        let test_data = [
+            // correct
+            (
+                "\\/./{H;d;};x;s/\n/={NL}=/g",
+                "line1\nline2",
+                "",
+                "sed: unterminated `s' command (line: 0, col: 16)\n",
+            ),
+            (
+                r#"N; s/^/     /; s/\(\n.*\)/\1     /"#,
+                "line1\nline2",
+                "     line1\nline2     ",
+                "",
+            ),
+            (
+                r#"s/h\.0\.\(.*\)/ \U\1/"#,
+                "h.0.someText\nh.0=data\nh.0.anotherExample",
+                "h.0. UsomeText\nh.0=data\nh.0. UanotherExample",
+                "",
+            ),
+            (
+                r#"s/ *(.*)//; s/>.*//; s/.*[:<] *//"#,
+                "Subject: Hello <hello@example.com>\nFrom: someone <someone@example.com>\n",
+                "hello@example.com\nsomeone@example.com\n",
+                "",
+            ),
+            (
+                "\\/./N; s/\n//",
+                "line1\nline2\n",
+                "",
+                "sed: unterminated `s' command (line: 0, col: 10)\n",
+            ),
+            (
+                "s/$/`echo -e \\\r`/",
+                "Hello World",
+                "Hello World`echo -e \r`",
+                "",
+            ),
+            (
+                "s/\n/\t/; N",
+                "Line 1\nLine 2\nLine 3\nLine 4",
+                "",
+                "sed: unterminated `s' command (line: 0, col: 3)\n",
+            ),
+            (
+                r#"s/\(^[*][[:space:]]\)/   \1/;\/List of products:/a\ ---------------"#,
+                "List of products:\n---------------* product\n* product1",
+                "List of products:\n ---------------\n---------------   * product\n   * product1",
+                "",
+            ),
+        ];
+
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+
+    #[test]
+    fn test_combinations_7() {
+        let test_data = [
+            // correct         
+            (r#"\/^Reply-To:/q; \/^From:/h; \/./d;g;q"#, "From: someone\nReply-To: someoneelse\n", "Reply-To: someoneelse\n", ""),
+            ("\\/./{H;$d}; x; 1 s/^/START-->/; $ s/$/<--END/", "Line 1\nLine 2\n\nLine 3",
+            "START-->\nLine 1\nLine 1\nLine 2\nLine 2\n", ""),
+            (r#"1 s/^/ /; $ s/$/ /"#, "line1\nline2", " line1\nline2 ", ""), 
+            (":a; $ q; n; 11,$ D; ba", "line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10\nline11\nline12\n",
+            "line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10\nline12\n", ""),
+            (r#"$ s/[[:alnum:]]*//2"#, "apple pie is sweet\n123abc test123 hello world\none two three four\n",
+            "apple pie is sweet\n123abc test123 hello world\none  three four\n", ""),
+            (r#"s/[[:alnum:]]*//2"#, "apple pie is sweet\n123abc test123 hello world\none two three four\n",
+            "apple  is sweet\n123abc  hello world\none  three four\n", ""),
+            (r#":a;s/^.\{1,13\}$/ &/;ta"#, "12345678\n1234567890123", "      12345678\n 1234567890123", ""),
+            (
+                "\\/begin/,\\/end/ {\ns/#.* //;\n\ns/[[:blank:]]*$//;\n\\/^$/ d;\np;\n}",
+                "Some text\nbegin\n# A comment   \nLine with trailing spaces     \nAnother line\n\n     \nend\nSome more text\n",
+                "Some text\nbegin\nbegin\nLine with trailing spaces\nLine with trailing spaces\nAnother line\nAnother line\nend\nend\nSome more text\n", 
+                ""
+            ),
+        ];
+        for (script, input, output, err) in test_data {
+            sed_test(&["-e", script], input, output, err, !err.is_empty() as i32);
+        }
+    }
+}
diff --git a/text/tests/text-tests.rs b/text/tests/text-tests.rs
index 9b686c63e..a8d100ebe 100644
--- a/text/tests/text-tests.rs
+++ b/text/tests/text-tests.rs
@@ -18,6 +18,7 @@ mod join;
 mod nl;
 mod paste;
 mod pr;
+mod sed;
 mod sort;
 mod tail;
 mod tr;