We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
"This command is not documented."
It looks like we lost documentation via `help` at some point in time.  This is related to #232 

```
pwndbg> help search
This command is not documented.
```



--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `pwndbg/commands/__init__.py`
Content:
```
1 #!/usr/bin/env python
2 # -*- coding: utf-8 -*-
3 from __future__ import absolute_import
4 from __future__ import division
5 from __future__ import print_function
6 from __future__ import unicode_literals
7 
8 import argparse
9 import functools
10 
11 import gdb
12 
13 import pwndbg.chain
14 import pwndbg.color
15 import pwndbg.enhance
16 import pwndbg.exception
17 import pwndbg.hexdump
18 import pwndbg.memory
19 import pwndbg.regs
20 import pwndbg.symbol
21 import pwndbg.ui
22 
23 
24 class Command(gdb.Command):
25     """Generic command wrapper"""
26     count    = 0
27     commands = []
28     history  = {}
29 
30     def __init__(self, function, inc=True, prefix=False):
31         super(Command, self).__init__(function.__name__, gdb.COMMAND_USER, gdb.COMPLETE_EXPRESSION, prefix=prefix)
32         self.function = function
33 
34         if inc:
35             self.commands.append(self)
36 
37         functools.update_wrapper(self, function)
38         self.__doc__ = function.__doc__
39 
40     def split_args(self, argument):
41         """Split a command-line string from the user into arguments.
42 
43         Returns:
44             A ``(tuple, dict)``, in the form of ``*args, **kwargs``.
45             The contents of the tuple/dict are undefined.
46         """
47         return gdb.string_to_argv(argument), {}
48 
49     def invoke(self, argument, from_tty):
50         """Invoke the command with an argument string"""
51         try:
52             args, kwargs = self.split_args(argument)
53         except SystemExit:
54             # Raised when the usage is printed by an ArgparsedCommand
55             return
56         except (TypeError, gdb.error):
57             pwndbg.exception.handle(self.function.__name__)
58             return
59 
60         try:
61             self.repeat = self.check_repeated(argument, from_tty)
62             return self(*args, **kwargs)
63         finally:
64             self.repeat = False
65 
66     def check_repeated(self, argument, from_tty):
67         """Keep a record of all commands which come from the TTY.
68 
69         Returns:
70             True if this command was executed by the user just hitting "enter".
71         """
72         # Don't care unless it's interactive use
73         if not from_tty:
74             return False
75 
76         lines = gdb.execute('show commands', from_tty=False, to_string=True)
77         lines = lines.splitlines()
78 
79         # No history
80         if not lines:
81             return False
82 
83         last_line = lines[-1]
84         number, command = last_line.split(None, 1)
85         number = int(number)
86 
87         # A new command was entered by the user
88         if number not in Command.history:
89             Command.history[number] = command
90             return False
91 
92         # Somehow the command is different than we got before?
93         if not command.endswith(argument):
94             return False
95 
96         return True
97 
98     def __call__(self, *args, **kwargs):
99         try:
100             return self.function(*args, **kwargs)
101         except TypeError as te:
102             print('%r: %s' % (self.function.__name__.strip(),
103                               self.function.__doc__.strip()))
104             pwndbg.exception.handle(self.function.__name__)
105         except Exception:
106             pwndbg.exception.handle(self.function.__name__)
107 
108 
109 class ParsedCommand(Command):
110     #: Whether to return the string 'arg' if parsing fails.
111     sloppy = False
112 
113     #: Whether to hide errors during parsing
114     quiet  = False
115 
116     def split_args(self, argument):
117         # sys.stdout.write(repr(argument) + '\n')
118         argv, _ = super(ParsedCommand, self).split_args(argument)
119         # sys.stdout.write(repr(argv) + '\n')
120         return list(filter(lambda x: x is not None, map(self.fix, argv))), {}
121 
122     def fix(self, arg):
123         return fix(arg, self.sloppy, self.quiet)
124 
125 
126 class ParsedCommandPrefix(ParsedCommand):
127     def __init__(self, function, inc=True, prefix=True):
128         super(ParsedCommand, self).__init__(function, inc, prefix)
129 
130 
131 
132 def fix(arg, sloppy=False, quiet=True, reraise=False):
133     """Fix a single command-line argument coming from the GDB CLI.
134 
135     Arguments:
136         arg(str): Original string representation (e.g. '0', '$rax', '$rax+44')
137         sloppy(bool): If ``arg`` cannot be evaluated, return ``arg``. (default: False)
138         quiet(bool): If an error occurs, suppress it. (default: True)
139         reraise(bool): If an error occurs, raise the exception. (default: False)
140 
141     Returns:
142         Ideally ``gdb.Value`` object.  May return a ``str`` if ``sloppy==True``.
143         May return ``None`` if ``sloppy == False and reraise == False``.
144     """
145     if isinstance(arg, gdb.Value):
146         return arg
147 
148     try:
149         parsed = gdb.parse_and_eval(arg)
150         return parsed
151     except Exception:
152         pass
153 
154     try:
155         arg = pwndbg.regs.fix(arg)
156         return gdb.parse_and_eval(arg)
157     except Exception as e:
158         if not quiet:
159             print(e)
160         if reraise:
161             raise e
162         pass
163 
164     if sloppy:
165         return arg
166 
167     return None
168 
169 
170 def fix_int(*a, **kw):
171     return int(fix(*a,**kw))
172 
173 def fix_int_reraise(*a, **kw):
174     return fix(*a, reraise=True, **kw)
175 
176 
177 def OnlyWithFile(function):
178     @functools.wraps(function)
179     def _OnlyWithFile(*a, **kw):
180         if pwndbg.proc.exe:
181             return function(*a, **kw)
182         else:
183             print("%s: There is no file loaded." % function.__name__)
184 
185     return _OnlyWithFile
186 
187 
188 def OnlyWhenRunning(function):
189     @functools.wraps(function)
190     def _OnlyWhenRunning(*a, **kw):
191         if pwndbg.proc.alive:
192             return function(*a, **kw)
193         else:
194             print("%s: The program is not being run." % function.__name__)
195     return _OnlyWhenRunning
196 
197 
198 class QuietSloppyParsedCommand(ParsedCommand):
199     def __init__(self, *a, **kw):
200         super(QuietSloppyParsedCommand, self).__init__(*a, **kw)
201         self.quiet = True
202         self.sloppy = True
203 
204 
205 class _ArgparsedCommand(Command):
206     def __init__(self, parser, function, *a, **kw):
207         self.parser = parser
208         self.parser.prog = function.__name__
209         function.__doc__ = self.parser.description
210         super(_ArgparsedCommand, self).__init__(function, *a, **kw)
211 
212     def split_args(self, argument):
213         argv = gdb.string_to_argv(argument)
214         return tuple(), vars(self.parser.parse_args(argv))
215 
216 
217 class ArgparsedCommand(object):
218     """Adds documentation and offloads parsing for a Command via argparse"""
219     def __init__(self, parser):
220         self.parser = parser
221 
222         # We want to run all integer and otherwise-unspecified arguments
223         # through fix() so that GDB parses it.
224         for action in parser._actions:
225             if action.dest == 'help':
226                 continue
227             if action.type in (int, None):
228                 action.type = fix_int_reraise
229             if action.default is not None:
230                 action.help += ' (default: %(default)s)'
231 
232     def __call__(self, function):
233         return _ArgparsedCommand(self.parser, function)
234 
235 
236 def sloppy_gdb_parse(s):
237     """
238     This function should be used as ``argparse.ArgumentParser`` .add_argument method's `type` helper.
239     
240     This makes the type being parsed as gdb value and if that parsing fails,
241     a string is returned.
242 
243     :param s: String.
244     :return: Whatever gdb.parse_and_eval returns or string.
245     """
246     try:
247         return gdb.parse_and_eval(s)
248     except (TypeError, gdb.error):
249         return s
250
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/pwndbg/commands/__init__.py b/pwndbg/commands/__init__.py
--- a/pwndbg/commands/__init__.py
+++ b/pwndbg/commands/__init__.py
@@ -206,7 +206,7 @@
     def __init__(self, parser, function, *a, **kw):
         self.parser = parser
         self.parser.prog = function.__name__
-        function.__doc__ = self.parser.description
+        self.__doc__ = function.__doc__ = self.parser.description
         super(_ArgparsedCommand, self).__init__(function, *a, **kw)
 
     def split_args(self, argument):

{"golden_diff": "diff --git a/pwndbg/commands/__init__.py b/pwndbg/commands/__init__.py\n--- a/pwndbg/commands/__init__.py\n+++ b/pwndbg/commands/__init__.py\n@@ -206,7 +206,7 @@\n     def __init__(self, parser, function, *a, **kw):\n         self.parser = parser\n         self.parser.prog = function.__name__\n-        function.__doc__ = self.parser.description\n+        self.__doc__ = function.__doc__ = self.parser.description\n         super(_ArgparsedCommand, self).__init__(function, *a, **kw)\n \n     def split_args(self, argument):\n", "issue": "\"This command is not documented.\"\nIt looks like we lost documentation via `help` at some point in time.  This is related to #232 \r\n\r\n```\r\npwndbg> help search\r\nThis command is not documented.\r\n```\r\n\r\n\n", "before_files": [{"content": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport argparse\nimport functools\n\nimport gdb\n\nimport pwndbg.chain\nimport pwndbg.color\nimport pwndbg.enhance\nimport pwndbg.exception\nimport pwndbg.hexdump\nimport pwndbg.memory\nimport pwndbg.regs\nimport pwndbg.symbol\nimport pwndbg.ui\n\n\nclass Command(gdb.Command):\n    \"\"\"Generic command wrapper\"\"\"\n    count    = 0\n    commands = []\n    history  = {}\n\n    def __init__(self, function, inc=True, prefix=False):\n        super(Command, self).__init__(function.__name__, gdb.COMMAND_USER, gdb.COMPLETE_EXPRESSION, prefix=prefix)\n        self.function = function\n\n        if inc:\n            self.commands.append(self)\n\n        functools.update_wrapper(self, function)\n        self.__doc__ = function.__doc__\n\n    def split_args(self, argument):\n        \"\"\"Split a command-line string from the user into arguments.\n\n        Returns:\n            A ``(tuple, dict)``, in the form of ``*args, **kwargs``.\n            The contents of the tuple/dict are undefined.\n        \"\"\"\n        return gdb.string_to_argv(argument), {}\n\n    def invoke(self, argument, from_tty):\n        \"\"\"Invoke the command with an argument string\"\"\"\n        try:\n            args, kwargs = self.split_args(argument)\n        except SystemExit:\n            # Raised when the usage is printed by an ArgparsedCommand\n            return\n        except (TypeError, gdb.error):\n            pwndbg.exception.handle(self.function.__name__)\n            return\n\n        try:\n            self.repeat = self.check_repeated(argument, from_tty)\n            return self(*args, **kwargs)\n        finally:\n            self.repeat = False\n\n    def check_repeated(self, argument, from_tty):\n        \"\"\"Keep a record of all commands which come from the TTY.\n\n        Returns:\n            True if this command was executed by the user just hitting \"enter\".\n        \"\"\"\n        # Don't care unless it's interactive use\n        if not from_tty:\n            return False\n\n        lines = gdb.execute('show commands', from_tty=False, to_string=True)\n        lines = lines.splitlines()\n\n        # No history\n        if not lines:\n            return False\n\n        last_line = lines[-1]\n        number, command = last_line.split(None, 1)\n        number = int(number)\n\n        # A new command was entered by the user\n        if number not in Command.history:\n            Command.history[number] = command\n            return False\n\n        # Somehow the command is different than we got before?\n        if not command.endswith(argument):\n            return False\n\n        return True\n\n    def __call__(self, *args, **kwargs):\n        try:\n            return self.function(*args, **kwargs)\n        except TypeError as te:\n            print('%r: %s' % (self.function.__name__.strip(),\n                              self.function.__doc__.strip()))\n            pwndbg.exception.handle(self.function.__name__)\n        except Exception:\n            pwndbg.exception.handle(self.function.__name__)\n\n\nclass ParsedCommand(Command):\n    #: Whether to return the string 'arg' if parsing fails.\n    sloppy = False\n\n    #: Whether to hide errors during parsing\n    quiet  = False\n\n    def split_args(self, argument):\n        # sys.stdout.write(repr(argument) + '\\n')\n        argv, _ = super(ParsedCommand, self).split_args(argument)\n        # sys.stdout.write(repr(argv) + '\\n')\n        return list(filter(lambda x: x is not None, map(self.fix, argv))), {}\n\n    def fix(self, arg):\n        return fix(arg, self.sloppy, self.quiet)\n\n\nclass ParsedCommandPrefix(ParsedCommand):\n    def __init__(self, function, inc=True, prefix=True):\n        super(ParsedCommand, self).__init__(function, inc, prefix)\n\n\n\ndef fix(arg, sloppy=False, quiet=True, reraise=False):\n    \"\"\"Fix a single command-line argument coming from the GDB CLI.\n\n    Arguments:\n        arg(str): Original string representation (e.g. '0', '$rax', '$rax+44')\n        sloppy(bool): If ``arg`` cannot be evaluated, return ``arg``. (default: False)\n        quiet(bool): If an error occurs, suppress it. (default: True)\n        reraise(bool): If an error occurs, raise the exception. (default: False)\n\n    Returns:\n        Ideally ``gdb.Value`` object.  May return a ``str`` if ``sloppy==True``.\n        May return ``None`` if ``sloppy == False and reraise == False``.\n    \"\"\"\n    if isinstance(arg, gdb.Value):\n        return arg\n\n    try:\n        parsed = gdb.parse_and_eval(arg)\n        return parsed\n    except Exception:\n        pass\n\n    try:\n        arg = pwndbg.regs.fix(arg)\n        return gdb.parse_and_eval(arg)\n    except Exception as e:\n        if not quiet:\n            print(e)\n        if reraise:\n            raise e\n        pass\n\n    if sloppy:\n        return arg\n\n    return None\n\n\ndef fix_int(*a, **kw):\n    return int(fix(*a,**kw))\n\ndef fix_int_reraise(*a, **kw):\n    return fix(*a, reraise=True, **kw)\n\n\ndef OnlyWithFile(function):\n    @functools.wraps(function)\n    def _OnlyWithFile(*a, **kw):\n        if pwndbg.proc.exe:\n            return function(*a, **kw)\n        else:\n            print(\"%s: There is no file loaded.\" % function.__name__)\n\n    return _OnlyWithFile\n\n\ndef OnlyWhenRunning(function):\n    @functools.wraps(function)\n    def _OnlyWhenRunning(*a, **kw):\n        if pwndbg.proc.alive:\n            return function(*a, **kw)\n        else:\n            print(\"%s: The program is not being run.\" % function.__name__)\n    return _OnlyWhenRunning\n\n\nclass QuietSloppyParsedCommand(ParsedCommand):\n    def __init__(self, *a, **kw):\n        super(QuietSloppyParsedCommand, self).__init__(*a, **kw)\n        self.quiet = True\n        self.sloppy = True\n\n\nclass _ArgparsedCommand(Command):\n    def __init__(self, parser, function, *a, **kw):\n        self.parser = parser\n        self.parser.prog = function.__name__\n        function.__doc__ = self.parser.description\n        super(_ArgparsedCommand, self).__init__(function, *a, **kw)\n\n    def split_args(self, argument):\n        argv = gdb.string_to_argv(argument)\n        return tuple(), vars(self.parser.parse_args(argv))\n\n\nclass ArgparsedCommand(object):\n    \"\"\"Adds documentation and offloads parsing for a Command via argparse\"\"\"\n    def __init__(self, parser):\n        self.parser = parser\n\n        # We want to run all integer and otherwise-unspecified arguments\n        # through fix() so that GDB parses it.\n        for action in parser._actions:\n            if action.dest == 'help':\n                continue\n            if action.type in (int, None):\n                action.type = fix_int_reraise\n            if action.default is not None:\n                action.help += ' (default: %(default)s)'\n\n    def __call__(self, function):\n        return _ArgparsedCommand(self.parser, function)\n\n\ndef sloppy_gdb_parse(s):\n    \"\"\"\n    This function should be used as ``argparse.ArgumentParser`` .add_argument method's `type` helper.\n    \n    This makes the type being parsed as gdb value and if that parsing fails,\n    a string is returned.\n\n    :param s: String.\n    :return: Whatever gdb.parse_and_eval returns or string.\n    \"\"\"\n    try:\n        return gdb.parse_and_eval(s)\n    except (TypeError, gdb.error):\n        return s\n", "path": "pwndbg/commands/__init__.py"}], "after_files": [{"content": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport argparse\nimport functools\n\nimport gdb\n\nimport pwndbg.chain\nimport pwndbg.color\nimport pwndbg.enhance\nimport pwndbg.exception\nimport pwndbg.hexdump\nimport pwndbg.memory\nimport pwndbg.regs\nimport pwndbg.symbol\nimport pwndbg.ui\n\n\nclass Command(gdb.Command):\n    \"\"\"Generic command wrapper\"\"\"\n    count    = 0\n    commands = []\n    history  = {}\n\n    def __init__(self, function, inc=True, prefix=False):\n        super(Command, self).__init__(function.__name__, gdb.COMMAND_USER, gdb.COMPLETE_EXPRESSION, prefix=prefix)\n        self.function = function\n\n        if inc:\n            self.commands.append(self)\n\n        functools.update_wrapper(self, function)\n        self.__doc__ = function.__doc__\n\n    def split_args(self, argument):\n        \"\"\"Split a command-line string from the user into arguments.\n\n        Returns:\n            A ``(tuple, dict)``, in the form of ``*args, **kwargs``.\n            The contents of the tuple/dict are undefined.\n        \"\"\"\n        return gdb.string_to_argv(argument), {}\n\n    def invoke(self, argument, from_tty):\n        \"\"\"Invoke the command with an argument string\"\"\"\n        try:\n            args, kwargs = self.split_args(argument)\n        except SystemExit:\n            # Raised when the usage is printed by an ArgparsedCommand\n            return\n        except (TypeError, gdb.error):\n            pwndbg.exception.handle(self.function.__name__)\n            return\n\n        try:\n            self.repeat = self.check_repeated(argument, from_tty)\n            return self(*args, **kwargs)\n        finally:\n            self.repeat = False\n\n    def check_repeated(self, argument, from_tty):\n        \"\"\"Keep a record of all commands which come from the TTY.\n\n        Returns:\n            True if this command was executed by the user just hitting \"enter\".\n        \"\"\"\n        # Don't care unless it's interactive use\n        if not from_tty:\n            return False\n\n        lines = gdb.execute('show commands', from_tty=False, to_string=True)\n        lines = lines.splitlines()\n\n        # No history\n        if not lines:\n            return False\n\n        last_line = lines[-1]\n        number, command = last_line.split(None, 1)\n        number = int(number)\n\n        # A new command was entered by the user\n        if number not in Command.history:\n            Command.history[number] = command\n            return False\n\n        # Somehow the command is different than we got before?\n        if not command.endswith(argument):\n            return False\n\n        return True\n\n    def __call__(self, *args, **kwargs):\n        try:\n            return self.function(*args, **kwargs)\n        except TypeError as te:\n            print('%r: %s' % (self.function.__name__.strip(),\n                              self.function.__doc__.strip()))\n            pwndbg.exception.handle(self.function.__name__)\n        except Exception:\n            pwndbg.exception.handle(self.function.__name__)\n\n\nclass ParsedCommand(Command):\n    #: Whether to return the string 'arg' if parsing fails.\n    sloppy = False\n\n    #: Whether to hide errors during parsing\n    quiet  = False\n\n    def split_args(self, argument):\n        # sys.stdout.write(repr(argument) + '\\n')\n        argv, _ = super(ParsedCommand, self).split_args(argument)\n        # sys.stdout.write(repr(argv) + '\\n')\n        return list(filter(lambda x: x is not None, map(self.fix, argv))), {}\n\n    def fix(self, arg):\n        return fix(arg, self.sloppy, self.quiet)\n\n\nclass ParsedCommandPrefix(ParsedCommand):\n    def __init__(self, function, inc=True, prefix=True):\n        super(ParsedCommand, self).__init__(function, inc, prefix)\n\n\n\ndef fix(arg, sloppy=False, quiet=True, reraise=False):\n    \"\"\"Fix a single command-line argument coming from the GDB CLI.\n\n    Arguments:\n        arg(str): Original string representation (e.g. '0', '$rax', '$rax+44')\n        sloppy(bool): If ``arg`` cannot be evaluated, return ``arg``. (default: False)\n        quiet(bool): If an error occurs, suppress it. (default: True)\n        reraise(bool): If an error occurs, raise the exception. (default: False)\n\n    Returns:\n        Ideally ``gdb.Value`` object.  May return a ``str`` if ``sloppy==True``.\n        May return ``None`` if ``sloppy == False and reraise == False``.\n    \"\"\"\n    if isinstance(arg, gdb.Value):\n        return arg\n\n    try:\n        parsed = gdb.parse_and_eval(arg)\n        return parsed\n    except Exception:\n        pass\n\n    try:\n        arg = pwndbg.regs.fix(arg)\n        return gdb.parse_and_eval(arg)\n    except Exception as e:\n        if not quiet:\n            print(e)\n        if reraise:\n            raise e\n        pass\n\n    if sloppy:\n        return arg\n\n    return None\n\n\ndef fix_int(*a, **kw):\n    return int(fix(*a,**kw))\n\ndef fix_int_reraise(*a, **kw):\n    return fix(*a, reraise=True, **kw)\n\n\ndef OnlyWithFile(function):\n    @functools.wraps(function)\n    def _OnlyWithFile(*a, **kw):\n        if pwndbg.proc.exe:\n            return function(*a, **kw)\n        else:\n            print(\"%s: There is no file loaded.\" % function.__name__)\n\n    return _OnlyWithFile\n\n\ndef OnlyWhenRunning(function):\n    @functools.wraps(function)\n    def _OnlyWhenRunning(*a, **kw):\n        if pwndbg.proc.alive:\n            return function(*a, **kw)\n        else:\n            print(\"%s: The program is not being run.\" % function.__name__)\n    return _OnlyWhenRunning\n\n\nclass QuietSloppyParsedCommand(ParsedCommand):\n    def __init__(self, *a, **kw):\n        super(QuietSloppyParsedCommand, self).__init__(*a, **kw)\n        self.quiet = True\n        self.sloppy = True\n\n\nclass _ArgparsedCommand(Command):\n    def __init__(self, parser, function, *a, **kw):\n        self.parser = parser\n        self.parser.prog = function.__name__\n        self.__doc__ = function.__doc__ = self.parser.description\n        super(_ArgparsedCommand, self).__init__(function, *a, **kw)\n\n    def split_args(self, argument):\n        argv = gdb.string_to_argv(argument)\n        return tuple(), vars(self.parser.parse_args(argv))\n\n\nclass ArgparsedCommand(object):\n    \"\"\"Adds documentation and offloads parsing for a Command via argparse\"\"\"\n    def __init__(self, parser):\n        self.parser = parser\n\n        # We want to run all integer and otherwise-unspecified arguments\n        # through fix() so that GDB parses it.\n        for action in parser._actions:\n            if action.dest == 'help':\n                continue\n            if action.type in (int, None):\n                action.type = fix_int_reraise\n            if action.default is not None:\n                action.help += ' (default: %(default)s)'\n\n    def __call__(self, function):\n        return _ArgparsedCommand(self.parser, function)\n\n\ndef sloppy_gdb_parse(s):\n    \"\"\"\n    This function should be used as ``argparse.ArgumentParser`` .add_argument method's `type` helper.\n    \n    This makes the type being parsed as gdb value and if that parsing fails,\n    a string is returned.\n\n    :param s: String.\n    :return: Whatever gdb.parse_and_eval returns or string.\n    \"\"\"\n    try:\n        return gdb.parse_and_eval(s)\n    except (TypeError, gdb.error):\n        return s\n", "path": "pwndbg/commands/__init__.py"}]}