diff --git a/src/lib.rs b/src/lib.rs
index f1568a9..ff09a85 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -352,6 +352,7 @@ pub struct Cmd<'a> {
     args: Vec<&'a str>,
     opts: HashMap<&'a str, Vec<&'a str>>,
     cfgs: Vec<OptCfg>,
+    is_after_end_opt: bool,
 
     _leaked_strs: Vec<&'a str>,
     _num_of_args: usize,
@@ -457,6 +458,7 @@ impl<'b, 'a> Cmd<'a> {
             args: Vec::new(),
             opts: HashMap::new(),
             cfgs: Vec::new(),
+            is_after_end_opt: false,
             _leaked_strs,
             _num_of_args,
         })
@@ -496,12 +498,13 @@ impl<'b, 'a> Cmd<'a> {
             args: Vec::new(),
             opts: HashMap::new(),
             cfgs: Vec::new(),
+            is_after_end_opt: false,
             _leaked_strs,
             _num_of_args,
         }
     }
 
-    fn sub_cmd(&'a self, from_index: usize) -> Cmd<'b> {
+    fn sub_cmd(&'a self, from_index: usize, is_after_end_opt: bool) -> Cmd<'b> {
         let arg_iter = self._leaked_strs[from_index..(self._num_of_args)].into_iter();
         let (size, _) = arg_iter.size_hint();
         let mut _leaked_strs = Vec::with_capacity(size);
@@ -518,6 +521,7 @@ impl<'b, 'a> Cmd<'a> {
             args: Vec::new(),
             opts: HashMap::new(),
             cfgs: Vec::new(),
+            is_after_end_opt: is_after_end_opt,
             _leaked_strs,
             _num_of_args,
         }
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index fe1aaf9..328cb3a 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -17,13 +17,14 @@ fn parse_args<'a, F1, F2, F3>(
     mut collect_opts: F2,
     take_opt_args: F3,
     until_1st_arg: bool,
-) -> Result<Option<usize>, InvalidOption>
+    is_after_end_opt: bool,
+) -> Result<Option<(usize, bool)>, InvalidOption>
 where
     F1: FnMut(&'a str),
     F2: FnMut(&'a str, Option<&'a str>) -> Result<(), InvalidOption>,
     F3: Fn(&str) -> bool,
 {
-    let mut is_non_opt = false;
+    let mut is_non_opt = is_after_end_opt;
     let mut prev_opt_taking_args = "";
     let mut first_err: Option<InvalidOption> = None;
 
@@ -33,7 +34,7 @@ where
                 if let Some(err) = first_err {
                     return Err(err);
                 }
-                return Ok(Some(i_arg));
+                return Ok(Some((i_arg, is_non_opt)));
             }
             collect_args(arg);
         } else if !prev_opt_taking_args.is_empty() {
@@ -114,7 +115,7 @@ where
                     if let Some(err) = first_err {
                         return Err(err);
                     }
-                    return Ok(Some(i_arg));
+                    return Ok(Some((i_arg, is_non_opt)));
                 }
                 collect_args(arg);
                 continue 'L0;
@@ -183,7 +184,7 @@ where
                 if let Some(err) = first_err {
                     return Err(err);
                 }
-                return Ok(Some(i_arg));
+                return Ok(Some((i_arg, is_non_opt)));
             }
             collect_args(arg);
         }
diff --git a/src/parse/parse.rs b/src/parse/parse.rs
index abe6fcb..999b917 100644
--- a/src/parse/parse.rs
+++ b/src/parse/parse.rs
@@ -59,6 +59,7 @@ impl<'b, 'a> Cmd<'a> {
                 collect_opts,
                 take_opt_args,
                 false,
+                self.is_after_end_opt,
             ) {
                 Ok(_) => {}
                 Err(err) => return Err(err),
@@ -112,14 +113,15 @@ impl<'b, 'a> Cmd<'a> {
         let take_opt_args = |_arg: &str| false;
 
         if self._num_of_args > 0 {
-            if let Some(idx) = parse_args(
+            if let Some((idx, is_after_end_opt)) = parse_args(
                 &self._leaked_strs[1..(self._num_of_args)],
                 collect_args,
                 collect_opts,
                 take_opt_args,
                 true,
+                self.is_after_end_opt,
             )? {
-                return Ok(Some(self.sub_cmd(idx + 1))); // +1, because parse_args parses from 1.
+                return Ok(Some(self.sub_cmd(idx + 1, is_after_end_opt))); // +1, because parse_args parses from 1.
             }
         }
 
@@ -823,4 +825,190 @@ mod tests_of_parse_until_sub_cmd {
             assert_eq!(sub_cmd.has_opt("baz"), true);
         }
     }
+
+    #[test]
+    fn should_parse_single_hyphen() {
+        let mut cmd = Cmd::with_strings([
+            "/path/to/app".to_string(),
+            "-a".to_string(),
+            "-".to_string(),
+            "b".to_string(),
+            "-".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd() {
+            Ok(None) => assert!(false),
+            Ok(Some(mut sub_cmd)) => {
+                assert_eq!(cmd.name(), "app");
+                assert_eq!(cmd.args(), &[] as &[&str]);
+                assert_eq!(cmd.has_opt("a"), true);
+
+                match sub_cmd.parse() {
+                    Ok(_) => {
+                        assert_eq!(sub_cmd.name(), "-");
+                        assert_eq!(sub_cmd.args(), &["b", "-"]);
+                        assert_eq!(sub_cmd.has_opt("a"), false);
+                    }
+                    Err(_) => assert!(false),
+                }
+            }
+            Err(_) => assert!(false),
+        }
+    }
+
+    #[test]
+    fn should_parse_single_hyphen_but_error() {
+        let mut cmd = Cmd::with_strings([
+            "/path/to/app".to_string(),
+            "-a".to_string(),
+            "-@".to_string(),
+            "-".to_string(),
+            "b".to_string(),
+            "-".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd() {
+            Ok(_) => assert!(false),
+            Err(InvalidOption::OptionContainsInvalidChar { option }) => {
+                assert_eq!(option, "@");
+            }
+            Err(_) => assert!(false),
+        }
+
+        assert_eq!(cmd.name(), "app");
+        assert_eq!(cmd.args(), &[] as &[&str]);
+        assert_eq!(cmd.has_opt("a"), true);
+    }
+
+    #[test]
+    fn should_parse_with_end_opt_mark() {
+        let mut cmd = Cmd::with_strings([
+            "/path/to/app".to_string(),
+            "sub".to_string(),
+            "--".to_string(),
+            "-a".to_string(),
+            "-s@".to_string(),
+            "--".to_string(),
+            "xxx".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd() {
+            Ok(None) => assert!(false),
+            Ok(Some(mut sub_cmd)) => {
+                assert_eq!(cmd.name(), "app");
+                assert_eq!(cmd.args(), &[] as &[&str]);
+                assert_eq!(cmd.has_opt("a"), false);
+                assert_eq!(cmd.opt_arg("a"), None);
+                assert_eq!(cmd.opt_args("a"), None);
+                assert_eq!(cmd.has_opt("alphabet"), false);
+                assert_eq!(cmd.opt_arg("alphabet"), None);
+                assert_eq!(cmd.opt_args("alphabet"), None);
+                assert_eq!(cmd.has_opt("s"), false);
+                assert_eq!(cmd.opt_arg("s"), None);
+                assert_eq!(cmd.opt_args("s"), None);
+                assert_eq!(cmd.has_opt("silent"), false);
+                assert_eq!(cmd.opt_arg("silent"), None);
+                assert_eq!(cmd.opt_args("silent"), None);
+
+                match sub_cmd.parse() {
+                    Err(_) => assert!(false),
+                    Ok(_) => {
+                        assert_eq!(sub_cmd.name(), "sub");
+                        assert_eq!(sub_cmd.args(), &["-a", "-s@", "--", "xxx"]);
+                        assert_eq!(sub_cmd.has_opt("a"), false);
+                        assert_eq!(sub_cmd.opt_arg("a"), None);
+                        assert_eq!(sub_cmd.opt_args("a"), None);
+                        assert_eq!(sub_cmd.has_opt("alphabet"), false);
+                        assert_eq!(sub_cmd.opt_arg("alphabet"), None);
+                        assert_eq!(sub_cmd.opt_args("alphabet"), None);
+                        assert_eq!(sub_cmd.has_opt("s"), false);
+                        assert_eq!(sub_cmd.opt_arg("s"), None);
+                        assert_eq!(sub_cmd.opt_args("s"), None);
+                        assert_eq!(sub_cmd.has_opt("silent"), false);
+                        assert_eq!(sub_cmd.opt_arg("silent"), None);
+                        assert_eq!(sub_cmd.opt_args("silent"), None);
+                    }
+                }
+            }
+            Err(_) => assert!(false),
+        }
+    }
+
+    #[test]
+    fn should_parse_after_end_opt_mark() {
+        let mut cmd = Cmd::with_strings([
+            "/path/to/app".to_string(),
+            "-s".to_string(),
+            "--".to_string(),
+            "-a".to_string(),
+            "-s@".to_string(),
+            "--".to_string(),
+            "xxx".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd() {
+            Ok(None) => assert!(false),
+            Ok(Some(mut sub_cmd)) => {
+                assert_eq!(cmd.name(), "app");
+                assert_eq!(cmd.args(), &[] as &[&str]);
+                assert_eq!(cmd.has_opt("a"), false);
+                assert_eq!(cmd.opt_arg("a"), None);
+                assert_eq!(cmd.opt_args("a"), None);
+                assert_eq!(cmd.has_opt("alphabet"), false);
+                assert_eq!(cmd.opt_arg("alphabet"), None);
+                assert_eq!(cmd.opt_args("alphabet"), None);
+                assert_eq!(cmd.has_opt("s"), true);
+                assert_eq!(cmd.opt_arg("s"), None);
+                assert_eq!(cmd.opt_args("s"), Some(&[] as &[&str]));
+                assert_eq!(cmd.has_opt("silent"), false);
+                assert_eq!(cmd.opt_arg("silent"), None);
+                assert_eq!(cmd.opt_args("silent"), None);
+
+                match sub_cmd.parse() {
+                    Err(_) => assert!(false),
+                    Ok(_) => {
+                        assert_eq!(sub_cmd.name(), "-a");
+                        assert_eq!(sub_cmd.args(), &["-s@", "--", "xxx"]);
+                        assert_eq!(sub_cmd.has_opt("a"), false);
+                        assert_eq!(sub_cmd.opt_arg("a"), None);
+                        assert_eq!(sub_cmd.opt_args("a"), None);
+                        assert_eq!(sub_cmd.has_opt("alphabet"), false);
+                        assert_eq!(sub_cmd.opt_arg("alphabet"), None);
+                        assert_eq!(sub_cmd.opt_args("alphabet"), None);
+                        assert_eq!(sub_cmd.has_opt("s"), false);
+                        assert_eq!(sub_cmd.opt_arg("s"), None);
+                        assert_eq!(sub_cmd.opt_args("s"), None);
+                        assert_eq!(sub_cmd.has_opt("silent"), false);
+                        assert_eq!(sub_cmd.opt_arg("silent"), None);
+                        assert_eq!(sub_cmd.opt_args("silent"), None);
+                    }
+                }
+            }
+            Err(_) => assert!(false),
+        }
+    }
+
+    #[test]
+    fn should_parse_after_end_opt_mark_but_error() {
+        let mut cmd = Cmd::with_strings([
+            "/path/to/app".to_string(),
+            "-@".to_string(),
+            "--".to_string(),
+            "-a".to_string(),
+            "-s@".to_string(),
+            "--".to_string(),
+            "xxx".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd() {
+            Ok(_) => assert!(false),
+            Err(InvalidOption::OptionContainsInvalidChar { option }) => {
+                assert_eq!(option, "@");
+            }
+            Err(_) => assert!(false),
+        }
+
+        assert_eq!(cmd.name(), "app");
+        assert_eq!(cmd.args(), &[] as &[&str]);
+    }
 }
diff --git a/src/parse/parse_for.rs b/src/parse/parse_for.rs
index e89a00d..16e96f9 100644
--- a/src/parse/parse_for.rs
+++ b/src/parse/parse_for.rs
@@ -1909,4 +1909,92 @@ mod tests_of_parse_util_sub_cmd_for {
 
         assert_eq!(my_options.foo, false);
     }
+
+    #[test]
+    fn should_parse_with_end_opt_mark() {
+        let mut my_options = MyOptions::with_defaults();
+        let mut sub_options = SubOptions::with_defaults();
+
+        let mut cmd = Cmd::with_strings([
+            "app".to_string(),
+            "--foo".to_string(),
+            "sub".to_string(),
+            "--".to_string(),
+            "bar".to_string(),
+            "-@".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd_for(&mut my_options) {
+            Ok(Some(mut sub_cmd)) => {
+                assert_eq!(cmd.name(), "app");
+                assert_eq!(cmd.args(), &[] as &[&str]);
+                assert_eq!(cmd.has_opt("foo"), true);
+                assert_eq!(cmd.opt_arg("foo"), None);
+                assert_eq!(cmd.opt_args("foo"), Some(&[] as &[&str]));
+                assert_eq!(cmd.has_opt("bar"), false);
+                assert_eq!(cmd.opt_arg("bar"), None);
+                assert_eq!(cmd.opt_args("bar"), None);
+
+                match sub_cmd.parse_for(&mut sub_options) {
+                    Ok(_) => {
+                        assert_eq!(sub_cmd.name(), "sub");
+                        assert_eq!(sub_cmd.args(), &["bar", "-@"] as &[&str]);
+                        assert_eq!(sub_cmd.has_opt("foo"), false);
+                        assert_eq!(sub_cmd.opt_arg("foo"), None);
+                        assert_eq!(sub_cmd.opt_args("foo"), None);
+                        assert_eq!(sub_cmd.has_opt("bar"), false);
+                        assert_eq!(sub_cmd.opt_arg("bar"), None);
+                        assert_eq!(sub_cmd.opt_args("bar"), None);
+                    }
+                    Err(_) => assert!(false),
+                }
+            }
+            Ok(None) => assert!(false),
+            Err(_) => assert!(false),
+        }
+    }
+
+    #[test]
+    fn should_parse_after_end_opt_mark() {
+        let mut my_options = MyOptions::with_defaults();
+        let mut sub_options = SubOptions::with_defaults();
+
+        let mut cmd = Cmd::with_strings([
+            "app".to_string(),
+            "--".to_string(),
+            "--foo".to_string(),
+            "sub".to_string(),
+            "bar".to_string(),
+            "-@".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd_for(&mut my_options) {
+            Ok(Some(mut sub_cmd)) => {
+                assert_eq!(cmd.name(), "app");
+                assert_eq!(cmd.args(), &[] as &[&str]);
+                assert_eq!(cmd.has_opt("foo"), false);
+                assert_eq!(cmd.opt_arg("foo"), None);
+                assert_eq!(cmd.opt_args("foo"), None);
+                assert_eq!(cmd.has_opt("bar"), false);
+                assert_eq!(cmd.opt_arg("bar"), None);
+                assert_eq!(cmd.opt_args("bar"), None);
+
+                match sub_cmd.parse_for(&mut sub_options) {
+                    Ok(_) => {
+                        assert_eq!(sub_cmd.name(), "--foo");
+                        assert_eq!(sub_cmd.args(), &["sub", "bar", "-@"] as &[&str]);
+                        assert_eq!(sub_cmd.has_opt("foo"), false);
+                        assert_eq!(sub_cmd.opt_arg("foo"), None);
+                        assert_eq!(sub_cmd.opt_args("foo"), None);
+                        assert_eq!(sub_cmd.has_opt("bar"), false);
+                        assert_eq!(sub_cmd.opt_arg("bar"), None);
+                        assert_eq!(sub_cmd.opt_args("bar"), None);
+                    }
+                    Err(_) => assert!(false),
+                }
+            }
+            Ok(None) => assert!(false),
+            Err(_) => assert!(false),
+        }
+    }
 }
diff --git a/src/parse/parse_with.rs b/src/parse/parse_with.rs
index 4f365e2..25af7c6 100644
--- a/src/parse/parse_with.rs
+++ b/src/parse/parse_with.rs
@@ -71,7 +71,7 @@ impl<'b, 'a> Cmd<'a> {
     /// }
     /// ```
     pub fn parse_with(&mut self, opt_cfgs: Vec<OptCfg>) -> Result<(), InvalidOption> {
-        let result = self.parse_args_with(&opt_cfgs, false);
+        let result = self.parse_args_with(&opt_cfgs, false, self.is_after_end_opt);
         self.cfgs = opt_cfgs;
         result?;
         Ok(())
@@ -134,10 +134,10 @@ impl<'b, 'a> Cmd<'a> {
         &mut self,
         opt_cfgs: Vec<OptCfg>,
     ) -> Result<Option<Cmd<'b>>, InvalidOption> {
-        match self.parse_args_with(&opt_cfgs, true) {
-            Ok(Some(idx)) => {
+        match self.parse_args_with(&opt_cfgs, true, self.is_after_end_opt) {
+            Ok(Some((idx, is_after_end_opt))) => {
                 self.cfgs = opt_cfgs;
-                return Ok(Some(self.sub_cmd(idx)));
+                return Ok(Some(self.sub_cmd(idx, is_after_end_opt)));
             }
             Ok(None) => {
                 self.cfgs = opt_cfgs;
@@ -154,12 +154,13 @@ impl<'b, 'a> Cmd<'a> {
         &mut self,
         opt_cfgs: &Vec<OptCfg>,
         until_1st_arg: bool,
-    ) -> Result<Option<usize>, InvalidOption> {
+        is_after_end_opt: bool,
+    ) -> Result<Option<(usize, bool)>, InvalidOption> {
         let mut cfg_map = HashMap::<&str, usize>::new();
         let mut opt_map = HashMap::<&str, ()>::new();
 
         const ANY_OPT: &str = "*";
-        let mut has_any_opt = false;
+        let mut has_any_opt = is_after_end_opt;
 
         for (i, cfg) in opt_cfgs.iter().enumerate() {
             let names: Vec<&String> = cfg.names.iter().filter(|nm| !nm.is_empty()).collect();
@@ -328,6 +329,7 @@ impl<'b, 'a> Cmd<'a> {
             collect_opts,
             take_opt_args,
             until_1st_arg,
+            is_after_end_opt,
         );
 
         for str_ref in str_refs {
@@ -370,8 +372,8 @@ impl<'b, 'a> Cmd<'a> {
             }
         }
 
-        if let Some(idx) = result? {
-            return Ok(Some(idx + 1)); // +1, because _parse_args parses from 1
+        if let Some((idx, is_after_end_opt)) = result? {
+            return Ok(Some((idx + 1, is_after_end_opt))); // +1, because _parse_args parses from 1
         }
 
         Ok(None)
@@ -2260,4 +2262,92 @@ mod tests_of_parse_util_sub_cmd_with {
         assert_eq!(cmd.cfgs[0].desc, "".to_string());
         assert_eq!(cmd.cfgs[0].arg_in_help, "".to_string());
     }
+
+    #[test]
+    fn should_parse_with_end_opt_mark() {
+        let opt_cfgs0 = vec![OptCfg::with([names(&["foo"])])];
+        let opt_cfgs1 = vec![OptCfg::with([names(&["bar"])])];
+
+        let mut cmd = Cmd::with_strings([
+            "app".to_string(),
+            "--foo".to_string(),
+            "sub".to_string(),
+            "--".to_string(),
+            "bar".to_string(),
+            "-@".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd_with(opt_cfgs0) {
+            Ok(Some(mut sub_cmd)) => {
+                assert_eq!(cmd.name(), "app");
+                assert_eq!(cmd.args(), &[] as &[&str]);
+                assert_eq!(cmd.has_opt("foo"), true);
+                assert_eq!(cmd.opt_arg("foo"), None);
+                assert_eq!(cmd.opt_args("foo"), Some(&[] as &[&str]));
+                assert_eq!(cmd.has_opt("bar"), false);
+                assert_eq!(cmd.opt_arg("bar"), None);
+                assert_eq!(cmd.opt_args("bar"), None);
+
+                match sub_cmd.parse_with(opt_cfgs1) {
+                    Ok(_) => {
+                        assert_eq!(sub_cmd.name(), "sub");
+                        assert_eq!(sub_cmd.args(), &["bar", "-@"] as &[&str]);
+                        assert_eq!(sub_cmd.has_opt("foo"), false);
+                        assert_eq!(sub_cmd.opt_arg("foo"), None);
+                        assert_eq!(sub_cmd.opt_args("foo"), None);
+                        assert_eq!(sub_cmd.has_opt("bar"), false);
+                        assert_eq!(sub_cmd.opt_arg("bar"), None);
+                        assert_eq!(sub_cmd.opt_args("bar"), None);
+                    }
+                    Err(_) => assert!(false),
+                }
+            }
+            Ok(None) => assert!(false),
+            Err(_) => assert!(false),
+        }
+    }
+
+    #[test]
+    fn should_parse_after_end_opt_mark() {
+        let opt_cfgs0 = vec![OptCfg::with([names(&["foo"])])];
+        let opt_cfgs1 = vec![OptCfg::with([names(&["bar"])])];
+
+        let mut cmd = Cmd::with_strings([
+            "app".to_string(),
+            "--".to_string(),
+            "--foo".to_string(),
+            "sub".to_string(),
+            "bar".to_string(),
+            "-@".to_string(),
+        ]);
+
+        match cmd.parse_until_sub_cmd_with(opt_cfgs0) {
+            Ok(Some(mut sub_cmd)) => {
+                assert_eq!(cmd.name(), "app");
+                assert_eq!(cmd.args(), &[] as &[&str]);
+                assert_eq!(cmd.has_opt("foo"), false);
+                assert_eq!(cmd.opt_arg("foo"), None);
+                assert_eq!(cmd.opt_args("foo"), None);
+                assert_eq!(cmd.has_opt("bar"), false);
+                assert_eq!(cmd.opt_arg("bar"), None);
+                assert_eq!(cmd.opt_args("bar"), None);
+
+                match sub_cmd.parse_with(opt_cfgs1) {
+                    Ok(_) => {
+                        assert_eq!(sub_cmd.name(), "--foo");
+                        assert_eq!(sub_cmd.args(), &["sub", "bar", "-@"] as &[&str]);
+                        assert_eq!(sub_cmd.has_opt("foo"), false);
+                        assert_eq!(sub_cmd.opt_arg("foo"), None);
+                        assert_eq!(sub_cmd.opt_args("foo"), None);
+                        assert_eq!(sub_cmd.has_opt("bar"), false);
+                        assert_eq!(sub_cmd.opt_arg("bar"), None);
+                        assert_eq!(sub_cmd.opt_args("bar"), None);
+                    }
+                    Err(_) => assert!(false),
+                }
+            }
+            Ok(None) => assert!(false),
+            Err(_) => assert!(false),
+        }
+    }
 }