eD5l&@3*A3l3<3$3
333
4
4,4A4X4	n4x444444
55 /5P5d5(5/5;5$6::6u66(6'6"67(7)E7o7377&7&7/!8/Q88.8+88/949E9c9"9999-9:%:B:(S:|::::::);8;W;u;;;;;; <!%<G<]<,w<< <<+<
=0)='Z=.==0==>,>?>O>b>y>>>>
>>?&+?R?h?/???)?@+@3:@n@@@@&@@@A
A!A@A _A9A#AAABBHEBIRIbIF
nIJJJJ	J	J%
K'Q
;Q[1\m
2\]2]_]
aYcT2gimhq+w
'z||?j}r__g̡4u
'v
|g
F[v?Ƕ )0	@JSg	{N۷J],
+=
XfD
Qb	P@x
"
g<5

q
uFFNL


qy>
sv



Z
|I
D$
%
%
	%
g	&
q*
y*
*
*
*

*
*W,

,
,
,
,
5,
O
-
Bc.
x.
B6
Eb6
6

6
6
}6
V9
Xj9
9
*9

:

:
(:

>
l@
{@
eA
F
#F

;F
FF
WF
iF
%F
$F
'F
F
%G
5G
NG
.hG
G
G
!G
G
H
,H
9H
'PH
0xH
H
9H
I
I
I
%0I
.VI
4I
)I
I
$J
)J
=J

NJ
\J
lJ
&uJ
'J
3J
9J
2K
6DK
6{K
K
.FL
:uL
3L
	L
L
!M

)M
37M
kM
=M
M
M

M
)N
2N
'RN
zN
N
&N
N
*N
*O
)2O
)\O
O
O
%O
%O
 O
P
)P
HP
-TP
#P
1P
&P
&P
&&Q
5MQ
.Q
Q
Q
!Q
!R
:"R
]R
zR
 R
R
0R
1R
+S
S
#rT
(T
$T
T
$T
#U
':U
bU
SjU
.U
U
V
"V
8V
)OV

yV
V
V
V
V
V
,V
%W
!DW
,fW
"W
!W
W
.W
?X
+VX
X
X
X
1X
X
#X
@Y

XY
fY
Y
-Y
,Y
'Y
!Z
<Z
.LZ
,{Z
&Z
*Z
0Z
6+[
Gb[
:[
P[
(6\
 _\
)\
\
\
"\
?\
T8]
]
]

]
8]
V]
&R^
'y^
4^
^
^
_
(_
D_
\_
s_
_
_
_
_
#_
`
"`
@`
5M`
O`
`
`
`
	`
a
5 a
Va
va

~a

a
+a
9a
;a
$6b
[b
dyb
$b
c
"c
.c
:c
Sc
 qc
c
c
c
Hc
d
,d
Id
Vd
"id
+d
d
d
d
4d

%e
D0e
?ue
,e
e
e
2
f
!@f
"bf
"f
0f
f
f
	g
pg

g
fg
1g
/%h
)Uh
-h
3h
h
&h
2"i
5Ui
,i

i
"i

i
1i
I#j
4mj
j
.j
>j
)'k
NQk
	k
k
 k
"k
%k
 l

:l
Hl
Ul
&bl
=l
l
'l
Gm
Nm
lm
m
,m
$m
Am
<4n
qn
n
n
n
&n
6n
o
3o
QQo
*o
o
o
%p
.(p
-Wp
7p
6p
2p
1'q
*Yq
,q
,q
;q
#r
>r
Fr
\r
#|r
r
6r
r

s
*s
"Gs
js
6s
	s
-s
-s
#'t
Kt
'Wt
't
t
t
&t
=v
9w
=Ow
'w
w
w
w

w
%w
x
(x
Ax
Vx
bx
$vx
x
.x
!x
y
#*y
Ny
1hy
y
'y
:y
Fz
Zbz
&z
=z
"{
&7{
@^{
5{
1{
|
 "|
9C|
}|
6|
|
8|
+%}
HQ}
;}
}
8}
;+~
g~
;~
~
8~
"
A3
u


P
!
!:
\
2t

,Ā


"
">
4a
"
'
!
"
&
=
Z
#o
%
2


8&
_
(t

<

?
8H
K
̈́
:
%"
H
%h


Ņ

 
$
D
c
u
#
,


@
"\
$
2
!ׇ

@
M
f


=




)+
)U
%
M
2
&
?
S
of
֎



f

,!
N
f
r
"

C

!


8

&

ت


9
1۱



۽
p


H
9

w
	;

E
S
e






C

G


f
t
r

Y

fO




+
;
"Y
|R)
#7"[)~!'#:TaYi5D
>K
)
+y,#	---
5
7v7jTC7CJw
KNfRK;S\UX8[>
^
T_aafman
aCc`e
}gggxk	nSx{o~{tA
	 Z*	ɢ0Ҥ%&2Y9y
]R	ݧY0^0&Wkr0޵7G[o
g<
RgK#i
$**6@*wL*?7,w(='%3Y"n17 Gd}+8:6?-v,&924lHQ<8P8;mEB	20<+m
_&M.6|(=M,:z#1@:C{CBFb@wA*'%)Mw;J;-M9{-4B[.p3H5R'o!?[
i%0*'7_(l6-V
7X-,?+Q}1,-9;g(/A@M-4$-;Bi,',->6l&.,I><O5MKJU2:$m*1Y#[},B3Pv()A\|+:-&Ho~%)1.:=]x
#Q4#

3GXP(!e4Z*%) *Juu!(5J).8
:GDTQQ7ZJ(
"6"Y<|	znq4/&GV?R+1B]3<,>2M
:WT%s/@<
VG	&$*'7_q~.K11>kp( '&2N4UO\{(&YGgT,H:\UB6Ay987.=f=K..
]h!?)F6U9&K9\F\!
"
*4
-_
0







J
d}

s

.

/
J

?
	S
F<



i
\3
Kh
:nQ
0

#
`v
NRM

~

U
L

]=H
(
&Xu
|dr
4H&!
'O


1P
^

W
S
 a
N$


 
C

m
1

*
=
5
E

	
`1

%97

t
Yc
aj

m
c
/
["

+

V

];H
*-
Q

L,x
W

6




I-2

|

3
y\
Y
PG
h)eo+<
@
?
Pl
7eb,n

";
7t


8
^







8
Z
N
\V[


M
FX

gR
T_
I


p
,
:F
@
^U
l6

2B

D
]

!
Z

p 
GUA

/

:
I


f
4


K



2


;9
s=[&

V


>


qM_
G
0

%



K

>{
d
)
T


TS
E


w$


by


B
-
r
L#

Z

u}
v
"
g
D#


A
+
b
5
?




94
Qa
c
Eq
_
@'
e
`
3
.
J


z.O{(

w
OA05
z
(B
ki



C%

~k
	6
f<
)
8
>
Y
xR*
!X'C$

DWj
o
timed out waiting for input: auto-logout
	-%s or -o option
	-ilrsD or -c command or -O shopt_option		(invocation only)

malloc: %s:%d: assertion botched
  (wd: %s) (core dumped) line ! PIPELINE$%s: cannot assign in this way%c%c: invalid option%s can be invoked via %s has null exportstr%s is %s
%s is a function
%s is a shell builtin
%s is a shell keyword
%s is a special shell builtin
%s is aliased to `%s'
%s is hashed (%s)
%s is not bound to any keys.
%s out of range%s%s%s: %s (error token is "%s")%s: %s out of range%s: %s: cannot open as FILE%s: %s: compatibility value out of range%s: %s: invalid value for trace file descriptor%s: %s: must use subscript when assigning associative array%s: %s:%d: cannot allocate %lu bytes%s: %s:%d: cannot allocate %lu bytes (%lu bytes allocated)%s: Is a directory%s: ambiguous job spec%s: arguments must be process or job IDs%s: assigning integer to name reference%s: bad network path specification%s: bad substitution%s: binary operator expected%s: builtin names may not contain slashes%s: cannot allocate %lu bytes%s: cannot allocate %lu bytes (%lu bytes allocated)%s: cannot assign%s: cannot assign list to array member%s: cannot assign to non-numeric index%s: cannot convert associative to indexed array%s: cannot convert indexed to associative array%s: cannot delete: %s%s: cannot destroy array variables in this way%s: cannot execute: required file not found%s: cannot export%s: cannot inherit value from incompatible type%s: cannot unset%s: cannot unset: readonly %s%s: circular name reference%s: dynamic builtin already loaded%s: expression error
%s: file is too large%s: file not found%s: first non-whitespace character is not `"'%s: hash table empty
%s: history expansion failed%s: host unknown%s: ignoring function definition attempt%s: illegal option -- %c
%s: integer expected%s: invalid action name%s: invalid argument%s: invalid array origin%s: invalid callback quantum%s: invalid file descriptor specification%s: invalid indirect expansion%s: invalid job specification%s: invalid limit argument%s: invalid line count%s: invalid option%s: invalid option name%s: invalid service%s: invalid shell option name%s: invalid signal specification%s: invalid timeout specification%s: invalid timestamp%s: invalid variable name%s: invalid variable name for name reference%s: is a directory%s: job %d already in background%s: job has terminated%s: job specification requires leading `%%'%s: line %d: %s: maximum function nesting level exceeded (%d)%s: maximum nameref depth (%d) exceeded%s: maximum source nesting level exceeded (%d)%s: missing separator%s: nameref variable self references not allowed%s: no completion specification%s: no current jobs%s: no job control%s: no such job%s: not a function%s: not a regular file%s: not a shell builtin%s: not an array variable%s: not an indexed array%s: not dynamically loaded%s: not found%s: numeric argument required%s: option requires an argument%s: option requires an argument -- %c
%s: parameter not set%s: parameter null or not set%s: quoted compound array assignment deprecated%s: readonly function%s: readonly variable%s: reference variable cannot be an array%s: removing nameref attribute%s: restricted%s: restricted: cannot specify `/' in command names%s: substring expression < 0%s: unary operator expected%s: unbound variable%s: usage: %s: variable may not be assigned value'

(( expression ))(core dumped) (wd now: %s)
++: assignment requires lvalue--: assignment requires lvalue. [-p path] filename [arguments]/dev/(tcp|udp)/host/port not supported without networking/tmp must be a valid directory name<no current directory>ABORT instructionAborting...Add directories to stack.
    
    Adds a directory to the top of the directory stack, or rotates
    the stack, making the new top of the stack the current working
    directory.  With no arguments, exchanges the top two directories.
    
    Options:
      -n	Suppresses the normal change of directory when adding
    		directories to the stack, so only the stack is manipulated.
    
    Arguments:
      +N	Rotates the stack so that the Nth directory (counting
    		from the left of the list shown by `dirs', starting with
    		zero) is at the top.
    
      -N	Rotates the stack so that the Nth directory (counting
    		from the right of the list shown by `dirs', starting with
    		zero) is at the top.
    
      dir	Adds DIR to the directory stack at the top, making it the
    		new current working directory.
    
    The `dirs' builtin displays the directory stack.
    
    Exit Status:
    Returns success unless an invalid argument is supplied or the directory
    change fails.Adds a directory to the top of the directory stack, or rotates
    the stack, making the new top of the stack the current working
    directory.  With no arguments, exchanges the top two directories.
    
    Options:
      -n	Suppresses the normal change of directory when adding
    	directories to the stack, so only the stack is manipulated.
    
    Arguments:
      +N	Rotates the stack so that the Nth directory (counting
    	from the left of the list shown by `dirs', starting with
    	zero) is at the top.
    
      -N	Rotates the stack so that the Nth directory (counting
    	from the right of the list shown by `dirs', starting with
    	zero) is at the top.
    
      dir	Adds DIR to the directory stack at the top, making it the
    	new current working directory.
    
    The `dirs' builtin displays the directory stack.Alarm (profile)Alarm (virtual)Alarm clockArithmetic for loop.
    
    Equivalent to
    	(( EXP1 ))
    	while (( EXP2 )); do
    		COMMANDS
    		(( EXP3 ))
    	done
    EXP1, EXP2, and EXP3 are arithmetic expressions.  If any expression is
    omitted, it behaves as if it evaluates to 1.
    
    Exit Status:
    Returns the status of the last command executed.BPT trace/trapBad system callBogus signalBroken pipeBus errorCPU limitChange the shell working directory.
    
    Change the current directory to DIR.  The default DIR is the value of the
    HOME shell variable. If DIR is "-", it is converted to $OLDPWD.
    
    The variable CDPATH defines the search path for the directory containing
    DIR.  Alternative directory names in CDPATH are separated by a colon (:).
    A null directory name is the same as the current directory.  If DIR begins
    with a slash (/), then CDPATH is not used.
    
    If the directory is not found, and the shell option `cdable_vars' is set,
    the word is assumed to be  a variable name.  If that variable has a value,
    its value is used for DIR.
    
    Options:
      -L	force symbolic links to be followed: resolve symbolic
    		links in DIR after processing instances of `..'
      -P	use the physical directory structure without following
    		symbolic links: resolve symbolic links in DIR before
    		processing instances of `..'
      -e	if the -P option is supplied, and the current working
    		directory cannot be determined successfully, exit with
    		a non-zero status
      -@	on systems that support it, present a file with extended
    		attributes as a directory containing the file attributes
    
    The default is to follow symbolic links, as if `-L' were specified.
    `..' is processed by removing the immediately previous pathname component
    back to a slash or the beginning of DIR.
    
    Exit Status:
    Returns 0 if the directory is changed, and if $PWD is set successfully when
    -P is used; non-zero otherwise.Child death or stopCommon shell variable names and usage.
    
    BASH_VERSION	Version information for this Bash.
    CDPATH	A colon-separated list of directories to search
    		for directories given as arguments to `cd'.
    GLOBIGNORE	A colon-separated list of patterns describing filenames to
    		be ignored by pathname expansion.
    HISTFILE	The name of the file where your command history is stored.
    HISTFILESIZE	The maximum number of lines this file can contain.
    HISTSIZE	The maximum number of history lines that a running
    		shell can access.
    HOME	The complete pathname to your login directory.
    HOSTNAME	The name of the current host.
    HOSTTYPE	The type of CPU this version of Bash is running under.
    IGNOREEOF	Controls the action of the shell on receipt of an EOF
    		character as the sole input.  If set, then the value
    		of it is the number of EOF characters that can be seen
    		in a row on an empty line before the shell will exit
    		(default 10).  When unset, EOF signifies the end of input.
    MACHTYPE	A string describing the current system Bash is running on.
    MAILCHECK	How often, in seconds, Bash checks for new mail.
    MAILPATH	A colon-separated list of filenames which Bash checks
    		for new mail.
    OSTYPE	The version of Unix this version of Bash is running on.
    PATH	A colon-separated list of directories to search when
    		looking for commands.
    PROMPT_COMMAND	A command to be executed before the printing of each
    		primary prompt.
    PS1		The primary prompt string.
    PS2		The secondary prompt string.
    PWD		The full pathname of the current directory.
    SHELLOPTS	A colon-separated list of enabled shell options.
    TERM	The name of the current terminal type.
    TIMEFORMAT	The output format for timing statistics displayed by the
    		`time' reserved word.
    auto_resume	Non-null means a command word appearing on a line by
    		itself is first looked for in the list of currently
    		stopped jobs.  If found there, that job is foregrounded.
    		A value of `exact' means that the command word must
    		exactly match a command in the list of stopped jobs.  A
    		value of `substring' means that the command word must
    		match a substring of the job.  Any other value means that
    		the command must be a prefix of a stopped job.
    histchars	Characters controlling history expansion and quick
    		substitution.  The first character is the history
    		substitution character, usually `!'.  The second is
    		the `quick substitution' character, usually `^'.  The
    		third is the `history comment' character, usually `#'.
    HISTIGNORE	A colon-separated list of patterns used to decide which
    		commands should be saved on the history list.
ContinueCopyright (C) 2025 Free Software Foundation, Inc.Create a coprocess named NAME.
    
    Execute COMMAND asynchronously, with the standard output and standard
    input of the command connected via a pipe to file descriptors assigned
    to indices 0 and 1 of an array variable NAME in the executing shell.
    The default NAME is "COPROC".
    
    Exit Status:
    The coproc command returns an exit status of 0.DEBUG warning: Define local variables.
    
    Create a local variable called NAME, and give it VALUE.  OPTION can
    be any option accepted by `declare'.
    
    If any NAME is "-", local saves the set of shell options and restores
    them when the function returns.
    
    Local variables can only be used within a function; they are visible
    only to the function where they are defined and its children.
    
    Exit Status:
    Returns success unless an invalid option is supplied, a variable
    assignment error occurs, or the shell is not executing a function.Define or display aliases.
    
    Without arguments, `alias' prints the list of aliases in the reusable
    form `alias NAME=VALUE' on standard output.
    
    Otherwise, an alias is defined for each NAME whose VALUE is given.
    A trailing space in VALUE causes the next word to be checked for
    alias substitution when the alias is expanded.
    
    Options:
      -p	print all defined aliases in a reusable format
    
    Exit Status:
    alias returns true unless a NAME is supplied for which no alias has been
    defined.Define shell function.
    
    Create a shell function named NAME.  When invoked as a simple command,
    NAME runs COMMANDs in the calling shell's context.  When NAME is invoked,
    the arguments are passed to the function as $1...$n, and the function's
    name is in $FUNCNAME.
    
    Exit Status:
    Returns success unless NAME is readonly.Display directory stack.
    
    Display the list of currently remembered directories.  Directories
    find their way onto the list with the `pushd' command; you can get
    back up through the list with the `popd' command.
    
    Options:
      -c	clear the directory stack by deleting all of the elements
      -l	do not print tilde-prefixed versions of directories relative
    		to your home directory
      -p	print the directory stack with one entry per line
      -v	print the directory stack with one entry per line prefixed
    		with its position in the stack
    
    Arguments:
      +N	Displays the Nth entry counting from the left of the list
    		shown by dirs when invoked without options, starting with
    		zero.
    
      -N	Displays the Nth entry counting from the right of the list
    		shown by dirs when invoked without options, starting with
    		zero.
    
    Exit Status:
    Returns success unless an invalid option is supplied or an error occurs.Display information about builtin commands.
    
    Displays brief summaries of builtin commands.  If PATTERN is
    specified, gives detailed help on all commands matching PATTERN,
    otherwise the list of help topics is printed.
    
    Options:
      -d	output short description for each topic
      -m	display usage in pseudo-manpage format
      -s	output only a short usage synopsis for each topic matching
    		PATTERN
    
    Arguments:
      PATTERN	Pattern specifying a help topic
    
    Exit Status:
    Returns success unless PATTERN is not found or an invalid option is given.Display information about command type.
    
    For each NAME, indicate how it would be interpreted if used as a
    command name.
    
    Options:
      -a	display all locations containing an executable named NAME;
    		includes aliases, builtins, and functions, if and only if
    		the `-p' option is not also used
      -f	suppress shell function lookup
      -P	force a PATH search for each NAME, even if it is an alias,
    		builtin, or function, and returns the name of the disk file
    		that would be executed
      -p	returns either the name of the disk file that would be executed,
    		or nothing if `type -t NAME' would not return `file'
      -t	output a single word which is one of `alias', `keyword',
    		`function', `builtin', `file' or `', if NAME is an alias,
    		shell reserved word, shell function, shell builtin, disk file,
    		or not found, respectively
    
    Arguments:
      NAME	Command name to be interpreted.
    
    Exit Status:
    Returns success if all of the NAMEs are found; fails if any are not found.Display or execute commands from the history list.
    
    fc is used to list or edit and re-execute commands from the history list.
    FIRST and LAST can be numbers specifying the range, or FIRST can be a
    string, which means the most recent command beginning with that
    string.
    
    Options:
      -e ENAME	select which editor to use.  Default is FCEDIT, then EDITOR,
    		then vi
      -l 	list lines instead of editing
      -n	omit line numbers when listing
      -r	reverse the order of the lines (newest listed first)
    
    With the `fc -s [pat=rep ...] [command]' format, COMMAND is
    re-executed after the substitution OLD=NEW is performed.
    
    A useful alias to use with this is r='fc -s', so that typing `r cc'
    runs the last command beginning with `cc' and typing `r' re-executes
    the last command.
    
    The history builtin also operates on the history list.
    
    Exit Status:
    Returns success or status of executed command; non-zero if an error occurs.Display or manipulate the history list.
    
    Display the history list with line numbers, prefixing each modified
    entry with a `*'.  An argument of N lists only the last N entries.
    
    Options:
      -c	clear the history list by deleting all of the entries
      -d offset	delete the history entry at position OFFSET. Negative
    		offsets count back from the end of the history list
      -d start-end	delete the history entries beginning at position START
    		through position END.
    
      -a	append history lines from this session to the history file
      -n	read all history lines not already read from the history file
    		and append them to the history list
      -r	read the history file and append the contents to the history
    		list
      -w	write the current history to the history file
    
      -p	perform history expansion on each ARG and display the result
    		without storing it in the history list
      -s	append the ARGs to the history list as a single entry
    
    If FILENAME is given, it is used as the history file.  Otherwise,
    if HISTFILE has a value, that is used. If FILENAME is not supplied
    and HISTFILE is unset or null, the -a, -n, -r, and -w options have
    no effect and return success.
    
    The fc builtin also operates on the history list.
    
    If the HISTTIMEFORMAT variable is set and not null, its value is used
    as a format string for strftime(3) to print the time stamp associated
    with each displayed history entry.  No time stamps are printed otherwise.
    
    Exit Status:
    Returns success unless an invalid option is given or an error occurs.Display or set file mode mask.
    
    Sets the user file-creation mask to MODE.  If MODE is omitted, prints
    the current value of the mask.
    
    If MODE begins with a digit, it is interpreted as an octal number;
    otherwise it is a symbolic mode string like that accepted by chmod(1).
    
    Options:
      -p	if MODE is omitted, output in a form that may be reused as input
      -S	makes the output symbolic; otherwise an octal number is output
    
    Exit Status:
    Returns success unless MODE is invalid or an invalid option is given.Display possible completions depending on the options.
    
    Intended to be used from within a shell function generating possible
    completions.  If the optional WORD argument is present, generate matches
    against WORD.
    
    If the -V option is supplied, store the possible completions in the indexed
    array VARNAME instead of printing them to the standard output.
    
    Exit Status:
    Returns success unless an invalid option is supplied or an error occurs.Display process times.
    
    Prints the accumulated user and system times for the shell and all of its
    child processes.
    
    Exit Status:
    Always succeeds.Display status of jobs.
    
    Lists the active jobs.  JOBSPEC restricts output to that job.
    Without options, the status of all active jobs is displayed.
    
    Options:
      -l	lists process IDs in addition to the normal information
      -n	lists only processes that have changed status since the last
    		notification
      -p	lists process IDs only
      -r	restrict output to running jobs
      -s	restrict output to stopped jobs
    
    If -x is supplied, COMMAND is run after all job specifications that
    appear in ARGS have been replaced with the process ID of that job's
    process group leader.
    
    Exit Status:
    Returns success unless an invalid option is given or an error occurs.
    If -x is used, returns the exit status of COMMAND.Display the list of currently remembered directories.  Directories
    find their way onto the list with the `pushd' command; you can get
    back up through the list with the `popd' command.
    
    Options:
      -c	clear the directory stack by deleting all of the elements
      -l	do not print tilde-prefixed versions of directories relative
    	to your home directory
      -p	print the directory stack with one entry per line
      -v	print the directory stack with one entry per line prefixed
    	with its position in the stack
    
    Arguments:
      +N	Displays the Nth entry counting from the left of the list shown by
    	dirs when invoked without options, starting with zero.
    
      -N	Displays the Nth entry counting from the right of the list shown by
	dirs when invoked without options, starting with zero.DoneDone(%d)EMT instructionEnable and disable shell builtins.
    
    Enables and disables builtin shell commands.  Disabling allows you to
    execute a disk command which has the same name as a shell builtin
    without using a full pathname.
    
    Options:
      -a	print a list of builtins showing whether or not each is enabled
      -n	disable each NAME or display a list of disabled builtins
      -p	print the list of builtins in a reusable format
      -s	print only the names of Posix `special' builtins
    
    Options controlling dynamic loading:
      -f	Load builtin NAME from shared object FILENAME
      -d	Remove a builtin loaded with -f
    
    Without options, each NAME is enabled.
    
    On systems with dynamic loading, the shell variable BASH_LOADABLES_PATH
    defines a search path for the directory containing FILENAMEs that do
    not contain a slash. It may include "." to force a search of the current
    directory.
    
    To use the `test' found in $PATH instead of the shell builtin
    version, type `enable -n test'.
    
    Exit Status:
    Returns success unless NAME is not a shell builtin or an error occurs.Evaluate arithmetic expression.
    
    The EXPRESSION is evaluated according to the rules for arithmetic
    evaluation.  Equivalent to `let "EXPRESSION"'.
    
    Exit Status:
    Returns 1 if EXPRESSION evaluates to 0; returns 0 otherwise.Evaluate arithmetic expressions.
    
    Evaluate each ARG as an arithmetic expression.  Evaluation is done in
    fixed-width integers with no check for overflow, though division by 0
    is trapped and flagged as an error.  The following list of operators is
    grouped into levels of equal-precedence operators.  The levels are listed
    in order of decreasing precedence.
    
    	id++, id--	variable post-increment, post-decrement
    	++id, --id	variable pre-increment, pre-decrement
    	-, +		unary minus, plus
    	!, ~		logical and bitwise negation
    	**		exponentiation
    	*, /, %		multiplication, division, remainder
    	+, -		addition, subtraction
    	<<, >>		left and right bitwise shifts
    	<=, >=, <, >	comparison
    	==, !=		equality, inequality
    	&		bitwise AND
    	^		bitwise XOR
    	|		bitwise OR
    	&&		logical AND
    	||		logical OR
    	expr ? expr : expr
    			conditional operator
    	=, *=, /=, %=,
    	+=, -=, <<=, >>=,
    	&=, ^=, |=	assignment
    
    Shell variables are allowed as operands.  The name of the variable
    is replaced by its value (coerced to a fixed-width integer) within
    an expression.  The variable need not have its integer attribute
    turned on to be used in an expression.
    
    Operators are evaluated in order of precedence.  Sub-expressions in
    parentheses are evaluated first and may override the precedence
    rules above.
    
    Exit Status:
    If the last ARG evaluates to 0, let returns 1; let returns 0 otherwise.Evaluate conditional expression.
    
    Exits with a status of 0 (true) or 1 (false) depending on
    the evaluation of EXPR.  Expressions may be unary or binary.  Unary
    expressions are often used to examine the status of a file.  There
    are string operators and numeric comparison operators as well.
    
    The behavior of test depends on the number of arguments.  Read the
    bash manual page for the complete specification.
    
    File operators:
    
      -a FILE        True if file exists.
      -b FILE        True if file is block special.
      -c FILE        True if file is character special.
      -d FILE        True if file is a directory.
      -e FILE        True if file exists.
      -f FILE        True if file exists and is a regular file.
      -g FILE        True if file is set-group-id.
      -h FILE        True if file is a symbolic link.
      -L FILE        True if file is a symbolic link.
      -k FILE        True if file has its `sticky' bit set.
      -p FILE        True if file is a named pipe.
      -r FILE        True if file is readable by you.
      -s FILE        True if file exists and is not empty.
      -S FILE        True if file is a socket.
      -t FD          True if FD is opened on a terminal.
      -u FILE        True if the file is set-user-id.
      -w FILE        True if the file is writable by you.
      -x FILE        True if the file is executable by you.
      -O FILE        True if the file is effectively owned by you.
      -G FILE        True if the file is effectively owned by your group.
      -N FILE        True if the file has been modified since it was last read.
    
      FILE1 -nt FILE2  True if file1 is newer than file2 (according to
                       modification date).
    
      FILE1 -ot FILE2  True if file1 is older than file2.
    
      FILE1 -ef FILE2  True if file1 is a hard link to file2.
    
    String operators:
    
      -z STRING      True if string is empty.
    
      -n STRING
         STRING      True if string is not empty.
    
      STRING1 = STRING2
                     True if the strings are equal.
      STRING1 != STRING2
                     True if the strings are not equal.
      STRING1 < STRING2
                     True if STRING1 sorts before STRING2 lexicographically.
      STRING1 > STRING2
                     True if STRING1 sorts after STRING2 lexicographically.
    
    Other operators:
    
      -o OPTION      True if the shell option OPTION is enabled.
      -v VAR         True if the shell variable VAR is set.
      -R VAR         True if the shell variable VAR is set and is a name
                     reference.
      ! EXPR         True if expr is false.
      EXPR1 -a EXPR2 True if both expr1 AND expr2 are true.
      EXPR1 -o EXPR2 True if either expr1 OR expr2 is true.
    
      arg1 OP arg2   Arithmetic tests.  OP is one of -eq, -ne,
                     -lt, -le, -gt, or -ge.
    
    Arithmetic binary operators return true if ARG1 is equal, not-equal,
    less-than, less-than-or-equal, greater-than, or greater-than-or-equal
    than ARG2.
    
    Exit Status:
    Returns success if EXPR evaluates to true; fails if EXPR evaluates to
    false or an invalid argument is given.Evaluate conditional expression.
    
    This is a synonym for the "test" builtin, but the last argument must
    be a literal `]', to match the opening `['.Execute PIPELINE, which can be a simple command, and negate PIPELINE's
    return status.
    
    Exit Status:
    The logical negation of PIPELINE's return status.Execute a simple command or display information about commands.
    
    Runs COMMAND with ARGS suppressing  shell function lookup, or display
    information about the specified COMMANDs.  Can be used to invoke commands
    on disk when a function with the same name exists.
    
    Options:
      -p    use a default value for PATH that is guaranteed to find all of
            the standard utilities
      -v    print a single word indicating the command or filename that
            invokes COMMAND
      -V    print a more verbose description of each COMMAND
    
    Exit Status:
    Returns exit status of COMMAND, or failure if COMMAND is not found.Execute arguments as a shell command.
    
    Combine ARGs into a single string, use the result as input to the shell,
    and execute the resulting commands.
    
    Exit Status:
    Returns exit status of command or success if command is null.Execute commands as long as a test does not succeed.
    
    Expand and execute COMMANDS-2 as long as the final command in COMMANDS has
    an exit status which is not zero.
    
    Exit Status:
    Returns the status of the last command executed.Execute commands as long as a test succeeds.
    
    Expand and execute COMMANDS-2 as long as the final command in COMMANDS has
    an exit status of zero.
    
    Exit Status:
    Returns the status of the last command executed.Execute commands based on conditional.
    
    The `if COMMANDS' list is executed.  If its exit status is zero, then the
    `then COMMANDS' list is executed.  Otherwise, each `elif COMMANDS' list is
    executed in turn, and if its exit status is zero, the corresponding
    `then COMMANDS' list is executed and the if command completes.  Otherwise,
    the `else COMMANDS' list is executed, if present.  The exit status of the
    entire construct is the exit status of the last command executed, or zero
    if no condition tested true.
    
    Exit Status:
    Returns the status of the last command executed.Execute commands based on pattern matching.
    
    Selectively execute COMMANDS based upon WORD matching PATTERN.  The
    `|' is used to separate multiple patterns.
    
    Exit Status:
    Returns the status of the last command executed.Execute commands for each member in a list.
    
    The `for' loop executes a sequence of commands for each member in a
    list of items.  If `in WORDS ...;' is not present, then `in "$@"' is
    assumed.  For each element in WORDS, NAME is set to that element, and
    the COMMANDS are executed.
    
    Exit Status:
    Returns the status of the last command executed.Execute commands from a file in the current shell.
    
    Read and execute commands from FILENAME in the current shell. If the
    -p option is supplied, the PATH argument is treated as a colon-
    separated list of directories to search for FILENAME. If -p is not
    supplied, $PATH is searched to find FILENAME. If any ARGUMENTS are
    supplied, they become the positional parameters when FILENAME is executed.
    
    Exit Status:
    Returns the status of the last command executed in FILENAME; fails if
    FILENAME cannot be read.Execute conditional command.
    
    Returns a status of 0 or 1 depending on the evaluation of the conditional
    expression EXPRESSION.  Expressions are composed of the same primaries used
    by the `test' builtin, and may be combined using the following operators:
    
      ( EXPRESSION )	Returns the value of EXPRESSION
      ! EXPRESSION		True if EXPRESSION is false; else false
      EXPR1 && EXPR2	True if both EXPR1 and EXPR2 are true; else false
      EXPR1 || EXPR2	True if either EXPR1 or EXPR2 is true; else false
    
    When the `==' and `!=' operators are used, the string to the right of
    the operator is used as a pattern and pattern matching is performed.
    When the `=~' operator is used, the string to the right of the operator
    is matched as a regular expression.
    
    The && and || operators do not evaluate EXPR2 if EXPR1 is sufficient to
    determine the expression's value.
    
    Exit Status:
    0 or 1 depending on value of EXPRESSION.Execute shell builtins.
    
    Execute SHELL-BUILTIN with arguments ARGs without performing command
    lookup.  This is useful when you wish to reimplement a shell builtin
    as a shell function, but need to execute the builtin within the function.
    
    Exit Status:
    Returns the exit status of SHELL-BUILTIN, or false if SHELL-BUILTIN is
    not a shell builtin.Exit %dExit a login shell.
    
    Exits a login shell with exit status N.  Returns an error if not executed
    in a login shell.Exit for, while, or until loops.
    
    Exit a FOR, WHILE or UNTIL loop.  If N is specified, break N enclosing
    loops.
    
    Exit Status:
    The exit status is 0 unless N is not greater than or equal to 1.Exit the shell.
    
    Exits the shell with a status of N.  If N is omitted, the exit status
    is that of the last command executed.File limitFloating point exceptionFormats and prints ARGUMENTS under control of the FORMAT.
    
    Options:
      -v var	assign the output to shell variable VAR rather than
    		display it on the standard output
    
    FORMAT is a character string which contains three types of objects: plain
    characters, which are simply copied to standard output; character escape
    sequences, which are converted and copied to the standard output; and
    format specifications, each of which causes printing of the next successive
    argument.
    
    In addition to the standard format characters csndiouxXeEfFgGaA described
    in printf(3), printf interprets:
    
      %b	expand backslash escape sequences in the corresponding argument
      %q	quote the argument in a way that can be reused as shell input
      %Q	like %q, but apply any precision to the unquoted argument before
    		quoting
      %(fmt)T	output the date-time string resulting from using FMT as a format
    	        string for strftime(3)
    
    The format is re-used as necessary to consume all of the arguments.  If
    there are fewer arguments than the format requires,  extra format
    specifications behave as if a zero value or null string, as appropriate,
    had been supplied.
    
    Exit Status:
    Returns success unless an invalid option is given or a write or assignment
    error occurs.GNU bash, version %s (%s)
GNU bash, version %s-(%s)
GNU long options:
General help using GNU software: <http://www.gnu.org/gethelp/>
Group commands as a unit.
    
    Run a set of commands in a group.  This is one way to redirect an
    entire set of commands.
    
    Exit Status:
    Returns the status of the last command executed.HFT input data pendingHFT monitor mode grantedHFT monitor mode retractedHFT sound sequence has completedHOME not setHangupI have no name!I/O readyINFORM: Illegal instructionInformation requestInterruptKilledLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
Mark shell variables as unchangeable.
    
    Mark each NAME as read-only; the values of these NAMEs may not be
    changed by subsequent assignment.  If VALUE is supplied, assign VALUE
    before marking as read-only.
    
    Options:
      -a	refer to indexed array variables
      -A	refer to associative array variables
      -f	refer to shell functions
      -p	display a list of all readonly variables or functions,
    		depending on whether or not the -f option is given
    
    An argument of `--' disables further option processing.
    
    Exit Status:
    Returns success unless an invalid option is given or NAME is invalid.Modify or display completion options.
    
    Modify the completion options for each NAME, or, if no NAMEs are supplied,
    the completion currently being executed.  If no OPTIONs are given, print
    the completion options for each NAME or the current completion specification.
    
    Options:
    	-o option	Set completion option OPTION for each NAME
    	-D		Change options for the "default" command completion
    	-E		Change options for the "empty" command completion
    	-I		Change options for completion on the initial word
    
    Using `+o' instead of `-o' turns off the specified option.
    
    Arguments:
    
    Each NAME refers to a command for which a completion specification must
    have previously been defined using the `complete' builtin.  If no NAMEs
    are supplied, compopt must be called by a function currently generating
    completions, and the options for that currently-executing completion
    generator are modified.
    
    Exit Status:
    Returns success unless an invalid option is supplied or NAME does not
    have a completion specification defined.Modify shell resource limits.
    
    Provides control over the resources available to the shell and processes
    it creates, on systems that allow such control.
    
    Options:
      -S	use the `soft' resource limit
      -H	use the `hard' resource limit
      -a	all current limits are reported
      -b	the socket buffer size
      -c	the maximum size of core files created
      -d	the maximum size of a process's data segment
      -e	the maximum scheduling priority (`nice')
      -f	the maximum size of files written by the shell and its children
      -i	the maximum number of pending signals
      -k	the maximum number of kqueues allocated for this process
      -l	the maximum size a process may lock into memory
      -m	the maximum resident set size
      -n	the maximum number of open file descriptors
      -p	the pipe buffer size
      -q	the maximum number of bytes in POSIX message queues
      -r	the maximum real-time scheduling priority
      -s	the maximum stack size
      -t	the maximum amount of cpu time in seconds
      -u	the maximum number of user processes
      -v	the size of virtual memory
      -x	the maximum number of file locks
      -P	the maximum number of pseudoterminals
      -R	the maximum time a real-time process can run before blocking
      -T	the maximum number of threads
    
    Not all options are available on all platforms.
    
    If LIMIT is given, it is the new value of the specified resource; the
    special LIMIT values `soft', `hard', and `unlimited' stand for the
    current soft limit, the current hard limit, and no limit, respectively.
    Otherwise, the current value of the specified resource is printed.  If
    no option is given, then -f is assumed.
    
    Values are in 1024-byte increments, except for -t, which is in seconds;
    -p, which is in increments of 512 bytes; -R, which is in microseconds;
    -b, which is in bytes; and -e, -i, -k, -n, -q, -r, -u, -x, and -P,
    which accept unscaled values.
    
    When in posix mode, values supplied with -c and -f are in 512-byte
    increments.
    
    Exit Status:
    Returns success unless an invalid option is supplied or an error occurs.Move job to the foreground.
    
    Place the job identified by JOB_SPEC in the foreground, making it the
    current job.  If JOB_SPEC is not present, the shell's notion of the
    current job is used.
    
    Exit Status:
    Status of command placed in foreground, or failure if an error occurs.Move jobs to the background.
    
    Place the jobs identified by each JOB_SPEC in the background, as if they
    had been started with `&'.  If JOB_SPEC is not present, the shell's notion
    of the current job is used.
    
    Exit Status:
    Returns success unless job control is not enabled or an error occurs.Null command.
    
    No effect; the command does nothing.
    
    Exit Status:
    Always succeeds.OLDPWD not setParse option arguments.
    
    Getopts is used by shell procedures to parse positional parameters
    as options.
    
    OPTSTRING contains the option letters to be recognized; if a letter
    is followed by a colon, the option is expected to have an argument,
    which should be separated from it by white space.
    
    Each time it is invoked, getopts will place the next option in the
    shell variable $name, initializing name if it does not exist, and
    the index of the next argument to be processed into the shell
    variable OPTIND.  OPTIND is initialized to 1 each time the shell or
    a shell script is invoked.  When an option requires an argument,
    getopts places that argument into the shell variable OPTARG.
    
    getopts reports errors in one of two ways.  If the first character
    of OPTSTRING is a colon, getopts uses silent error reporting.  In
    this mode, no error messages are printed.  If an invalid option is
    seen, getopts places the option character found into OPTARG.  If a
    required argument is not found, getopts places a ':' into NAME and
    sets OPTARG to the option character found.  If getopts is not in
    silent mode, and an invalid option is seen, getopts places '?' into
    NAME and unsets OPTARG.  If a required argument is not found, a '?'
    is placed in NAME, OPTARG is unset, and a diagnostic message is
    printed.
    
    If the shell variable OPTERR has the value 0, getopts disables the
    printing of error messages, even if the first character of
    OPTSTRING is not a colon.  OPTERR has the value 1 by default.
    
    Getopts normally parses the positional parameters, but if arguments
    are supplied as ARG values, they are parsed instead.
    
    Exit Status:
    Returns success if an option is found; fails if the end of options is
    encountered or an error occurs.Print the name of the current working directory.
    
    Options:
      -L	print the value of $PWD if it names the current working
    		directory
      -P	print the physical directory, without any symbolic links
    
    By default, `pwd' behaves as if `-L' were specified.
    
    Exit Status:
    Returns 0 unless an invalid option is given or the current directory
    cannot be read.QuitRead a line from the standard input and split it into fields.
    
    Reads a single line from the standard input, or from file descriptor FD
    if the -u option is supplied.  The line is split into fields as with word
    splitting, and the first word is assigned to the first NAME, the second
    word to the second NAME, and so on, with any leftover words assigned to
    the last NAME.  Only the characters found in $IFS are recognized as word
    delimiters. By default, the backslash character escapes delimiter characters
    and newline.
    
    If no NAMEs are supplied, the line read is stored in the REPLY variable.
    
    Options:
      -a array	assign the words read to sequential indices of the array
    		variable ARRAY, starting at zero
      -d delim	continue until the first character of DELIM is read, rather
    		than newline
      -e	use Readline to obtain the line
      -E	use Readline to obtain the line and use the bash default
    		completion instead of Readline's default completion
      -i text	use TEXT as the initial text for Readline
      -n nchars	return after reading NCHARS characters rather than waiting
    		for a newline, but honor a delimiter if fewer than
    		NCHARS characters are read before the delimiter
      -N nchars	return only after reading exactly NCHARS characters, unless
    		EOF is encountered or read times out, ignoring any
    		delimiter
      -p prompt	output the string PROMPT without a trailing newline before
    		attempting to read
      -r	do not allow backslashes to escape any characters
      -s	do not echo input coming from a terminal
      -t timeout	time out and return failure if a complete line of
    		input is not read within TIMEOUT seconds.  The value of the
    		TMOUT variable is the default timeout.  TIMEOUT may be a
    		fractional number.  If TIMEOUT is 0, read returns
    		immediately, without trying to read any data, returning
    		success only if input is available on the specified
    		file descriptor.  The exit status is greater than 128
    		if the timeout is exceeded
      -u fd	read from file descriptor FD instead of the standard input
    
    Exit Status:
    The return code is zero, unless end-of-file is encountered, read times out
    (in which case it's greater than 128), a variable assignment error occurs,
    or an invalid file descriptor is supplied as the argument to -u.Read lines from a file into an array variable.
    
    A synonym for `mapfile'.Read lines from the standard input into an indexed array variable.
    
    Read lines from the standard input into the indexed array variable ARRAY, or
    from file descriptor FD if the -u option is supplied.  The variable MAPFILE
    is the default ARRAY.
    
    Options:
      -d delim	Use DELIM to terminate lines, instead of newline
      -n count	Copy at most COUNT lines.  If COUNT is 0, all lines are copied
      -O origin	Begin assigning to ARRAY at index ORIGIN.  The default index is 0
      -s count	Discard the first COUNT lines read
      -t	Remove a trailing DELIM from each line read (default newline)
      -u fd	Read lines from file descriptor FD instead of the standard input
      -C callback	Evaluate CALLBACK each time QUANTUM lines are read
      -c quantum	Specify the number of lines read between each call to
    			CALLBACK
    
    Arguments:
      ARRAY	Array variable name to use for file data
    
    If -C is supplied without -c, the default quantum is 5000.  When
    CALLBACK is evaluated, it is supplied the index of the next array
    element to be assigned and the line to be assigned to that element
    as additional arguments.
    
    If not supplied with an explicit origin, mapfile will clear ARRAY before
    assigning to it.
    
    Exit Status:
    Returns success unless an invalid option is given or ARRAY is readonly or
    not an indexed array.Record lockRemember or display program locations.
    
    Determine and remember the full pathname of each command NAME.  If
    no arguments are given, information about remembered commands is displayed.
    
    Options:
      -d	forget the remembered location of each NAME
      -l	display in a format that may be reused as input
      -p pathname	use PATHNAME as the full pathname of NAME
      -r	forget all remembered locations
      -t	print the remembered location of each NAME, preceding
    		each location with the corresponding NAME if multiple
    		NAMEs are given
    Arguments:
      NAME	Each NAME is searched for in $PATH and added to the list
    		of remembered commands.
    
    Exit Status:
    Returns success unless NAME is not found or an invalid option is given.Remove directories from stack.
    
    Removes entries from the directory stack.  With no arguments, removes
    the top directory from the stack, and changes to the new top directory.
    
    Options:
      -n	Suppresses the normal change of directory when removing
    		directories from the stack, so only the stack is manipulated.
    
    Arguments:
      +N	Removes the Nth entry counting from the left of the list
    		shown by `dirs', starting with zero.  For example: `popd +0'
    		removes the first directory, `popd +1' the second.
    
      -N	Removes the Nth entry counting from the right of the list
    		shown by `dirs', starting with zero.  For example: `popd -0'
    		removes the last directory, `popd -1' the next to last.
    
    The `dirs' builtin displays the directory stack.
    
    Exit Status:
    Returns success unless an invalid argument is supplied or the directory
    change fails.Remove each NAME from the list of defined aliases.
    
    Options:
      -a	remove all alias definitions
    
    Return success unless a NAME is not an existing alias.Remove jobs from current shell.
    
    Removes each JOBSPEC argument from the table of active jobs.  Without
    any JOBSPECs, the shell uses its notion of the current job.
    
    Options:
      -a	remove all jobs if JOBSPEC is not supplied
      -h	mark each JOBSPEC so that SIGHUP is not sent to the job if the
    		shell receives a SIGHUP
      -r	remove only running jobs
    
    Exit Status:
    Returns success unless an invalid option or JOBSPEC is given.Removes entries from the directory stack.  With no arguments, removes
    the top directory from the stack, and changes to the new top directory.
    
    Options:
      -n	Suppresses the normal change of directory when removing
    	directories from the stack, so only the stack is manipulated.
    
    Arguments:
      +N	Removes the Nth entry counting from the left of the list
    	shown by `dirs', starting with zero.  For example: `popd +0'
    	removes the first directory, `popd +1' the second.
    
      -N	Removes the Nth entry counting from the right of the list
    	shown by `dirs', starting with zero.  For example: `popd -0'
    	removes the last directory, `popd -1' the next to last.
    
    The `dirs' builtin displays the directory stack.Replace the shell with the given command.
    
    Execute COMMAND, replacing this shell with the specified program.
    ARGUMENTS become the arguments to COMMAND.  If COMMAND is not specified,
    any redirections take effect in the current shell.
    
    Options:
      -a name	pass NAME as the zeroth argument to COMMAND
      -c	execute COMMAND with an empty environment
      -l	place a dash in the zeroth argument to COMMAND
    
    If the command cannot be executed, a non-interactive shell exits, unless
    the shell option `execfail' is set.
    
    Exit Status:
    Returns success unless COMMAND is not found or a redirection error occurs.Report time consumed by pipeline's execution.
    
    Execute PIPELINE and print a summary of the real time, user CPU time,
    and system CPU time spent executing PIPELINE when it terminates.
    
    Options:
      -p	print the timing summary in the portable Posix format
    
    The value of the TIMEFORMAT variable is used as the output format.
    
    Exit Status:
    The return status is the return status of PIPELINE.Resume for, while, or until loops.
    
    Resumes the next iteration of the enclosing FOR, WHILE or UNTIL loop.
    If N is specified, resumes the Nth enclosing loop.
    
    Exit Status:
    The exit status is 0 unless N is not greater than or equal to 1.Resume job in foreground.
    
    Equivalent to the JOB_SPEC argument to the `fg' command.  Resume a
    stopped or background job.  JOB_SPEC can specify either a job name
    or a job number.  Following JOB_SPEC with a `&' places the job in
    the background, as if the job specification had been supplied as an
    argument to `bg'.
    
    Exit Status:
    Returns the status of the resumed job.Return a successful result.
    
    Exit Status:
    Always succeeds.Return an unsuccessful result.
    
    Exit Status:
    Always fails.Return from a shell function.
    
    Causes a function or sourced script to exit with the return value
    specified by N.  If N is omitted, the return status is that of the
    last command executed within the function or script.
    
    Exit Status:
    Returns N, or failure if the shell is not executing a function or script.Return the context of the current subroutine call.
    
    Without EXPR, returns "$line $filename".  With EXPR, returns
    "$line $subroutine $filename"; this extra information can be used to
    provide a stack trace.
    
    The value of EXPR indicates how many call frames to go back before the
    current one; the top frame is frame 0.
    
    Exit Status:
    Returns 0 unless the shell is not executing a shell function or EXPR
    is invalid.Returns the context of the current subroutine call.
    
    Without EXPR, returns "$line $filename".  With EXPR, returns
    "$line $subroutine $filename"; this extra information can be used to
    provide a stack trace.
    
    The value of EXPR indicates how many call frames to go back before the
    current one; the top frame is frame 0.
    
    Exit Status:
    Returns 0 unless the shell is not executing a shell function or EXPR
    is invalid.RunningSegmentation faultSelect words from a list and execute commands.
    
    The WORDS are expanded, generating a list of words.  The
    set of expanded words is printed on the standard error, each
    preceded by a number.  If `in WORDS' is not present, `in "$@"'
    is assumed.  The PS3 prompt is then displayed and a line read
    from the standard input.  If the line consists of the number
    corresponding to one of the displayed words, then NAME is set
    to that word.  If the line is empty, WORDS and the prompt are
    redisplayed.  If EOF is read, the command completes.  Any other
    value read causes NAME to be set to null.  The line read is saved
    in the variable REPLY.  COMMANDS are executed after each selection
    until a break command is executed.
    
    Exit Status:
    Returns the status of the last command executed.Send a signal to a job.
    
    Send the processes identified by PID or JOBSPEC the signal named by
    SIGSPEC or SIGNUM.  If neither SIGSPEC nor SIGNUM is present, then
    SIGTERM is assumed.
    
    Options:
      -s sig	SIG is a signal name
      -n sig	SIG is a signal number
      -l	list the signal names; if arguments follow `-l' they are
    		assumed to be signal numbers for which names should be listed
      -L	synonym for -l
    
    Kill is a shell builtin for two reasons: it allows job IDs to be used
    instead of process IDs, and allows processes to be killed if the limit
    on processes that you can create is reached.
    
    Exit Status:
    Returns success unless an invalid option is given or an error occurs.Set Readline key bindings and variables.
    
    Bind a key sequence to a Readline function or a macro, or set a
    Readline variable.  The non-option argument syntax is equivalent to
    that found in ~/.inputrc, but must be passed as a single argument:
    e.g., bind '"\C-x\C-r": re-read-init-file'.
    
    Options:
      -m  keymap         Use KEYMAP as the keymap for the duration of this
                         command.  Acceptable keymap names are emacs,
                         emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,
                         vi-command, and vi-insert.
      -l                 List names of functions.
      -P                 List function names and bindings.
      -p                 List functions and bindings in a form that can be
                         reused as input.
      -S                 List key sequences that invoke macros and their values
      -s                 List key sequences that invoke macros and their values
                         in a form that can be reused as input.
      -V                 List variable names and values
      -v                 List variable names and values in a form that can
                         be reused as input.
      -q  function-name  Query about which keys invoke the named function.
      -u  function-name  Unbind all keys which are bound to the named function.
      -r  keyseq         Remove the binding for KEYSEQ.
      -f  filename       Read key bindings from FILENAME.
      -x  keyseq:shell-command	Cause SHELL-COMMAND to be executed when
    				KEYSEQ is entered.
      -X                 List key sequences bound with -x and associated commands
                         in a form that can be reused as input.
    
    If arguments remain after option processing, the -p and -P options treat
    them as readline command names and restrict output to those names.
    
    Exit Status:
    bind returns 0 unless an unrecognized option is given or an error occurs.Set and unset shell options.
    
    Change the setting of each shell option OPTNAME.  Without any option
    arguments, list each supplied OPTNAME, or all shell options if no
    OPTNAMEs are given, with an indication of whether or not each is set.
    
    Options:
      -o	restrict OPTNAMEs to those defined for use with `set -o'
      -p	print each shell option with an indication of its status
      -q	suppress output
      -s	enable (set) each OPTNAME
      -u	disable (unset) each OPTNAME
    
    Exit Status:
    Returns success if OPTNAME is enabled; fails if an invalid option is
    given or OPTNAME is disabled.Set export attribute for shell variables.
    
    Marks each NAME for automatic export to the environment of subsequently
    executed commands.  If VALUE is supplied, assign VALUE before exporting.
    
    Options:
      -f	refer to shell functions
      -n	remove the export property from each NAME
      -p	display a list of all exported variables or functions
    
    An argument of `--' disables further option processing.
    
    Exit Status:
    Returns success unless an invalid option is given or NAME is invalid.Set or unset values of shell options and positional parameters.
    
    Change the value of shell attributes and positional parameters, or
    display the names and values of shell variables.
    
    Options:
      -a  Mark variables which are modified or created for export.
      -b  Notify of job termination immediately.
      -e  Exit immediately if a command exits with a non-zero status.
      -f  Disable file name generation (globbing).
      -h  Remember the location of commands as they are looked up.
      -k  All assignment arguments are placed in the environment for a
          command, not just those that precede the command name.
      -m  Job control is enabled.
      -n  Read commands but do not execute them.
      -o option-name
          Set the variable corresponding to option-name:
              allexport    same as -a
              braceexpand  same as -B
              emacs        use an emacs-style line editing interface
              errexit      same as -e
              errtrace     same as -E
              functrace    same as -T
              hashall      same as -h
              histexpand   same as -H
              history      enable command history
              ignoreeof    the shell will not exit upon reading EOF
              interactive-comments
                           allow comments to appear in interactive commands
              keyword      same as -k
              monitor      same as -m
              noclobber    same as -C
              noexec       same as -n
              noglob       same as -f
              nolog        currently accepted but ignored
              notify       same as -b
              nounset      same as -u
              onecmd       same as -t
              physical     same as -P
              pipefail     the return value of a pipeline is the status of
                           the last command to exit with a non-zero status,
                           or zero if no command exited with a non-zero status
              posix        change the behavior of bash where the default
                           operation differs from the Posix standard to
                           match the standard
              privileged   same as -p
              verbose      same as -v
              vi           use a vi-style line editing interface
              xtrace       same as -x
      -p  Turned on whenever the real and effective user ids do not match.
          Disables processing of the $ENV file and importing of shell
          functions.  Turning this option off causes the effective uid and
          gid to be set to the real uid and gid.
      -t  Exit after reading and executing one command.
      -u  Treat unset variables as an error when substituting.
      -v  Print shell input lines as they are read.
      -x  Print commands and their arguments as they are executed.
      -B  the shell will perform brace expansion
      -C  If set, disallow existing regular files to be overwritten
          by redirection of output.
      -E  If set, the ERR trap is inherited by shell functions.
      -H  Enable ! style history substitution.  This flag is on
          by default when the shell is interactive.
      -P  If set, do not resolve symbolic links when executing commands
          such as cd which change the current directory.
      -T  If set, the DEBUG and RETURN traps are inherited by shell functions.
      --  Assign any remaining arguments to the positional parameters.
          If there are no remaining arguments, the positional parameters
          are unset.
      -   Assign any remaining arguments to the positional parameters.
          The -x and -v options are turned off.
    
    If -o is supplied with no option-name, set prints the current shell
    option settings. If +o is supplied with no option-name, set prints a
    series of set commands to recreate the current option settings.
    
    Using + rather than - causes these flags to be turned off.  The
    flags can also be used upon invocation of the shell.  The current
    set of flags may be found in $-.  The remaining n ARGs are positional
    parameters and are assigned, in order, to $1, $2, .. $n.  If no
    ARGs are given, all shell variables are printed.
    
    Exit Status:
    Returns success unless an invalid option is given.Set variable values and attributes.
    
    A synonym for `declare'.  See `help declare'.Set variable values and attributes.
    
    Declare variables and give them attributes.  If no NAMEs are given,
    display the attributes and values of all variables.
    
    Options:
      -f	restrict action or display to function names and definitions
      -F	restrict display to function names only (plus line number and
    		source file when debugging)
      -g	create global variables when used in a shell function; otherwise
    		ignored
      -I	if creating a local variable, inherit the attributes and value
    		of a variable with the same name at a previous scope
      -p	display the attributes and value of each NAME
    
    Options which set attributes:
      -a	to make NAMEs indexed arrays (if supported)
      -A	to make NAMEs associative arrays (if supported)
      -i	to make NAMEs have the `integer' attribute
      -l	to convert the value of each NAME to lower case on assignment
      -n	make NAME a reference to the variable named by its value
      -r	to make NAMEs readonly
      -t	to make NAMEs have the `trace' attribute
      -u	to convert the value of each NAME to upper case on assignment
      -x	to make NAMEs export
    
    Using `+' instead of `-' turns off the given attribute, except for a,
    A, and r.
    
    Variables with the integer attribute have arithmetic evaluation (see
    the `let' command) performed when the variable is assigned a value.
    
    When used in a function, `declare' makes NAMEs local, as with the `local'
    command.  The `-g' option suppresses this behavior.
    
    Exit Status:
    Returns success unless an invalid option is supplied or a variable
    assignment error occurs.Shell commands matching keyword `Shell commands matching keywords `Shell options:
Shift positional parameters.
    
    Rename the positional parameters $N+1,$N+2 ... to $1,$2 ...  If N is
    not given, it is assumed to be 1.
    
    Exit Status:
    Returns success unless N is negative or greater than $#.Signal %dSpecify how arguments are to be completed by Readline.
    
    For each NAME, specify how arguments are to be completed.  If no options
    or NAMEs are supplied, display existing completion specifications in a way
    that allows them to be reused as input.
    
    Options:
      -p	print existing completion specifications in a reusable format
      -r	remove a completion specification for each NAME, or, if no
    		NAMEs are supplied, all completion specifications
      -D	apply the completions and actions as the default for commands
    		without any specific completion defined
      -E	apply the completions and actions to "empty" commands --
    		completion attempted on a blank line
      -I	apply the completions and actions to the initial (usually the
    		command) word
    
    When completion is attempted, the actions are applied in the order the
    uppercase-letter options are listed above. If multiple options are supplied,
    the -D option takes precedence over -E, and both take precedence over -I.
    
    Exit Status:
    Returns success unless an invalid option is supplied or an error occurs.StoppedStopped (signal)Stopped (tty input)Stopped (tty output)Stopped(%s)Suspend shell execution.
    
    Suspend the execution of this shell until it receives a SIGCONT signal.
    Unless forced, login shells and shells without job control cannot be
    suspended.
    
    Options:
      -f	force the suspend, even if the shell is a login shell or job
    		control is not enabled.
    
    Exit Status:
    Returns success unless job control is not enabled or an error occurs.TIMEFORMAT: `%c': invalid format characterTerminatedThe mail in %s has been read
There are running jobs.
There are stopped jobs.
There is NO WARRANTY, to the extent permitted by law.These shell commands are defined internally.  Type `help' to see this list.
Type `help name' to find out more about the function `name'.
Use `info bash' to find out more about the shell in general.
Use `man -k' or `info' to find out more about commands not in this list.

A star (*) next to a name means that the command is disabled.

This is free software; you are free to change and redistribute it.Trap signals and other events.
    
    Defines and activates handlers to be run when the shell receives signals
    or other conditions.
    
    ACTION is a command to be read and executed when the shell receives the
    signal(s) SIGNAL_SPEC.  If ACTION is absent (and a single SIGNAL_SPEC
    is supplied) or `-', each specified signal is reset to its original
    value.  If ACTION is the null string each SIGNAL_SPEC is ignored by the
    shell and by the commands it invokes.
    
    If a SIGNAL_SPEC is EXIT (0) ACTION is executed on exit from the shell.
    If a SIGNAL_SPEC is DEBUG, ACTION is executed before every simple command
    and selected other commands. If a SIGNAL_SPEC is RETURN, ACTION is
    executed each time a shell function or a script run by the . or source
    builtins finishes executing.  A SIGNAL_SPEC of ERR means to execute ACTION
    each time a command's failure would cause the shell to exit when the -e
    option is enabled.
    
    If no arguments are supplied, trap prints the list of commands associated
    with each trapped signal in a form that may be reused as shell input to
    restore the same signal dispositions.
    
    Options:
      -l	print a list of signal names and their corresponding numbers
      -p	display the trap commands associated with each SIGNAL_SPEC in a
    		form that may be reused as shell input; or for all trapped
    		signals if no arguments are supplied
      -P	display the trap commands associated with each SIGNAL_SPEC. At least
    		one SIGNAL_SPEC must be supplied. -P and -p cannot be used
    		together.
    
    Each SIGNAL_SPEC is either a signal name in <signal.h> or a signal number.
    Signal names are case insensitive and the SIG prefix is optional.  A
    signal may be sent to the shell with "kill -signal $$".
    
    Exit Status:
    Returns success unless a SIGSPEC is invalid or an invalid option is given.Type `%s -c "help set"' for more information about shell options.
Type `%s -c help' for more information about shell builtin commands.
Unknown Signal #%dUnknown errorUnknown statusUnset values and attributes of shell variables and functions.
    
    For each NAME, remove the corresponding variable or function.
    
    Options:
      -f	treat each NAME as a shell function
      -v	treat each NAME as a shell variable
      -n	treat each NAME as a name reference and unset the variable itself
    		rather than the variable it references
    
    Without options, unset first tries to unset a variable, and if that fails,
    tries to unset a function.
    
    Some variables cannot be unset; also see `readonly'.
    
    Exit Status:
    Returns success unless an invalid option is given or a NAME is read-only.Urgent IO conditionUsage:	%s [GNU long option] [option] ...
	%s [GNU long option] [option] script-file ...
Use "%s" to leave the shell.
Use the `bashbug' command to report bugs.
User signal 1User signal 2Wait for job completion and return exit status.
    
    Waits for each process identified by an ID, which may be a process ID or a
    job specification, and reports its termination status.  If ID is not
    given, waits for all currently active child processes, and the return
    status is zero.  If ID is a job specification, waits for all processes
    in that job's pipeline.
    
    If the -n option is supplied, waits for a single job from the list of IDs,
    or, if no IDs are supplied, for the next job to complete and returns its
    exit status.
    
    If the -p option is supplied, the process or job identifier of the job
    for which the exit status is returned is assigned to the variable VAR
    named by the option argument. The variable will be unset initially, before
    any assignment. This is useful only when the -n option is supplied.
    
    If the -f option is supplied, and job control is enabled, waits for the
    specified ID to terminate, instead of waiting for it to change status.
    
    Exit Status:
    Returns the status of the last ID; fails if ID is invalid or an invalid
    option is given, or if -n is supplied and the shell has no unwaited-for
    children.Wait for process completion and return exit status.
    
    Waits for each process specified by a PID and reports its termination status.
    If PID is not given, waits for all currently active child processes,
    and the return status is zero.  PID must be a process ID.
    
    Exit Status:
    Returns the status of the last PID; fails if PID is invalid or an invalid
    option is given.Window changedWrite arguments to the standard output.
    
    Display the ARGs on the standard output followed by a newline.
    
    Options:
      -n	do not append a newline
    
    Exit Status:
    Returns success unless a write error occurs.Write arguments to the standard output.
    
    Display the ARGs, separated by a single space character and followed by a
    newline, on the standard output.
    
    Options:
      -n	do not append a newline
      -e	enable interpretation of the following backslash escapes
      -E	explicitly suppress interpretation of backslash escapes
    
    `echo' interprets the following backslash-escaped characters:
      \a	alert (bell)
      \b	backspace
      \c	suppress further output
      \e	escape character
      \E	escape character
      \f	form feed
      \n	new line
      \r	carriage return
      \t	horizontal tab
      \v	vertical tab
      \\	backslash
      \0nnn	the character whose ASCII code is NNN (octal).  NNN can be
    		0 to 3 octal digits
      \xHH	the eight-bit character whose value is HH (hexadecimal).  HH
    		can be one or two hex digits
      \uHHHH	the Unicode character whose value is the hexadecimal value HHHH.
    		HHHH can be one to four hex digits.
      \UHHHHHHHH the Unicode character whose value is the hexadecimal value
    		HHHHHHHH. HHHHHHHH can be one to eight hex digits.
    
    Exit Status:
    Returns success unless a write error occurs.You have mail in $_You have new mail in $_[ arg... ][[ expression ]]`%c': bad command`%c': invalid format character`%c': invalid symbolic mode character`%c': invalid symbolic mode operator`%c': invalid time format specification`%s': cannot unbind`%s': cannot unbind in command keymap`%s': invalid alias name`%s': invalid keymap name`%s': invalid variable name for name reference`%s': is a special builtin`%s': missing format character`%s': not a pid or valid job spec`%s': not a valid identifier`%s': unknown function name`)' expected`)' expected, found %s`:' expected for conditional expressionadd_process: pid %5ld (%s) marked as still alivealias [-p] [name[=value] ... ]all_local_variables: no function context at current scopeambiguous redirectargumentargument expectedarithmetic syntax error in expressionarithmetic syntax error in variable assignmentarithmetic syntax error: invalid arithmetic operatorarithmetic syntax error: operand expectedarray variable support requiredattempted assignment to non-variablebad array subscriptbad command typebad connectorbad interpreterbad jumpbad substitution: no closing "`" in %sbad substitution: no closing `%s' in %sbash home page: <http://www.gnu.org/software/bash>
bash_execute_unix_command: cannot find keymap for commandbg [job_spec ...]bgp_delete: LOOP: psi (%d) == storage[psi].bucket_nextbgp_search: LOOP: psi (%d) == storage[psi].bucket_nextbind [-lpsvPSVX] [-m keymap] [-f filename] [-q name] [-u name] [-r keyseq] [-x keyseq:shell-command] [keyseq:readline-function or readline-command]brace expansion: cannot allocate memory for %sbrace expansion: failed to allocate memory for %s elementsbrace expansion: failed to allocate memory for `%s'break [n]bug: bad expassign tokenbuiltin [shell-builtin [arg ...]]caller [expr]can only `return' from a function or sourced scriptcan only be used in a functioncannot allocate new file descriptor for bash input from fd %dcannot assign fd to variablecannot change localecannot createcannot create temp file for here-documentcannot duplicate fd %d to fd %dcannot duplicate named pipe %s as fd %dcannot executecannot execute binary filecannot find %s in shared object %s: %scannot get limitcannot make child for command substitutioncannot make child for process substitutioncannot make pipe for command substitutioncannot make pipe for process substitutioncannot modify limitcannot opencannot open named pipe %s for readingcannot open named pipe %s for writingcannot open shared object %s: %scannot open temp filecannot overwrite existing filecannot readcannot redirect standard input from /dev/nullcannot reset nodelay mode for fd %dcannot set and unset shell options simultaneouslycannot set gid to %d: effective gid %dcannot set terminal process group (%d)cannot set uid to %d: effective uid %dcannot simultaneously unset a function and a variablecannot start debugger; debugging mode disabledcannot suspendcannot suspend a login shellcannot use `-f' to make functionscannot use more than one of -anrwcase WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esaccd [-L|[-P [-e]]] [-@] [dir]child setpgid (%ld to %ld)command [-pVv] command [arg ...]command not foundcommand substitution: ignored null byte in inputcommand_substitute: cannot duplicate pipe as fd 1compgen [-V varname] [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [word]complete [-abcdefgjksuv] [-pr] [-DEI] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [name ...]completion: function `%s' not foundcompopt [-o|+o option] [-DEI] [name ...]conditional binary operator expectedcontinue [n]coproc [NAME] command [redirections]could not find /tmp, please create!cprintf: `%c': invalid format charactercurrentdeclare [-aAfFgiIlnrtux] [name[=value] ...] or declare -p [-aAfFilnrtux] [name ...]deleting stopped job %d with process group %lddescribe_pid: %ld: no such piddirectory stack emptydirectory stack indexdirs [-clpv] [+N] [-N]disown [-h] [-ar] [jobspec ... | pid ...]division by 0dynamic loading not availableecho [-n] [arg ...]echo [-neE] [arg ...]empty array variable nameempty filenameenable [-a] [-dnps] [-f filename] [name ...]error creating buffered streamerror getting terminal attributeserror importing function definition for `%s'error retrieving current directoryerror setting terminal attributeseval [arg ...]eval: maximum eval nesting level exceeded (%d)exec [-cl] [-a name] [command [argument ...]] [redirection ...]execute_coproc: coproc [%d:%s] still existsexit [n]expected `)'exponent less than 0export [-fn] [name[=value] ...] or export -p [-f]expression expectedexpression recursion level exceededfc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [command]fg [job_spec]file descriptor out of rangefilename argument requiredfor (( exp1; exp2; exp3 )); do COMMANDS; donefor NAME [in WORDS ... ] ; do COMMANDS; doneforked pid %d appears in running job %dformat parsing problem: %sframe not foundfree: called with already freed block argumentfree: called with unallocated block argumentfree: start and end chunk sizes differfree: underflow detected; magic8 corruptedfree: underflow detected; mh_nbytes out of rangefunction name { COMMANDS ; } or name () { COMMANDS ; }function_substitute: cannot duplicate anonymous file as standard outputfunction_substitute: cannot open anonymous file for outputfuture versions of the shell will force evaluation as an arithmetic substitutiongetcwd: cannot access parent directoriesgetopts optstring name [arg ...]hash [-lr] [-p pathname] [-dt] [name ...]hashing disabledhelp [-dms] [pattern ...]help not available in this versionhere-document at line %d delimited by end-of-file (wanted `%s')history [-c] [-d offset] [n] or history -anrw [filename] or history -ps arg [arg...]history positionhistory specificationhits	command
identifier expected after pre-increment or pre-decrementif COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS; ]... [ else COMMANDS; ] fiinitialize_job_control: getpgrp failedinitialize_job_control: line disciplineinitialize_job_control: no job control in backgroundinitialize_job_control: setpgidinvalid arithmetic baseinvalid baseinvalid character %d in exportstr for %sinvalid file descriptorinvalid glob sort typeinvalid hex numberinvalid integer constantinvalid numberinvalid octal numberinvalid regular expression `%s'invalid regular expression `%s': %sinvalid signal numberjob %d started without job controljob_spec [&]jobs [-lnprs] [jobspec ...] or jobs -x command [args]kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]last command: %s
let arg [arg ...]limitline %d: line editing not enabledload function for %s returns failure (%d): not loadedlocal [option] name[=value] ...logout
logout [n]loop countmake_here_document: bad instruction type %dmake_local_variable: no function context at current scopemake_redirection: redirection instruction `%d' out of rangemalloc: block on free list clobberedmalloc: failed assertion: %s
mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]maximum here-document count exceededmigrate process to another CPUmissing `)'missing `]'missing hex digit for \xmissing unicode digit for \%cnetwork operations not supportedno `=' in exportstr for %sno closing `%c' in %sno command foundno help topics match `%s'.  Try `help help' or `man -k %s' or `info %s'.no job controlno job control in this shellno match: %sno other directoryno other options allowed with `-x'not currently executing completion functionnot login shell: use `exit'null directoryoctal numberonly meaningful in a `for', `while', or `until' looppipe errorpop_scope: head of shell_variables not a temporary environment scopepop_var_context: head of shell_variables not a function contextpop_var_context: no global_variables contextpopd [-n] [+N | -N]power failure imminentpretty-printing mode ignored in interactive shellsprint_command: bad connector `%d'printf [-v var] format [arguments]progcomp_insert: %s: NULL COMPSPECprogrammable_completion: %s: possible retry loopprogramming errorpushd [-n] [+N | -N | dir]pwd [-LP]read [-Eers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]read errorreadarray [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]readonly [-aAf] [name[=value] ...] or readonly -prealloc: called with unallocated block argumentrealloc: start and end chunk sizes differrealloc: underflow detected; magic8 corruptedrealloc: underflow detected; mh_nbytes out of rangerecursion stack underflowredirection error: cannot duplicate fdregister_alloc: %p already in table as allocated?
register_alloc: alloc table is full with FIND_ALLOC?
register_free: %p already in table as free?
restrictedrestricted: cannot redirect outputreturn [n]run_pending_traps: bad value in trap_list[%d]: %prun_pending_traps: signal handler is SIG_DFL, resending %d (%s) to myselfsave_bash_input: buffer already exists for new fd %dscript file read errorselect NAME [in WORDS ... ;] do COMMANDS; doneset [-abefhkmnptuvxBCEHPT] [-o option-name] [--] [-] [arg ...]shell level (%d) too high, resetting to 1shell_getc: shell_input_line_size (%zu) exceeds SIZE_MAX (%lu): line truncatedshift [n]shift countshopt [-pqsu] [-o] [optname ...]sigprocmask: %d: invalid operationsource [-p path] filename [arguments]start_pipeline: pgrp pipestring lengthsuspend [-f]syntax errorsyntax error in conditional expressionsyntax error in conditional expression: unexpected token `%s'syntax error near `%s'syntax error near unexpected token `%s'syntax error near unexpected token `%s' while looking for matching `%c'syntax error: `%s' unexpectedsyntax error: `((%s))'syntax error: `;' unexpectedsyntax error: arithmetic expression requiredsyntax error: unexpected end of filesyntax error: unexpected end of file from `%s' command on line %dsyntax error: unexpected end of file from command on line %dsystem crash imminenttest [expr]time [-p] pipelinetoo many argumentstrap [-Plp] [[action] signal_spec ...]trap handler: maximum trap handler level exceeded (%d)trap_handler: bad signal %dtype [-afptP] name [name ...]typeset [-aAfFgiIlnrtux] name[=value] ... or typeset -p [-aAfFilnrtux] [name ...]ulimit [-SHabcdefiklmnpqrstuvxPRT] [limit]umask [-p] [-S] [mode]unalias [-a] name [name ...]unexpected EOF while looking for `]]'unexpected EOF while looking for matching `%c'unexpected EOF while looking for matching `)'unexpected argument `%s' to conditional binary operatorunexpected argument `%s' to conditional unary operatorunexpected argument to conditional binary operatorunexpected argument to conditional unary operatorunexpected token %d in conditional commandunexpected token `%c' in conditional commandunexpected token `%s' in conditional commandunexpected token `%s', conditional binary operator expectedunexpected token `%s', expected `)'unknownunknown command errorunset [-f] [-v] [-n] [name ...]until COMMANDS; do COMMANDS-2; donevalue too great for basevariables - Names and meanings of some shell variableswait [-fn] [-p var] [id ...]wait [pid ...]wait: pid %ld is not a child of this shellwait_for: No record of process %ldwait_for_job: job %d is stoppedwaitchld: turning on WNOHANG to avoid indefinite blockwarning: warning: -C option may not work as you expectwarning: -F option may not work as you expectwhile COMMANDS; do COMMANDS-2; donewrite errorxtrace fd (%d) != fileno xtrace fp (%d)xtrace_set: %d: invalid file descriptorxtrace_set: NULL file pointer{ COMMANDS ; }Project-Id-Version: bash 5.3-rc2
Report-Msgid-Bugs-To: 
PO-Revision-Date: 2025-06-03 19:37+0200
Last-Translator: Remus-Gabriel Chelu <remusgabriel.chelu@disroot.org>
Language-Team: Romanian <translation-team-ro@lists.sourceforge.net>
Language: ro
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Plural-Forms: nplurals=3; plural=(n==1 ? 0 : (n==0 || ((n%100) > 0 && (n%100) < 20)) ? 1 : 2);
X-Bugs: Report translation errors to the Language-Team address.
X-Generator: Poedit 3.5
X-Poedit-SourceCharset: UTF-8
timed expirat așteptând introducerea datelor: auto-logout
	-%s sau -o opțiune
	-ilrsD sau -c comandă sau -O shopt_option		(doar invocare)

malloc: %s:%d: aserțiune greșită
  (dir.lucru: %s) (core dumped) linie ! PIPELINE$%s: nu se poate asigna în acest mod%c%c: opțiune nevalidă%s poate fi invocat via %s are exportstr nul%s este %s
%s este o funcție
%s este o comandă internă a shell
%s este un cuvânt cheie shell
%s este o comandă internă specială a shell
%s este un alias pentru „%s”
%s este asociat(hashed) (%s)
%s nu este asociat niciunei taste.
%s în afara intervalului%s%s%s: %s (identificatorul erorii este „%s”)%s: %s în afara intervalului%s: %s: nu se poate deschide ca FIȘIER%s: %s: valoarea de compatibilitate în afara intervalului%s: %s: valoare nevalidă pentru descriptorul fișierului de urmărire%s: %s: trebuie să fie folosit un indice atunci când se atribuie unei matrice asociative%s: %s:%d: nu se pot aloca %lu octeți%s: %s:%d: nu se pot aloca %lu octeți (%lu octeți alocați)%s: Este un director%s: specificație de lucrare, ambiguă%s: argumentele trebuie să fie ID-uri de proces sau de lucrări%s: se atribuie un număr întreg referinței de nume%s: specificație incorectă pentru ruta rețelei%s: substituție nevalidă%s: se așteaptă operator binar%s: numele comenzilor interne nu pot conține bare oblice%s: nu se pot aloca %lu octeți%s: nu se pot aloca %lu octeți (%lu octeți alocați)%s: nu se poate atribui%s: nu se poate atribui o listă unui membru al matricei%s: nu se poate atribui la index ne-numeric%s: nu se poate converti o matrice asociativă într-o matrice indexată%s: nu se poate converti matricea indexată în asociativă%s: nu se poate șterge: %s%s: nu se pot distruge variabilele matrice în acest fel%s: nu se poate executa: fișierul necesar nu a fost găsit%s: nu se poate exporta%s: nu se poate moșteni valoarea de la un tip incompatibil%s: nu se poate deconfigura%s: nu se poate deconfigura: %s este protejat la scriere%s: referință de nume circulară%s: comanda internă dinamică a «bash», este deja încărcată%s: eroare în expresie
%s: fișierul este prea mare%s: nu s-a găsit fișierul%s: primul caracter care nu este spațiu în alb nu este «"» (ghilimele duble)%s: tabelul de asociere este gol
%s: a eșuat expansiunea istoriei%s: gazdă necunoscută%s: se ignoră încercarea de definire a funcției%s: opțiune ilegală -- %c
%s: se aștepta un număr întreag (integer)%s: nume de acțiune nevalid%s argument nevalid%s: origine matrice nevalid%s: cuantum de apel invers nevalid%s: specificație de descriptor de fișier nevalidă%s: extindere indirectă nevalidă%s: specificație a lucrării nevalidă%s: limită de argument nevalidă%s: contorizare de linii nevalidă%s: opțiune nevalidă%s: nume de opțiune nevalid%s: serviciu nevalid%s: nume nevalid al opțiunii shell%s: specificație de semnal nevalidă%s: specificație a timpului de expirare nevalidă%s: marcaj de timp nevalid%s: nume de variabilă nevalid%s: nume de variabilă nevalid pentru referința numelui%s: este un director%s: lucrarea %d se află deja în fundal%s: lucrarea a fost terminată%s: specificația sarcinii trebuie să înceapă cu „%%”%s: linie %d: %s: s-a depășit nivelul maxim de suprapunere de funcții (%d)%s: adâncimea maximă a nameref (%d) a fost depășită%s: s-a depășit nivelul maxim de suprapunere de citiri cu «source» (%d)%s: lipsește separatorul%s: nu sunt permise auto-referințele la variabile nameref%s: nicio specificație de completare%s: nu există lucrări actuale%s: nu există un control de lucrări%s: nu există această lucrare%s: nu este o funcție%s: nu este un fișier normal%s: nu este o comandă internă%s: nu este o variabilă matrice%s: nu este o matrice indexată%s: nu este încărcat dinamic%s: nu s-a găsit%s: argument numeric necesar%s: opțiunea necesită un argument%s: opțiunea necesită un parametru: -- %c
%s: parametru nedefinit%s: parametru nul sau nedefinit%s: alocarea de matrice compusă între ghilimele este perimată%s: funcție protejată la scriere%s: variabilă protejată la scriere%s: variabila de referință nu poate fi o matrice%s: se elimină atributul nameref%s: restricționat%s: limitat: nu se poate specifica „/” în numele comenzilor%s: expresie subșir < 0%s: se așteaptă operator unar%s: variabilă neasociată%s: utilizare: %s: nu este posibil ca variabilei să i se atribuie o valoare”

(( expresie ))(core dumped) (dir.lucru actual: %s)
++: atribuirea necesită o valoare lvalue--: atribuirea necesită o valoare lvalue. [-p rută] nume_fișier [argumente]nu se admite «/dev/(tcp|udp)/host/port» fără a avea o conexiune la rețea«/tmp» trebuie să fie un nume de director valid<niciun director curent>Instrucțiune ABORTSe abandonează...Adaugă directoare la stivă.
    
    Adaugă un director în partea de sus a stivei de directoare sau 
    rotește stiva, făcând din partea de sus a stivei directorul de lucru
    curent.  Fără argumente, interschimbă primele două directoare.
    
    Opțiuni:
      -n	Suprimă schimbarea normală a directorului atunci când se adaugă
    		directoare la stivă, astfel încât numai stiva este manipulată.
    
    Argumente:
      +N	Rotește stiva astfel încât al N-lea director (numărând 
    		din stânga listei afișate de «dirs», începând cu zero) să fie
    		în partea de sus.
    
      -N	Rotește stiva astfel încât al N-lea director (numărând 
    		din dreapta listei afișate de «dirs», începând cu zero) să fie
    		în partea de sus.
    
      dir	Adaugă DIR la stiva de directoare din partea de sus, făcându-l
    		noul director de lucru curent.
    
    Comanda internă «dirs» afișează stiva de directoare.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizat un argument
    nevalid sau dacă schimbarea directorului eșuează.Adaugă un director în partea de sus a stivei de directoare sau rotește
   stiva, făcând din noul director din partea de sus a stivei, directorul de
    lucru curent. Fără argumente, interschimbă primele două directoare.
    
    Opțiuni:
      -n	Suprimă schimbarea normală a directorului atunci când se
    	adaugă directoare la stivă, astfel încât numai stiva este manipulată.
    
    Argumente:
      +N	Rotește stiva astfel încât al N-lea director (numărând din
    	stânga listei afișate de «dirs», începând cu zero) să fie în
    	partea de sus.
    
      -N	Rotește stiva astfel încât al N-lea director (numărând din
    	dreapta listei afișate de «dirs», începând cu zero) să fie în
    	partea de sus.
    
      dir	Adaugă DIR la stiva de directoare din partea de sus,
    	făcându-l noul director de lucru curent.
    
    Comanda internă «dirs» arată stiva curentă de directoare.Alarmă (profil)Alarmă (virtual)Ceas cu alarmăBuclă aritmetică „for”.
    
    Echivalentă cu:
    	(( EXP1 ))
    	while (( EXP2 )); do
    		COMENZI
    		(( EXP3 ))
    	done
    EXP1, EXP2, și EXP3 sunt expresii aritmetice.  Dacă orice expresie este
    omisă, se comportă ca și cum aceasta ar avea valoarea 1.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Punct de întrerupere de urmărire/capturareApel de sistem incorectSemnal falsLinie de conectare întreruptăEroare de magistrală de date(bus)Limită CPUSchimbă directorul de lucru al shell-ului.
    
    Schimbă directorul actual cu DIR.  DIR implicit este valoarea variabilei de 
    shell HOME. Dacă DIR este „-”, acesta este convertit în $OLDPWD.
    
    Variabila CDPATH definește ruta de căutare pentru directorul care conține
    DIR.  Numele alternative ale directoarelor din CDPATH sunt separate prin
    două puncte (:).  Numele unui director nul este același cu directorul curent.
    Dacă DIR începe cu o bară oblică (/), atunci CDPATH nu este utilizat.
    
    Dacă directorul nu este găsit și opțiunea de shell „cdable_vars” este definită,
    cuvântul se presupune a fi un nume de variabilă.  Dacă acea variabilă are o
    valoare, valoarea ei este utilizată pentru DIR.
    
    Opțiuni:
      -L	forțează ca legăturile simbolice să fie urmate: rezolvă 
    		legăturile simbolice din DIR după procesarea instanțelor de „..”
      -P	utilizează structura fizică a directorului fără a urma legăturile
    		simbolice: rezolvă legăturile simbolice din DIR înainte de a
    		procesa instanțe de „..”
      -e	dacă este furnizată opțiunea „-P” și directorul de lucru curent
    		nu poate fi determinat cu succes, iese cu o stare diferită de
    		zero
      -@	pe sistemele care acceptă acest lucru, prezintă un fișier cu
    		atribute extinse, ca un director care conține atributele fișierului
    
    Modul implicit este să urmeze legături simbolice, ca și cum ar fi fost specificat „-L”.
    „..” este procesat prin eliminarea componentei de rută imediat anterioară până
   la o bară oblică sau la începutul DIR.
    
   Starea de ieșire:
    Returnează 0 dacă directorul este schimbat și dacă $PWD este stabilit cu succes atunci
    când este utilizat „-P”; diferit de zero, în caz contrar.Proces-copil mort sau opritNumele și utilizarea variabilelor shell comune.
    
    BASH_VERSION
         	Informații despre versiunea acestui Bash.
    CDPATH	O listă de directoare separate prin două puncte
    		pentru a căuta directoare date ca argumente pentru «cd».
    GLOBIGNORE	O listă de modele, separate prin două puncte, care descriu nume
    		de fișiere care trebuie ignorate de extinderea numelui de rută.
    HISTFILE	Numele fișierului în care este stocat istoricul comenzilor.
    HISTFILESIZE
         	Numărul maxim de linii pe care acest fișier le poate conține.
    HISTSIZE	Numărul maxim de linii de istoric pe care le poate accesa un
    		shell care rulează.
    HOME	Ruta completă către directorul dumneavoastră de conectare.
    HOSTNAME	Numele gazdei curente.
    HOSTTYPE	Tipul de CPU pe care rulează această versiune de Bash.
    IGNOREEOF	Controlează acțiunea shell-ului la primirea unui caracter „EOF”
    		ca unică intrare.  Dacă este definită, atunci valoarea acesteia
    		este numărul de caractere „EOF” care pot fi văzute într-un rând
    		pe o linie goală înainte ca shell-ul să iasă (implicit 10).
    		Când nu este definită, „EOF” înseamnă sfârșitul intrării.
    MACHTYPE	Un șir care descrie sistemul curent pe care rulează Bash.
    MAILCHECK	Cât de des, în secunde, verifică Bash dacă există mesaje noi.
    MAILPATH	O listă de nume de fișiere, separate prin două puncte, pe care
    		Bash le verifică pentru mesaje noi.
    OSTYPE	Versiunea de Unix pe care rulează această versiune de Bash.
    PATH	O listă de directoare separate prin două puncte în care se caută,
    		atunci când se caută comenzi.
    PROMPT_COMMAND
         	O comandă care trebuie executată înainte de afișarea
    		fiecărui prompt primar.
    PS1		Șirul de prompt primar.
    PS2		Șirul de prompt secundar.
    PWD		Ruta completă a directorului curent.
    SHELLOPTS	O listă separată de două puncte, de opțiuni de shell activate.
    TERM	Numele tipului actual de terminal.
    TIMEFORMAT	Formatul de ieșire pentru statisticile de timp afișat de
    		cuvântul rezervat „time”.
    auto_resume	Non-null înseamnă că un cuvânt de comandă care apare singur pe o
    		linie este căutat mai întâi în lista de lucrări oprite în prezent.
    		Dacă se găsește acolo, lucrarea este în prim plan.  O valoare
    		„exact” înseamnă că cuvântul de comandă trebuie să se potrivească
    		exact cu o comandă din lista de lucrări oprite.  O valoare „sub-
    		string” înseamnă că cuvântul de comandă trebuie să se potrivească
    		cu un subșir al lucrării.  Orice altă valoare înseamnă  că
    		comanda trebuie să fie un prefix al unei lucrări oprite.
    histchars	Caractere care controlează extinderea istoricului și
    		înlocuirea rapidă.  Primul caracter este caracterul
    		de înlocuire a istoricului, de obicei „!”.  Al doilea este
    		caracterul „înlocuire rapidă”, de obicei „^”.  Al treilea
    		este caracterul „comentare istoric”, de obicei „#”.
    HISTIGNORE	O listă de modele separate prin două puncte, utilizată pentru a
    		decide ce comenzi ar trebui salvate în lista istoricului.
ContinuareDrepturi de autor © 2025 Free Software Foundation, Inc.Creează un coproces numit NUME.
    
    Execută COMANDA în mod asincron, cu ieșirea standard și intrarea standard a
    comenzii conectate printr-o conductă la descriptorii de fișiere alocați
    indicilor 0 și 1 ai unei variabile matrice NUME din shell-ul de execuție.
    NUMELE implicit este „COPROC”.
    
    Starea de ieșire:
    Comanda «coproc» returnează o stare de ieșire de 0.Avertisment de DEPANARE: Definește variabilele locale.
    
    Creează o variabilă locală numită NUME și îi dă această VALOARE.
    OPȚIUNE poate fi orice opțiune acceptată de «declare».
    
    Dacă un nume este „-”, local salvează setul de opțiuni ale shell-ului și
    le restabilește atunci când funcția returnează.
    
    Variabilele locale pot fi utilizate numai în cadrul unei funcții; sunt
    vizibile numai pentru funcția în care sunt definite și pentru copiii
    acesteia.
    
    Starea de ieșire:
    Returnează succes cu excepția cazului în care este furnizată o opțiune
    nevalidă, apare o eroare de atribuire a variabilei sau shell-ul nu execută
    o funcție.Definește sau afișează alias.
    
    Fără argumente, «alias» imprimă lista de alias în forma reutilizabilă
    „alias NUME=VALOARE” la ieșirea standard (pe ecran).
    
    În caz contrar, un alias este definit pentru fiecare NUME a cărui VALOARE
    este dată.  Un spațiu final în VALOARE, face ca următorul cuvânt să fie
    verificat pentru înlocuirea aliasului atunci când aliasul este extins.
    
    Opțiuni:
      -p	imprimă toate alias definite într-un format reutilizabil
    
    Starea de ieșire:
    «alias» returnează adevărat, cu excepția cazului în care este furnizat
    un NUME pentru care nu a fost definit niciun alias.Definește funcția shell.
    
    Creează o funcție de shell numită NUME.  Când se invocă ca o comandă simplă,
    NUME rulează COMENZI în contextul shell-ului apelant.  Când NUME este 
    invocat, argumentele sunt transmise funcției ca $1...$n, iar numele
    funcției este în $FUNCNAME.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care NUME este protejat la scriere.Afișează stiva de directoare.
    
    Afișează lista directoarelor memorate în prezent.  Directoarele
    sunt adăugate la această listă cu comanda «pushd» și eliminate
    cu comanda «popd».
    
    Opțiuni:
      -c	curăță stiva de directoare ștergând toate elementele
      -l	nu afișează versiuni de directoare cu prefix „~” în raport 
    		cu directorul dumneavoastră «acasă»
      -p	afișează stiva de directoare cu o intrare pe linie
      -v	afișează stiva de directoare cu o intrare pe linie, prefixată
    		cu poziția sa în stivă
    
    Argumente:
      +N	Afișează a N-a intrare numărând din stânga listei afișate
    		de «dirs» atunci când este invocată fără opțiuni, începând
    		cu zero.
    
      -N	Afișează a N-a intrare numărând din dreapta listei afișate
    		de «dirs» atunci când este invocată fără opțiuni, începând
    		cu zero.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizată o opțiune
    nevalidă sau apare o eroare.Afișează informații despre comenzile interne.
    
    Afișează scurte rezumate ale comenzilor interne.  Dacă TIPAR, este
    specificat, oferă ajutor detaliat pentru toate comenzile care se potrivesc
    cu TIPARul, în caz contrar, este afișată lista temelor de ajutor.
    
    Opțiuni:
      -d	afișează o scurtă descriere pentru fiecare temă
      -m	afișează utilizarea în format pseudo-pagină de manual
      -s	afișează doar un scurt rezumat de utilizare pentru
    		fiecare temă care se potrivește cu TIPAR
    
    Argumente:
      TIPAR  	TIPAR care specifică o temă de ajutor
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care TIPAR nu este găsit sau este
    dată o opțiune nevalidă.Afișează informații despre comanda «type».
    
    Pentru fiecare NUME, indică cum ar fi interpretat dacă ar fi folosit ca
    nume de comandă.
    
    Opțiuni:
      -a	afișează toate locațiile care conțin un executabil numit NUME; 
    		include alias, componente integrate și funcții, dacă și numai
    		dacă opțiunea „-p” nu este, de asemenea, utilizată
      -f	suprimă căutarea funcției de shell
      -P	forțează o căutare PATH pentru fiecare NUME, chiar dacă este un
    		alias, o comandă internă sau o funcție, și returnează numele
    		fișierului din disc care va fi executat
      -p	returnează fie numele fișierului de pe disc care va fi executat,
    		fie nimic dacă «type -t NUME» nu va returna „file”
      -t	afișează un singur cuvânt care este unul dintre „alias”, „keyword”,
    		„function”, „builtin”, „file” sau „”, dacă NUME este un alias,
    		cuvânt rezervat shell, funcție shell, comandă internă shell,
    		fișier pe disc, sau, respectiv, negăsit
    
    Argumente:
      NUME	Numele comenzii de interpretat.
    
    Starea de ieșire:
    Returnează succes dacă toate NUMEle sunt găsite; eșuează dacă nu sunt găsite.Afișează sau execută comenzi din lista istoricului.

    «fc» se utilizează pentru a lista sau edita și re-executa comenzi din lista
    istoricului.
    PRIMA și ULTIMA pot fi numere care specifică intervalul sau PRIMA poate fi
    un șir, ceea ce înseamnă cea mai recentă comandă care începe cu acel șir.

    Opțiuni:
      -e NUME_EDIT
    		selectează ce editor să utilizat.  Implicit este FCEDIT, apoi
    		EDITOR, apoi vi
      -l 	listează linii în loc să editeze
      -n	omite numerele de rând la listare
      -r	inversează ordinea liniilor (cele mai noi sunt listate primele)

    Cu formatul «fc -s [tipar=înloc ...] [comanda]», COMANDA este re-executată
    după ce este efectuată înlocuirea VECHE=NOUĂ.

    Un alias util de folosit cu aceasta, este «r='fc -s'», astfel încât tastând
    «r cc» se execută ultima comandă ce începe cu „cc” și tastând «r» se execută
    din nou ultima comandă folosită.

    Comanda internă «history» operează, de asemenea, pe lista istoricului.

    Starea de ieșire:
    Returnează succesul sau starea comenzii executate; diferit de zero dacă
    apare o eroare.Afișează sau manipulează lista istoricului.
    
    Afișează lista istoricului cu numere de linie, prefixând fiecare intrare
    modificată cu un „*”.  Un argument de N, listează numai ultimele N intrări.
    
    Opțiuni:
      -c	șterge lista istoricului ștergând toate intrările
      -d poziție
    		șterge intrarea din istoric de la poziția POZIȚIE.  Pozițiile
    		negative se numără înapoi de la sfârșitul listei istoricului
      -d start-final
    		șterge intrările din istoric începând de la poziția START până la
    		poziția FINAL.
    
      -a	adaugă linii istorice din această sesiune la fișierul istoricului
      -n	citește toate liniile istorice care nu sunt deja citite din
    		fișierul istoricului și le adaugă la lista istoricului
      -r	citește fișierul istoricului și îi adaugă conținutul la lista
    		istoricului
      -w	scrie istoricul curent în fișierul istoricului
    
      -p	efectuează extinderea istoricului pentru fiecare ARG și afișează
    		rezultatul fără a-l stoca în lista istoricului
      -s	adaugă ARGumentele la lista istoricului ca o singură intrare
    
    Dacă NUME_FIȘIER este dat, acesta este utilizat ca fișierul istoricului.
    Altfel, dacă HISTFILE are o valoare, aceasta este folosită. Dacă
    NUME_FIȘIER nu este furnizat și HISTFILE nu este definită sau este nulă,
    opțiunile „-a”, „-n”, „-r” și „-w” nu au niciun efect și returnează un
    rezultat de succes..
    
    Dacă variabila HISTTIMEFORMAT este definită și nu este nulă, valoarea ei este
    utilizată ca șir de format pentru strftime(3) pentru a imprima marcajul de
    timp asociat cu fiecare intrare din istoric afișată.  În caz contrar, nu se
    imprimă marcajele de timp.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau apare o eroare.Afișează sau modifică masca pentru accesarea fișierelor nou create.
    
    Stabilește masca de creare a fișierelor de utilizator la MOD.  Dacă MOD
    este omis, afișează valoarea curentă a măștii.
    
    Dacă MOD începe cu o cifră, acesta este interpretat ca un număr octal;
    altminteri este interpretat ca un șir în format simbolic ca cel acceptat
    de chmod(1).
    
    Opșiuni
      -p	dacă MOD este omis, arată ieșirea într-o formă care poate fi
          	reutilizată ca intrare
      -S	afișează MODul în formatul simbolic; altminteri în formatul octal
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care MOD este nevalid sau
    este dată o opțiune nevalidă.Afișează posibilele completări în funcție de opțiuni.
    
    Aceasta este destinată să fie utilizată dintr-o funcție shell care generează
    posibile completări.  Dacă este furnizat argumentul opțional CUVÂNT, se
    generează potriviri cu CUVÂNT.

    
    Dacă este furnizată opțiunea „-V”, stochează completările posibile în
    matricea indexată NUME_VARIABILĂ în loc să le imprime la ieșirea standard.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizată o opțiune
    nevalidă sau apare o eroare.Afișează timpii procesului.
    
    Afișează timpii acumulați de utilizator și sistem pentru shell și pentru toate
    procesele sale secundare.
    
    Starea de ieșire:
    Întotdeauna reușește(0).Afișează starea proceselor.
    
    Listează procesele active.  ID_PROC, restrânge afișarea la acel proces.
    Fără opțiuni, se afișează starea tuturor proceselor active.
    
    Opțiuni:
      -l	listează ID-urile proceselor, pe lângă informațiile normale
      -n	listează numai procesele care s-au schimbat de la ultima notificare
      -p	listează numai ID-urile proceselor
      -r	restrânge afișarea, la procesele în execuție
      -s	restrânge afișarea, la procesele oprite
    
    Dacă este furnizată -x, COMANDA este rulată după ce toate specificațiile
    procesului care apar în ARGumente au fost înlocuite cu ID-ul de proces al
    liderului grupului de procese, al procesului respectiv.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau apare o eroare.
    Dacă se utilizează „-x”, returnează starea de ieșire a COMENZII.Afișează lista curentă a directoarelor memorate.  Directoarele
    sunt adăugate la această listă cu comanda «pushd» și sunt eliminate din
    ea, cu comanda «popd».
    
    Opțiuni:
      -c	golește stiva de directoare prin ștergerea tuturor elementelor
      -l	nu afișează versiuni scurtate (cu ~) ale directoarelor în raport cu
    	directorul dumneavoastră «acasă»
      -p	imprimă stiva de directoare cu o intrare pe linie
      -v	imprimă stiva de directoare cu o intrare pe linie, prefixată cu poziția
    	sa în stivă
    
    Argumente:
      +N	Afișează a N-a intrare numărând din stânga listei afișate de «dirs»,
    	atunci când este invocată fără opțiuni, începând cu zero.
    
      -N	Afișează a N-a intrare numărând din dreapta listei afișate de «dirs»,
	atunci când este invocată fără opțiuni, începând cu zero.FinalizatFinalizat(%d)Instrucțiune EMTActivează și dezactivează comenzile interne ale shell-ului.
    
    Activează și dezactivează comenzile interne ale shell-ului.  Dezactivarea
    vă permite să executați o comandă de pe disc care are același nume ca
    și comanda internă a shell-ului, fără a utiliza ruta completă.
    
    Opțiuni:
      -a	afișează lista comenzilor interne indicând dacă sunt activate sau nu
      -n	dezactivează fiecare NUME sau afișează o listă de comenzi interne
    		dezactivate
      -p	afișează lista comenzilor interne într-un format reutilizabil
      -s	afișează numai numele comenzilor interne „speciale” Posix
    
    Opțiuni care controlează încărcarea dinamică:
      -f	Încarcă comanda internă NUME de la obiectul partajat NUME_FIȘIER
      -d	Elimină o comandă internă încărcată cu -f
    
    Fără opțiuni, fiecare NUME este activat.
    
    Pe sistemele cu încărcare dinamică, variabila shell BASH_LOADABLES_PATH
    definește o rută de căutare pentru directorul care conține NUME_FIȘIERe
    care nu conțin o bară oblică. Aceasta poate include „.” pentru a forța
    căutarea în directorul curent.
    
    Pentru a utiliza comanda «test» găsită în $PATH în loc de comanda internă
    de shell, tastați «enable -n test».
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care NUME nu este o comandă shell internă sau apare o eroare.Evaluează expresia aritmetică.
    
    EXPRESIA este evaluată conform regulilor de evaluare aritmetică.
    Echivalent cu „let "EXPRESIA"”.
    
    Starea de ieșire:
    Returnează 1 dacă EXPRESIA este evaluată la 0; în caz contrar, returnează 0.Evaluează expresii aritmetice.
    
    Evaluează fiecare ARGument ca o expresie aritmetică.  Evaluarea se face
    în numere întregi cu lățime fixă, fără verificarea depășirii, dar împărțirea
    la 0 este detectată și semnalată ca o eroare.  Următoarea listă de operatori
    este grupată în grupuri de operatori cu prioritate egală.  Nivelurile sunt
    listate în ordinea descrescătoare a priorității.
    
    	id++, id--	post-incrementare, post-decrementare a variabilei
    	++id, --id	pre-incrementare, pre-decrementare a variabilei
    	-, +		minus unar, plus unar
    	!, ~		negații logice și binare
    	**		exponențial
    	*, /, %		înmulțire, împărțire, rest
    	+, -		adunare, scădere
    	<<, >>		deplasare binară la stânga și la dreapta
    	<=, >=, <, >	comparare
    	==, !=		egalitate, inegalitate
    	&		și (AND) binar
    	^		sau exclusiv (XOR) binar
    	|		sau (OR) binar
    	&&		lși (AND) logic
    	||		sau (OR) logic
    	expr ? expr : expr
    			operator condițional
    	=, *=, /=, %=,
    	+=, -=, <<=, >>=,
    	&=, ^=, |=	asignare
    
    Variabilele shell sunt permise ca operanzi.  Numele variabilei este
    înlocuit cu valoarea acesteia (constrânsă la un număr întreg cu 
    lățime fixă) în cadrul unei expresii.  Nu este necesar ca variabila să
    aibă atributul întreg activat pentru a fi utilizată într-o expresie.
    
    Operatorii sunt evaluați în ordinea de prioritate.  Subexpresiile din
    paranteze sunt evaluate mai întâi și pot suprascrie regulile de
    precedență de mai sus.
    
   Starea de ieșire:
   Dacă ultimul ARGument este evaluat la 0, «let» returnează 1; în caz contrar,
   «let» returnează 0.Evaluează expresia condițională.
    
    Termină cu starea 0 (adevărat) sau 1 (fals) în funcție de evaluarea EXPR.
    Expresiile pot fi unare sau binare. Expresiile unare sunt adesea folosite
    pentru a examina starea unui fișier. Există de-asemeni operatori de șir și
    operatori de comparație numerică.
    
    Comportamentul testului depinde de numărul de argumente. Citiți pagina
    de manual, «bash», pentru specificația completă.
    
    Operatori de fișiere:
    
      -a FIȘIER      Adevărat dacă fișierul există.
      -b FIȘIER      Adevărat dacă fișierul este un dispozitiv de blocuri.
      -c FIȘIER      Adevărat dacă fișierul este un dispozitiv de caractere.
      -d FIȘIER      Adevărat dacă fișierul este un director.
      -e FIȘIER      Adevărat dacă fișierul există.
      -f FIȘIER      Adevărat dacă fișierul există și este un fișier normal.
      -g FIȘIER      Adevărat dacă fișierul are activat bitul „set-group-id”.
      -h FIȘIER      Adevărat dacă fișierul este o legătură simbolică.
      -L FIȘIER      Adevărat dacă fișierul este o legătură simbolică..
      -k FIȘIER      Adevărat dacă fișierul are activat bitul „sticky” (lipicios).
      -p FIȘIER      Adevărat dacă fișierul este o linie de conectare numită.
      -r FIȘIER      Adevărat dacă fișierul poate fi citit de dumneavoastră.
      -s FIȘIER      Adevărat dacă fișierul există și nu este gol.
      -S FIȘIER      Adevărat dacă fișierul este un soclu.
      -t DF          Adevărat dacă DF(descriptorul de fișier) este deschis pe un terminal.
      -u FIȘIER      Adevărat dacă fișierul are activat bitul „set-user-id”.
      -w FIȘIER      Adevărat dacă fișierul poate fi scris de dumneavoastră.
      -x FIȘIER      Adevărat dacă fișierul poate fi executat de dumneavoastră.
      -O FIȘIER      Adevărat dacă fișierul este deținut efectiv de dumneavoastră.
      -G FIȘIER      Adevărat dacă fișierul este deținut efectiv de grupul dumneavoastră.
      -N FIȘIER      Adevărat dacă fișierul a fost modificat de la ultima citire.
    
      FIȘI1 -nt FIȘI2  Adevărat dacă fișierul 1 este mai nou decât fișierul 2 (conform
                       datei modificării).
    
      FIȘI1 -ot FIȘI2  Adevărat dacă fișierul1 este mai vechi decât fișierul2.
    
      FIȘI1 -ef FIȘI2  Adevărat dacă fișierul1 este o legătură dură către fișierul2.
    
    Operatori de șir:
    
      -z ȘIR         Adevărat dacă șirul este gol.
    
      -n ȘIR         Adevărat dacă șirul nu este gol.
      ȘIR            Adevărat dacă șirul nu este gol.
    
      ȘIR1 = ȘIR2    Adevărat dacă șirurile sunt egale.
      ȘIR1 != ȘIR2   Adevărat dacă șirurile nu sunt egale.
      ȘIR1 < ȘIR2    Adevărat dacă ȘIR1 se ordonează lexicografic înainte de ȘIR2.
      ȘIR1 > ȘIR2    Adevărat dacă ȘIR1 se ordonează lexicografic după ȘIR2.
    
    Alți operatori:
    
      -o OPȚIUNE     Adevărat dacă opțiunea shell OPȚIUNE este activată.
      -v VAR         Adevărat dacă este definită variabila shell VAR.
      -R VAR         Adevărat dacă variabila shell VAR este definită și este o referință
                     de nume.
      ! EXPR         Adevărat dacă expresia EXPR este falsă.
      EXPR1 -a EXPR2 Adevărat dacă amândouă expresiile EXPR1 și EXPR2 sunt adevărate.
      EXPR1 -o EXPR2 Adevărat dacă fie expresia EXPR1, fie expresia EXPR2 este adevărată.
    
      ARG1 OP ARG2   Teste aritmetice.  OP este unul dintre -eq, -ne, -lt, -le, -gt, sau -ge.
    
    Operatorii binari aritmetici returnează adevărat dacă ARG1 este egal, inegal, mai mic
    decât, mai mic decât sau egal, mai mare decât, sau mai mare decât sau egal cu ARG2.
    
    Starea de ieșire:
    Returnează succes dacă EXPR este evaluată ca adevărată; eșuează dacă EXPR este
    evaluată ca fiind falsă sau este dat un argument nevalid.Evaluează expresia condițională.
    
    Acesta este un sinonim pentru comanda internă «test», dar ultimul argument
    trebuie să fie un „]” literal, pentru a se potrivi cu „[” de deschidere.Execută PIPELINE, care poate fi o simplă comandă, și inversează
    starea de returnare a PIPELINE.
    
    Starea de ieșire:
    Negarea logică a stării de returnare a PIPELINE.Execută o comandă simplă sau afișează informații despre comenzi.
    
    Rulează COMANDA cu ARGUMENTE care suprimă căutarea funcției shell, sau
    afișează informații despre COMENZILE specificate.  Se poate utiliza pentru
    a invoca comenzi de pe disc atunci când există o funcție cu același nume.
    
    Opțiuni:
      -p    utilizează o valoare implicită pentru PATH ce garantează că se
            vor găsi toate utilitățile standard
      -v    imprimă un singur cuvânt indicând comanda sau numele fișierului
            care invocă COMANDA
      -V    imprimă o descriere mai detaliată pentru fiecare COMANDĂ
    
    Starea de ieșire:
    Returnează starea de ieșire a COMENZII sau eșuează dacă COMANDA nu este găsită.Execută argumente ca o comandă de shell.
    
    Combină ARGumentele într-un singur șir, folosește rezultatul ca intrare în
    shell și execută comenzile rezultate.
    
    Starea de ieșire:
    Returnează starea de ieșire a comenzii, sau succes dacă comanda este nulă.Execută comenzi atâta timp cât un test nu reușește.
    
    Expandează și execută COMENZI-2 atâta timp cât comanda finală din
    COMENZI are o stare de ieșire diferită de zero.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Execută comenzi atâta timp cât un test reușește.
    
    Expandează și execută COMENZI-2 atâta timp cât comanda finală din
    COMENZI are o stare de ieșire zero.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Execută comenzi bazate pe condițional.
    
    Lista „if COMENZI” este executată.  Dacă starea sa de ieșire este zero,
    atunci este executată lista „then COMENZI”.  În caz contrar, fiecare listă 
    „elif COMENZI” este executată pe rând, iar dacă starea sa de ieșire este
    zero, lista corespunzătoare „then COMENZI” este executată și comanda
    «if» se completează.  În caz contrar, lista „else COMENZI” este executată,
    dacă este prezentă.  Starea de ieșire a întregii construcții este starea de
    ieșire a ultimei comenzi executate sau zero dacă nicio condiție nu a fost
    evaluată ca adevărată.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Execută comenzi bazate pe potrivirea modelelor.
    
    Execută COMENZI selectiv, pe baza potrivirilor dintre CUVÂNT și MODEL.
    „|” este folosit pentru a separa mai multe modele.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Execută comenzi pentru fiecare membru dintr-o listă.
    
    Bucla „for” execută o secvență de comenzi pentru fiecare membru dintr-o
    listă de elemente.  Dacă „in CUVINTE ...;” nu este prezent, atunci se
    presupune „in "$@"”.  Pentru fiecare element din CUVINTE, se definește
    NUME ca acel element, și se execută COMENZILE.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Execută comenzi dintr-un fișier în shell-ul curent.
    
    Citește și execută comenzi din NUME_FIȘIER în shell-ul curent. Dacă este
    furnizată opțiunea -p, argumentul PATH este tratat ca o listă de directoare
    separate prin două puncte care trebuie căutate pentru NUME_FIȘIER. Dacă -p
    nu este furnizată, $PATH este căutată pentru a găsi NUME_FIȘIER. Dacă sunt
    furnizate ARGUMENTE, acestea devin parametrii poziționali atunci când
    NUME_FIȘIER este executat.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate în NUME_FIȘIER; eșuează dacă
    NUME_FIȘIER nu poate fi citit.Execută comanda condițională.
    
    Returnează o stare de 0 sau 1, în funcție de evaluarea expresiei condiționale
    EXPRESIA.  Expresiile sunt compuse din aceleași elemente primare folosite de
    comanda INTERNĂ «test» și pot fi combinate folosind următorii operatori:
    
      ( EXPRESIA )	Returnează valoarea EXPRESIEI
      ! EXPRESIA	Adevărat dacă EXPRESIA este falsă; altfel fals
      EXPR1 && EXPR2	Adevărat dacă atât EXPR1 cât și EXPR2 sunt adevărate;
      			altfel fals
      EXPR1 || EXPR2	Adevărat dacă fie EXPR1, fie EXPR2 este adevărată;
      			altfel fals
    
    Când se utilizează operatorii „==” și „!=”, șirul din dreapta operatorului
    este utilizat ca model și se realizează potrivirea modelului.
    Când se utilizează operatorul „=~”, șirul din dreapta operatorului se
    potrivește ca expresie regulată.
    
    Operatorii „&&” și „||” nu evaluează EXPR2 dacă EXPR1 este suficientă pentru
    a determina valoarea expresiei.
    
    Starea de ieșire:
    0 sau 1, în funcție de valoarea EXPRESIEI.Execută comenzile interne de shell.
    
    Execută SHELL-BUILTIN cu argumentele ARG fără a efectua căutarea comenzilor.
    Acest lucru este util atunci când doriți să reimplementați o comandă internă de shell
    ca o funcție shell, dar trebuie să executați comanda internă în cadrul funcției.
    
    Starea de ieșire:
    Returnează starea de ieșire a lui SHELL-BUILTIN sau false dacă SHELL-BUILTIN nu
    este o comandă internă de shell.Ieșire %dIese din shell-ul de autentificare.
    
    Iese din shell-ul de autentificare cu starea de ieșire N. Returnează o eroare
    dacă nu este executată într-un shell de autentificare.Termină buclele for, while, sau until.
    
    Termină o buclă FOR, WHILE sau UNTIL.  Dacă se specifică N, termină
    numărul de bucle specificat.
    
    Starea de ieșire:
    Starea de ieșire este 0, cu excepția cazului în care N nu este mai mare sau egal cu 1.Iese din shell.
    
    Iese din shell cu starea lui N.  Dacă N este omis, starea de ieșire
    este starea ultimei comenzi executate.Limită fișierExcepție de virgulă mobilăFormatează și imprimă ARGUMENTELE sub controlul FORMATului.
    
    Opțiuni:
      -v var	asignează ieșirea variabilei shell VAR, în loc să o
    		afișeze la ieșirea standard
    
    FORMAT este un șir de caractere care conține trei tipuri de obiecte: 
    caractere simple, care sunt pur și simplu copiate la ieșirea standard; 
    secvențe de eludare de caractere, care sunt convertite și copiate la 
    ieșirea standard; și specificații de format, fiecare dintre acestea 
    determinând imprimarea următorului argument succesiv.
    
    În plus față de caracterele de format standard csndiouxXeEfFgGaA descrise
    în printf(3), «printf» interpretează:
    
      %b	expandează secvențele de eludare de bară inversată,
          	în argumentul corespunzător
      %q	citează argumentul într-un mod care poate fi reutilizat
          	ca intrare shell
      %Q	precum %q, dar aplică orice precizie argumentului necitat
    		înainte de al cita
      %(fmt)T	afișează șirul dată-oră rezultat din utilizarea FMT,
          	ca șir de format pentru strftime(3)
    
    Formatul este reutilizat după cum este necesar pentru a consuma toate
    argumentele. Dacă există mai puține argumente decât necesită formatul,
    specificațiile de format suplimentare se comportă ca și cum ar fi fost
    furnizată o valoare zero sau un șir nul, după caz.
    
    Starea de ieșire:
    Returnează succes cu excepția cazului în care este dată o opțiune nevalidă
    sau apare o eroare de scriere sau de atribuire.GNU bash, versiunea %s (%s)
GNU bash, versiunea %s-(%s)
Opțiuni lungi GNU:
Ajutor general pentru utilizarea software-ului GNU: <http://www.gnu.org/gethelp/>
Grupează comenzile ca o unitate.
    
    Rulează un set de comenzi dintr-un grup. Aceasta este o modalitate
    de a redirecționa un întreg set de comenzi.
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Date de intrare HFT în curs de rezolvareModul de monitor HFT a fost acordatModul de monitor HFT a fost retrasSecvența de sunet HFT a fost completatăvariabila $HOME nu este definităDeconectare/Terminare anormală(Hangup)Nu am nici un nume!In/Ieș pregătităRAPORT: Instrucțiune ilegalăSolicitare de informațieÎntrerupereOmorâtLicență GPLv3+: GNU GPL versiunea 3 sau ulterioară <http://gnu.org/licenses/gpl.html>
Marchează variabilele shell ca neschimbabile.
    
    Marchează fiecare NUME ca fiind doar pentru citire; valorile acestor NUME
    nu pot fi modificate prin atribuirea ulterioară. Dacă este furnizată VALOARE,
    atribuie VALOARE înainte de a marca ca doar pentru citire.
    
    Opțiuni:
      -a	se referă la variabilele matrice indexate
      -A	se referă la variabile matrice asociative
      -f	se referă la funcțiile shell
      -p	afișează o listă cu toate variabilele sau funcțiile protejate
    		la scriere, în funcție de dacă este dată sau nu opțiunea „-f”
    
    Un argument de „--” dezactivează procesarea ulterioară a opțiunilor.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau NUME nu este valid.Modifică sau afișează opțiunile de completare.
    
    Modifică opțiunile de completare pentru fiecare NUME sau, dacă nu sunt 
    furnizate NUME, completarea aflată în curs de executare.  Dacă nu sunt 
    date OPȚIUNI, afișează opțiunile de completare pentru fiecare NUME sau 
    specificația de completare curentă.
    
    Opțiuni:
    	-o opțiune
      		Stabilește opțiunea de completare OPȚIUNE pentru fiecare NUME
    	-D	Schimbă opțiunile pentru completarea comenzii „implicite”.
    	-E	Schimbă opțiunile pentru completarea comenzii „goale”.
    	-I	Schimbă opțiunile de completare a cuvântului inițial
    
    Utilizarea lui „+o” în loc de „-o” dezactivează opțiunea specificată.
    
    Argumente:
    
    Fiecare NUME se referă la o comandă pentru care o specificație de completare
    trebuie să fi fost definită anterior folosind comanda internă «complete».  
    Dacă nu sunt furnizate NUME, «compopt» trebuie să fie apelată de o funcție 
    care generează completări în acest moment și opțiunile pentru acest 
   generator de completare care se execută acum, sunt modificate.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizată o opțiune 
    nevalidă sau NUME nu are o specificație de completare definită.Modifică limitele resurselor shell.
    
    Oferă control asupra resurselor disponibile shell-ului și proceselor pe care
    acesta le creează, pe sisteme care permit un astfel de control.
    
    Opțiuni:
      -S	utilizează limita de resurse „soft”
      -H	utilizează limita de resurse „hard”
      -a	sunt raportate toate limitele curente
      -b	dimensiunea memoriei tampon a soclului
      -c	dimensiunea maximă a fișierelor create cu conținutul memoriei (core)
      -d	dimensiunea maximă a segmentului de date al unui proces
      -e	prioritatea maximă de planificare („nice”)
      -f	dimensiunea maximă a fișierelor scrise de shell și subprocesele sale
      -i	numărul maxim de semnale în așteptare
      -k	numărul maxim de Kcozi alocate pentru acest proces
      -l	dimensiunea maximă pe care un proces o poate bloca în memorie
      -m	cantitatea maximă de memorie fizică a unui proces
      -n	numărul maxim de descriptori de fișier deschise
      -p	dimensiunea memoriei tampon a liniei de conectare
      -q	numărul maxim de octeți din cozile de mesaje POSIX
      -r	prioritatea maximă a procesului în timp real
      -s	dimensiunea maximă a stivei
      -t	cantitatea maximă de timp a CPU-ului în secunde
      -u	numărul maxim de procese ale utilizatorului
      -v	dimensiunea memoriei virtuale
      -x	numărul maxim de blocări ale fișierelor
      -P	numărul maxim de pseudoterminale
      -R	timpul maxim pe care îl poate rula un proces în timp real înainte
        	de blocare
      -T	numărul maxim de fire(threads)
    
    Nu toate opțiunile sunt disponibile pe toate platformele.
    
    Dacă se dă LIMITA, aceasta este noua valoare a resursei specificate;
    valorile speciale de LIMITĂ: „soft”, „hard” și „unlimited” reprezintă
    limita curentă maleabilă, limita curentă dură și, respectiv, fără limită.
    Altminteri, este afișată valoarea curentă a resursei specificate. Dacă
    nu este dată nicio opțiune, atunci se presupune „-f”.
    
    Valorile sunt în incremente de 1024 de octeți, cu excepția lui „-t”, care
    este în secunde;
    „-p”, care este în incremente de 512 octeți; „-R”, care este în microseconde;
    „-b”, care este în octeți; și „-e”, „-i”, „-k”, „-n”, „-q”, „-r”, „-u”, „-x”,
    și „-P”, care acceptă valori nescalate.
    
    În modul posix, valorile furnizate cu „-c” și „-f” sunt în incremente de
    512 octeți.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizată o opțiune
    nevalidă sau apare o eroare.Mută procesul în primul plan.
    
    Plasează procesul identificat de ID_PROC în primul plan, făcându-l procesul
    curent.  Dacă ID_PROC nu este prezent, este utilizată noțiunea shell-ului
    despre procesul curent
    
    Starea de ieșire:
    Starea comenzii plasată în prim-plan sau eșec dacă apare o eroare.Mută procesul în fundal.
    
    Plasează procesele identificate de fiecare ID_PROC în fundal, ca și cum ar fi
    fost pornite cu „&”.  Dacă ID_PROC nu este prezent, se folosește noțiunea
    shell-ului despre procesul curent.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care controlul procesului nu este
    activat sau apare o eroare.Comandă nulă.
    
    Fără efect; comanda nu face nimic.
    
    Starea de ieșire:
    Întotdeauna reușește(0).variabila $OLDPWD nu este definităAnalizează argumentele opțiunii.
    
    «getopts» este folosit de procedurile shell pentru a analiza parametrii
    poziționali ca opțiuni.
    
    ȘIR_OPȚIUNI conține literele de opțiune care trebuie recunoscute; dacă
    o literă este urmată de două puncte, se așteaptă ca opțiunea să aibă un
    argument, care ar trebui să fie separat de aceasta prin spațiu alb.
    
    De fiecare dată când este invocată, «getopts» va plasa următoarea opțiune
    în variabila shell $nume, inițializând nume dacă nu există, iar indexul
    următorului argument va fi procesat în variabila shell OPTIND.  OPTIND este
    inițializată la 1 de fiecare dată când shell-ul sau un script shell este
    invocat.  Când o opțiune necesită un argument, «getopts» plasează acel
    argument în variabila shell OPTARG.
    
    «getopts» raportează erorile într-unul dintre următoarele două moduri.  Dacă
    primul caracter al lui  ȘIR_OPȚIUNI este două puncte, «getopts» utilizează 
    raportarea silențioasă a erorilor.  În acest mod, nu este afișat niciun mesaj
    de eroare.  Dacă se găsește o opțiune nevalidă, «getopts» plasează caracterul
    de opțiune găsit în OPTARG.  Dacă nu este găsit un argument necesar, «getopts»
    plasează un „:” în NUME și pune în OPTARG caracterul de opțiune găsit.  Dacă
    «getopts» nu este în modul silențios și se găsește o opțiune nevalidă, «getopts»
    plasează „?” în NUME și dezactivează OPTARG.  Dacă nu este găsit un argument
    necesar, un „?” este plasat în NUME, OPTARG este dezactivată și este afișat un
    mesaj de diagnosticare.
    
    Dacă variabila shell OPTERR are valoarea 0, «getopts» dezactivează afișarea
    mesajelor de eroare, chiar dacă primul caracter al lui  ȘIR_OPȚIUNI nu este 
    două puncte „:”.  OPTERR are valoarea 1 implicit.
    
    «getopts» analizează în mod normal parametrii de poziție, dar dacă argumentele
    sunt furnizate ca valori ARG, acestea sunt analizate în schimb.
    
    Starea de ieșire:
    Returnează succes dacă este găsită o opțiune; eșuează dacă se întâlnește
    sfârșitul opțiunilor sau apare o eroare.Imprimă numele directorului de lucru curent.
    
    Opțiuni:
      -L	imprimă valoarea lui $PWD dacă aceasta numește directorul de
    		lucru curent
      -P	imprimă directorul fizic, fără nicio legătură simbolică
    
    În mod implicit, „pwd” se comportă ca și cum „-L” ar fi fost specificat.
    
    Starea de ieșire:
    Returnează 0, cu excepția cazului în care este dată o opțiune nevalidă
    sau directorul curent nu poate fi citit.PărăsireCitește o linie din intrarea standard și o împarte în câmpuri.
    
    Citește o singură linie din intrarea standard sau din descriptorul de fișier
    FD dacă este furnizată opțiunea -u.  Linia este împărțită în câmpuri ca în
    cazul împărțirii cuvintelor, iar primul cuvânt este atribuit primului NUME, 
    al doilea cuvânt celui de-al doilea NUME și așa mai departe, ultimul NUME
    preluând lista cuvintelor rămase.  Doar caracterele găsite în $IFS sunt
    recunoscute ca delimitatori de cuvinte. În mod implicit, caracterul bară oblică
    inversă eludează caracterele delimitatoare și linia nouă.
    
    Dacă nu sunt furnizate NUME, linia citită este stocată în variabila REPLY.
    
    Opțiuni:
      -a matrice
    		atribuie cuvintele citite indicilor secvențiali ai variabilei
    		matrice MATRICE, începând de la zero
      -d delim	continuă până când este citit primul caracter din DELIM, în loc
    		de linia nouă
      -e	utilizează Readline pentru a obține linia

      -E	utilizează Readline pentru a obține linia și utilizează completarea
    		implicită bash în locul completării implicite a Readline
      -i text	utilizează TEXT ca text inițial pentru Readline
      -n ncarac	returnează după citirea a NCARAC caractere în loc să aștepte
    		o nouă linie, dar respectă delimitatorul dacă sunt citite mai
    		puțin de NCARAC caractere înainte de delimitator
      -N ncarac	returnează numai după citirea exactă a NCARAC caractere, cu
    		excepția cazului în care se întâlnește sfârșitul fișierului sau 
    		dacă timpul de citire expiră, eliminând orice delimitatori
      -p prompt	afișează șirul PROMPT fără un caracter de linie nouă la final,
    		înainte de a încerca să citească
      -r	nu permite barelor oblice inverse să eludeze niciun caracter
      -s	nu afișează ieșirea ce vine de la un terminal
      -t timeout
    		expiră și returnează un cod de eroare dacă o linie completă de
    		intrare nu este citită în TIMEOUT secunde.  Valoarea variabilei
    		TIMEOUT este timpul de expirare implicit.  TIMEOUT poate fi un
    		număr fracțional.  Dacă TIMEOUT este zero, citirea se termină
    		imediat fără a încerca să citească date, și returnează un cod de
    		succes numai dacă intrarea este disponibilă pe descriptorul de
    		fișier specificat.  Starea de ieșire este mai mare de 128 dacă
    		timpul de expirare este depășit
      -u fd	citește din descriptorul de fișier FD în loc de intrarea standard
    
    Starea de ieșire:
    Codul de returnare este zero, cu excepția cazului în care se întâlnește
    sfârșitul fișierului, expirarea timpului de citire (caz în care este mai mare
    de 128), apare o eroare de atribuire a variabilei sau este furnizat un
    descriptor de fișier nevalid ca argument pentru opțiunea „-u”.Citește linii dintr-un fișier într-o variabilă de tip matrice.
    
    Un sinonim pentru «mapfile».Citește linii de la intrarea standard într-o variabilă matrice indexată.
    
    Citește linii de la intrarea standard în variabila matrice indexată MATRICE,
    sau din descriptorul de fișier „FD” dacă este furnizată opțiunea „-u”.
    Variabila MAPFILE este MATRICEA implicită.
    
    Opțiuni:
      -d delim  Utilizează DELIM pentru a termina liniile, în loc de linie nouă
      -n număr  Copiază cel mult NUMĂRul de rânduri. Dacă NUMĂR este 0,
                toate liniile sunt copiate
      -O origin Începe alocarea către MATRICE la indexul ORIGIN.  Indicele
                implicit este 0
      -s count  Renunță la primele COUNT rânduri citite
      -t        Elimină un DELIM final din fiecare linie citită (implicit,
                linie nouă)
      -u fd     Citește linii din descriptorul de fișier „FD” în loc de la
                intrarea standard
      -C apelare
                Evaluează APELARE de fiecare dată când sunt citite linii CANTITATE
      -c cantitate
                Specifică numărul de linii citite între fiecare apel către APELARE
    
    Argumente:
      MATRICE	Nume variabilă matrice de utilizat pentru datele fișierului
    
    Dacă „-C” este furnizată fără „-c”, cantitatea implicită este 5000.  Când se
    evaluează APELARE, i se furnizează indexul următorului element din matrice
    care urmează să fie atribuit și linia care urmează să fie atribuită
    acelui element ca argumente suplimentare.
    
    Dacă nu este furnizat cu o origine explicită, «mapfile» va șterge MATRICE
    înainte de a-o utiliza pentru asignare.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau MATRICE este protejată la scriere sau nu este o matrice indexată.Blocare înregistrareMemorizează sau afișează locațiile programelor.
    
    Determină și memorizează ruta completă a fiecărei comenzi NUME.  Dacă nu
    sunt date argumente, sunt afișate informații despre comenzile memorate.
    
    Opțiuni:
      -d	uită locația reținută pentru fiecare NUME
      -l	afișează într-un format care poate fi reutilizat ca intrare
      -p rută-nume
        	utilizează RUTĂNUME drept ruta completă a NUME
      -r	uită toate locațiile memorizate
      -t	afișează locația reținută a fiecărui NUME, precedând fiecare
    		locație cu NUMELE corespunzător dacă sunt date mai multe NUME
    Argumente:
      NUME	Fiecare NUME este căutat în $PATH și adăugat la lista comenzilor
    		memorate.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care NUME nu este găsit sau
    este dată o opțiune nevalidă.Elimină directoare din stivă.
    
    Elimină intrările din stiva de directoare. Fără argumente, elimină
    directorul de sus din stivă, și trece la noul director de sus.
    
    Opțiuni:
      -n	Suprimă schimbarea normală a directorului atunci când se elimină
    		directoare la stivă, astfel încât numai stiva este manipulată.
    
    Argumente:
      +N	Elimină intrarea a N-a numărând din stânga listei afișate
    		de «dirs», începând cu zero.  De exemplu: «popd +0»
    		elimină primul director, «popd +1» al doilea.
    
      -N	Elimină intrarea a N-a numărând din dreapta listei afișate
    		de «dirs», începând cu zero.  De exemplu: «popd -0»
    		elimină ultimul director, «popd -1» penultimul.
    
    Comanda internă «dirs» afișează stiva de directoare.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizat un argument
    nevalid sau dacă schimbarea directorului eșuează.Elimină fiecare NUME din lista de aliasuri definite.
    
    Opțiuni:
      -a	elimină toate definițiile de alias
    
    Returnează succes, cu excepția cazului în care un NUME nu este un alias existent.Elimină procese din shell-ul actual.
    
    Elimină fiecare argument ID_PROC din tabelul de procese active.  Fără
    niciun ID_PROC, shell-ul folosește noțiunea sa de proces curent.
    
    Opțiuni:
      -a	elimină toate procesele dacă ID_PROC nu este furnizat
      -h	marchează fiecare ID_PROC astfel încât SIGHUP să nu fie trimis
    		la proces dacă shell-ul primește un semnal SIGHUP
      -r	elimină numai procesele care rulează
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau ID_PROC.Elimină intrările din stiva de directoare.  Fără argumente, elimină directorul
    din partea de sus a stivei, și trece la cel cea devenit noul director de sus
    a stivei.
    
    Opțiuni:
      -n	Suprimă schimbarea normală a directorului atunci când se elimină
    	directoare din stivă, astfel încât numai stiva este manipulată.
    
    Argumente:
      +N	Elimină intrarea a N-a numărând din stânga listei afișate de «dirs»,
    	începând cu zero.  De exemplu: «popd +0» elimină primul director,
    	«popd +1» al doilea director, șamd.
    
      -N	Elimină intrarea a N-a numărând din dreapta listei afișate de «dirs»,
    	începând cu zero.  De exemplu: «popd -0» elimină ultimul director,
    	„popd -1” penultimul director, șamd.
    
    Comanda internă «dirs» arată stiva curentă de directoare.Înlocuiește shell-ul cu comanda dată.
    
    Execută COMANDA, înlocuind acest shell cu programul specificat.
    ARGUMENTELE devin argumente pentru COMANDA.  Dacă COMANDA nu este
    specificată, orice redirecționare va avea efect în shell-ul curent.
    
    Opțiuni:
      -a nume	pasează NUME ca argument zero la COMANDA
      -c	execută COMANDA într-un mediu gol
      -l	plasează o liniuță în argumentul zero la COMANDA
    
    Dacă comanda nu poate fi executată, un shell non-interactiv se va închide, 
    cu excepția cazului în care opțiunea shell „execfail” este setată.
    
    Starea de ieșire
    Returnează succes, cu excepția cazului în care COMANDA nu este găsită sau
    apare o eroare de redirecționare.Raportează timpul consumat de execuția secvenței de comenzi.
    
    Execută SECVENȚA_DE_COMENZI și imprimă un rezumat al timpului real,
    al timpului CPU al utilizatorului și al timpului CPU al sistemului
    petrecut executând SECVENȚA_DE_COMENZI atunci când aceasta termină.
    
    Opțiuni:
      -p	afișează rezumatul cronometrajului în formatul Posix portabil
    
    Valoarea variabilei TIMEFORMAT este utilizată drept format de ieșire.
    
    Starea de ieșire:
    Starea de returnare este starea de returnare a SECVENȚEI_DE_COMENZI.Reia buclele for, while, sau until.
    
    Reia următoarea iterație a buclei curente FOR, WHILE sau UNTIL.
    Dacă se specifică N, reia bucla și continuă pentru N niveluri în continuare.
    
    Starea de ieșire:
    Starea de ieșire este 0, cu excepția cazului în care N nu este mai mare sau egal cu 1.Reia lucrarea în prim-plan.
    
    Echivalent cu argumentul JOB_SPEC al comenzii «fg».  Reia o lucrare
    oprită sau în fundal.  JOB_SPEC poate specifica fie un nume de lucrare,
    fie un număr de lucrare.  JOB_SPEC urmat de un „&” plasează lucrarea
    în fundal, ca și cum specificația lucrării ar fi fost furnizată ca argument
    pentru «bg».
    
    Starea de ieșire:
    Returnează starea lucrării reluate.Returnează un rezultat de succes(0).
    
    Starea de ieșire:
    Întotdeauna reușește(0).Returnează un rezultat nereușit(≠0).
    
    Starea de ieșire:
    Întotdeauna eșuează(≠0).Returnează dintr-o funcție shell.
    
    Determină ieșirea unei funcții sau a unui script sursă cu valoarea de
    returnare specificată de N.  Dacă N este omis, starea de returnare
    este cea a ultimei comenzi executate în funcție sau script.
    
    Starea de ieșire:
    Returnează N sau eșec dacă shell-ul nu execută o funcție sau un script.Returnează contextul apelului subrutinei curente.
    
    Fără EXPR, returnează „$line $filename”. Cu EXPR, returnează
    „$line $subroutine $filename”; aceste informații suplimentare pot fi
    utilizate pentru a furniza o urmărire a stivei.
    
    Valoarea EXPR indică câte cadre de apel trebuie să se întoarcă înaintea
    celui curent; cadrul superior este cadrul 0.
    
    Starea de ieșire:
    Returnează 0, cu excepția cazului în care shell-ul nu execută o funcție shell
    sau EXPR nu este validă.Returnează contextul apelului subrutinei curente.
    
    Fără EXPR, returnează „$line $filename”. Cu EXPR, returnează
    „$line $subroutine $filename”; aceste informații suplimentare pot fi
    utilizate pentru a furniza o urmărire a stivei.
    
    Valoarea EXPR indică câte cadre de apel trebuie să se întoarcă înaintea
    celui curent; cadrul superior este cadrul 0.
    
    Starea de ieșire:
    Returnează 0, cu excepția cazului în care shell-ul nu execută o funcție shell
    sau EXPR nu este validă.În rulareEroare de segmentareSelectează cuvinte dintr-o listă și execută comenzi.
    
    CUVINTELE sunt expandate, generând o listă de cuvinte.  Setul
    de cuvinte expandate este afișat la ieșirea de eroare standard,
    fiecare precedat de un număr.  Dacă „în CUVINTE” nu este prezent,
    se presupune „in "$@"”.  Se afișează apoi promptul PS3 și se citește
    o linie de la intrarea standard.  Dacă linia constă din numărul
    corespunzător unuia dintre cuvintele afișate, atunci se definește NUME
    ca acest cuvânt.  Dacă linia este goală, CUVINTE și promptul sunt
    reafișate.  Dacă este citit sfârșitul fișierului(EOF), comanda se
    finalizează.  Orice altă valoare citită face ca NUME să fie definit ca
    null.  Linia citită este salvată în variabila „REPLY”.  COMENZILE sunt
    executate după fiecare selecție până când este executată o comandă
    de întrerupere(break).
    
    Starea de ieșire:
    Returnează starea ultimei comenzi executate.Trimite un semnal către un proces.
    
    Trimite proceselor identificate prin PID sau JOBSPEC semnalul numit de
    SIGSPEC sau de SIGNUM.  Dacă nici SIGSPEC, nici SIGNUM nu sunt
    prezente, atunci se presupune SIGTERM.
    
    Opțiuni:
      -s sig	SIG este un nume de semnal
      -n sig	SIG este un număr de semnal
      -l	listează numele semnalelor; dacă după „-l” urmează argumente, se
    		presupune că sunt numere de semnal pentru care ar trebui listate
    		nume
      -L	sinonim cu -l
    
    Kill este o comandă internă de shell din două motive: permite utilizarea
    ID-urilor de job în locul ID-urilor de proces și permite omorârea proceselor
    dacă este atinsă limita de procese pe care le puteți crea.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau apare o eroare.Configurează legăturile de taste și variabilele Readline.
    
    Asociază o secvență de taste cu o funcție Readline sau cu o macrocomandă
    sau configurează o variabilă Readline.  Sintaxa argumentului fără opțiune 
    este echivalentă cu cea găsită în ~/.inputrc, dar trebuie transmisă ca un
    singur argument; de exp.: bind '"\C-x\C-r": re-read-init-file'.
    
    Opțiuni:
      -m  keymap         Utilizează KEYMAP ca hartă de taste pe durata acestei
                         comenzi.  Numele valabile pentru hărți de taste sunt emacs,
                         emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,
                         vi-command, și vi-insert.
      -l                 Enumeră numele funcțiilor.
      -P                 Enumeră numele și asocierile funcțiilor.
      -p                 Enumeră funcțiile și asocierile într-o formă care poate fi
                         reutilizată ca intrare.
      -S                 Enumeră secvențele de chei care invocă macrocomenzi și
                         valorile acestora
      -s                 Enumeră secvențele de chei care invocă macrocomenzi și
                         valorile acestora într-o formă care poate fi reutilizată ca intrare.
      -V                 Enumeră numele și valorile variabilelor
      -v                 Enumeră numele și valorile variabilelor într-o formă care
                         poate fi reutilizată ca intrare.
      -q  nume-funcție   Se utilizează pentru a afla care taste invocă funcția numită.
      -u  nume-funcție   Dezasociază toate tastele care sunt asociate cu funcția numită.
      -r  sec-taste      Elimină asocierea pentru sec-taste numită.
      -f  nume-fișier    Citește asocierile de taste din fișierul al cărui nume a fost dat.
      -x  sec-taste:comandă-shell	Determină executarea comandă-shell când este
    				introdusă sec-taste.
      -X                 Enumeră secvențele de taste asociate cu -x și comenzile asociate într-o
                         formă care poate fi reutilizată ca intrare.
    
    Dacă rămân argumente după procesarea opțiunilor, opțiunile „-p” și „-P” le
    tratează ca nume de comenzi readline și limitează ieșirea la aceste nume.
    
    Starea de ieșire:
    «bind» returnează 0, cu excepția cazului în care este dată o opțiune nerecunoscută, sau apare o eroare.Activează sau dezactivează opțiunile de shell.
    
    Schimbă configurarea fiecărei opțiuni de shell NUME_OPȚIUNE.  Fără
    niciun argument de opțiune, listează fiecare NUME_OPȚIUNE furnizat, 
    sau toate opțiunile de shell dacă nu sunt date NUME_OPȚIUNE, cu o
    indicație dacă fiecare este sau nu definită.
    
    Opțiuni:
      -o	restricționează NUME_OPȚIUNE la cele definite pentru a fi
           	utilizate cu «set -o»
      -p	afișează fiecare opțiune de shell cu o indicație a stării acesteia
      -q	suprimă ieșirea
      -s	activează (definește) fiecare NUME_OPȚIUNE
      -u	dezactivează (șterge) fiecare NUME_OPȚIUNE
    
    Starea de ieșire:
    Returnează succes dacă NUME_OPȚIUNE este activată; eșuează dacă
    este dată o opțiune nevalidă sau NUME_OPȚIUNE este dezactivată.Stabilește atributul de export pentru variabilele shell.
    
    Marchează fiecare NUME pentru export automat în mediul comenzilor executate
    ulterior.  Dacă este furnizată VALOAREA, atribuie VALOAREA înainte de a
    exporta.
    
    Opțiuni:
      -f	se referă la funcțiile shell
      -n	elimină proprietatea de export din fiecare NUME
      -p	afișează o listă cu toate variabilele sau funcțiile exportate
    
    Un argument de „--” dezactivează procesarea ulterioară a opțiunilor.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau NUME nu este valid.Stabilește sau anulează valorile opțiunilor de shell și ale parametrilor
poziționali.
    
    Modifică valoarea atributelor shell și a parametrilor poziționali sau 
    afișează numele și valorile variabilelor shell.
    
    Opțiuni:
      -a  Marchează variabilele care sunt modificate sau create, pentru export.
      -b  Notifică imediat când o sarcină este finalizată.
      -e  Termină imediat dacă o comandă termină cu o stare diferită de zero.
      -f  Dezactivează folosirea metacaracterelor pentru completarea numelor
          fișierelor (fără „globbing”).
      -h  Memorizează locația comenzilor pe măsură ce sunt căutate.
      -k  Toate argumentele de atribuire sunt plasate în mediul(environment)
          unei comenzi, nu doar cele care preced numele comenzii.
      -m  Activează controlul sarcinii.
      -n  Citește comenzile, dar nu le execută.
      -o  nume-opțiune
          Stabilește variabila corespunzătoare → nume-opțiune:
              allexport    la fel ca -a
              braceexpand  la fel ca -B
              emacs        utilizează o interfață de editare a liniilor în
                           stilul «emacs»
              errexit      la fel ca -e
              errtrace     la fel ca -E
              functrace    la fel ca -T
              hashall      la fel ca -h
              histexpand   la fel ca -H
              history      activează istoricul comenzilor
              ignoreeof    shell-ul nu va termina după citirea „EOF”
              interactive-comments
                           permite comentariilor să apară în comenzile interactive
              keyword      la fel ca -k
              monitor      la fel ca -m
              noclobber    la fel ca -C
              noexec       la fel ca -n
              noglob       la fel ca -f
              nolog        acceptat în prezent, dar ignorat
              notify       la fel ca -b
              nounset      la fel ca -u
              onecmd       la fel ca -t
              physical     la fel ca -P
              pipefail     valoarea returnată a unei linii de conectare este
                           starea ultimei comenzi care a ieșit cu o stare diferită
                           de zero sau zero dacă nicio comandă nu a ieșit cu o
                           stare diferită de zero
              posix        modifică comportamentul lui «bash» în cazul în care
                           operația implicită diferă de standardul Posix, pentru
                           a se potrivi cu standardul Posix
              privileged   la fel ca -p
              verbose      la fel ca -v
              vi           utilizează o interfață de editare a liniilor în
                           stilul «vi»
              xtrace       la fel ca -x
      -p  Modul cu privilegii: Activat ori de câte ori ID-urile de utilizator
          reale și efective nu se potrivesc.  Dezactivează procesarea 
          fișierului $ENV și importul funcțiilor shell. Dezactivarea acestei
          opțiuni face ca uid-ul și gid-ul efectiv să fie stabilite la uid-ul și
          gid-ul real
      -t  Termină după citirea și executarea unei comenzi.
      -u  Tratează variabilele nedefinite ca pe o eroare la substituire.
      -v  Afișează liniile de intrare ale shell-ului pe măsură ce sunt citite.
      -x  Afișează comenzile și argumentele lor pe măsură ce sunt executate.
      -B  Shell-ul va efectua înlocuirea acoladelor (de exp.: a{b,c} → ab ac)
      -C  Dacă este specificată, nu permite ca fișierele obișnuite existente să
          fie suprascrise prin redirecționarea ieșirii.
      -E  Dacă este specificată, capturarea ERR este moștenită de funcțiile shell.
      -H  Permite înlocuirea istoricului cu un „!”.  Această opțiune este activată
          în mod implicit atunci când shell-ul este interactiv.
      -P  Dacă este specificată, legăturile simbolice nu sunt urmate la executarea
          comenzilor precum «cd» care schimbă directorul curent.
      -T  Dacă este specificată, capturile DEBUG și RETURN sunt moștenite de
          funcțiile shell.
      --  Atribuie toate argumentele rămase parametrilor de poziție.
          Dacă nu există argumente rămase, parametrii de poziție sunt eliminați.
      -   Atribuie toate argumentele rămase parametrilor de poziție.
          Opțiunile -x și -v sunt dezactivate.
    
    Dacă -o este furnizat fără nume de opțiune, «set» afișează valorile
    curente ale opțiunilor shell-ului. Dacă +o este furnizat fără nume de
    opțiune, «set» afișează o serie de comenzi set pentru a recrea valorile
    actuale ale opțiunilor.
    
    Utilizarea lui „+” în loc de „-”, face ca aceste opțiuni să fie dezactivate.
    Opțiunile pot fi folosite și la invocarea shell-ului.  Setul actual de 
    opțiuni poate fi găsit în $-.  Restul de n ARG sunt parametri poziționali și
    sunt alocați, în ordine, la $1, $2, .. $n.  Dacă nu sunt date ARG, toate 
    variabilele shell sunt afișate.
    
    Starea de ieșire:
    Returnează succes cu excepția cazului în care este dată o opțiune nevalidă.Stabilește valorile și atributele variabilelor.
    
    Un sinonim pentru „declare”.  A se vedea „help declare”.Stabilește valorile și atributele variabilelor.
    
    Declară variabilele și-le atribuie atribute.  Dacă nu sunt date NUME,
    afișează atributele și valorile tuturor variabilelor.
    
    Opțiuni:
      -f	restricționează acțiunea sau afișarea, la numele și definițiile funcțiilor
      -F	restricționează afișarea numai la numele funcțiilor (plus numărul de
    		linie și fișierul sursă, la depanare)
      -g	creează variabile globale atunci când sunt utilizate într-o funcție shell;
    		altfel sunt ignorate
      -I	dacă se creează o variabilă locală, moștenește atributele și valoarea
    		unei variabile cu același nume dintr-un scop anterior
      -p	afișează atributele și valoarea fiecărui NUME
    
    Opțiuni care stabilesc atributele:
      -a	stabilește NUME ca matrice indexată (dacă este acceptat)
      -A	stabilește NUME ca matrice asociativă (dacă este acceptat)
      -i	stabilește ca NUME să aibă atributul „integer”
      -l	pentru a converti valoarea fiecărui NUME în minuscule, la atribuire
      -n	face din NUME o referință la variabila numită după valoarea acesteia
      -r	creează NUME ca numai-citire
      -t	stabilește ca NUME să aibă atributul „trace”
      -u	pentru a converti valoarea fiecărui NUME în majuscule, la atribuire
      -x	pentru a exporta NUME
    
    Utilizarea a „+” în loc de „-”, dezactivează atributul dat, cu excepția
    atributelor a, A și r.
    
    Variabilele cu atributul întreg au o evaluare aritmetică (vezi comanda
    «let») efectuată atunci când variabilei i se atribuie o valoare.
    
    Când este folosită într-o funcție, «declare» face ca NUME să fie local, ca
    și în cazul comenzii «local».  Opțiunea „-g” suprimă acest comportament.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizată o opțiune
    nevalidă sau apare o eroare de atribuire a variabilelor.Comenzile Shell care se potrivesc cu cuvântul cheie „Comenzile Shell care se potrivesc cu cuvintele cheie „Comenzile Shell care se potrivesc cu cuvintele cheie „Opțiuni ale shell-ului:
Schimbă parametrii poziționali.
    
    Redenumește parametrii de poziție $N+1,$N+2 ... la $1,$2 ...  Dacă N
    nu este dat, se presupune că este 1.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care N este negativ sau mai
    mare decât $#.Semnal %dSpecifică modul în care argumentele vor fi completate de Readline.
    
    Pentru fiecare NUME, specifică cum vor fi completate argumentele. Dacă nu
    sunt furnizate opțiuni sau NUME, afișează specificațiile de finalizare
    existente într-un mod care să permită reutilizarea acestora ca intrare.
    
    Opțiuni:
      -p	afișează specificațiile de completare existente într-un format
    		reutilizabil
      -r	elimină o specificație de completare pentru fiecare NUME sau,
    		dacă nu sunt furnizate NUME, toate specificațiile de completare
      -D	aplicați completările și acțiunile ca implicite pentru comenzi
    		fără nicio completare specifică definită
      -E	aplică completările și acțiunile pentru comenzile „goale” --
    		când se încearcă completarea într-o linie goală
      -I	aplică completările și acțiunile la cuvântul inițial (de obicei
    		comanda).
    
    Când se încearcă completarea, acțiunile sunt aplicate în ordinea în care
    opțiunile cu litere mari sunt listate mai sus.  Dacă sunt furnizate mai multe
    opțiuni, opțiunea „-D” are prioritate față de „-E” și ambele au prioritate
    față de opțiunea „-I”.
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este furnizată o opțiune
    nevalidă sau apare o eroare.OpritOprit (semnal)Oprit (tty input)Oprit (tty output)Oprit(%s)Suspendă execuția shell-ului.
    
    Suspendă execuția acestui shell până când primește un semnal SIGCONT.
    Cu excepția cazului în care sunt forțate, shell-urile de autentificare și
    shell-urile fără control al lucrărilor nu pot fi suspendate.
    
    Opțiuni:
      -f	forțează suspendarea, chiar dacă shell-ul este un shell de
        	autentificare
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care controlul sarcinii nu este
    activat sau apare o eroare.TIMEFORMAT: „%c”: caracter de format nevalidTerminatCorespondența din %s a fost citită
Sunt(există) lucrări în execuție.
Sunt(există) lucrări oprite.
NU EXISTĂ NICIO GARANȚIE, în măsura permisă de lege.Aceste comenzi shell, sunt definite intern.  Tastează «help», pentru a vedea
această listă.
Tastează «help nume_funcție» pentru a afla mai multe despre funcția „nume_funcție”.
Utilizați «info bash» pentru a afla mai multe despre shell în general.
Utilizați «man -k» sau «info» pentru a afla mai multe despre comenzile care nu
sunt în această listă.

O stea (*) în dreptul unui nume înseamnă că acea comandă este dezactivată.

Acesta este un software liber; sunteți liber să îl modificați și să îl redistribuiți.Capturează semnale și alte evenimente.
    
    Definește și activează operatorii care urmează să fie rulați atunci când
    shell-ul primește semnale sau apar alte evenimente.
    
    ACȚIUNE este o comandă care trebuie citită și executată atunci când shell-ul
    primește semnalul(ele) SIGNAL_SPEC.  Dacă ACȚIUNEA este absentă (și este
    furnizat un singur SIGNAL_SPEC) sau „-”, fiecare semnal specificat este
    restabilit la valoarea sa originală.  Dacă ACȚIUNEA este un șir nul, fiecare
    SIGNAL_SPEC este ignorat de către shell și de comenzile pe care le invocă.
    
    Dacă un SIGNAL_SPEC este EXIT (0), ACȚIUNEA este executată la ieșirea din
    shell.
    Dacă un SIGNAL_SPEC este DEBUG, ACȚIUNEA este executată înainte de fiecare
    comandă simplă. Dacă un SIGNAL_SPEC este RETURN, ACȚIUNEA este executată de
    fiecare dată când o funcție shell sau un script rulat din . sau comanda
    internă «source» se termină de executat. Un SIGNAL_SPEC de ERR face ca
    ACȚIUNEA să fie executată de fiecare dată când eșecul unei comenzi ar
    determina terminarea shell-ului atunci când opțiunea „-e” este activată. 
    
    Dacă nu sunt furnizate argumente, „trap” afișează lista de comenzi asociate
    fiecărui semnal blocat într-o formă care poate fi reutilizată ca intrare în
    shell pentru a restabili aceleași dispoziții ale semnalului.
    
    Opțiuni:
      -l	afișează o listă de nume de semnale și numerele corespunzătoare
        	ale acestora
      -p	afișează comenzile «trap» asociate cu fiecare SIGNAL_SPEC într-o
    		formă care poate fi reutilizată ca intrare shell; sau pentru toate
    		semnalele capturate dacă nu sunt furnizate argumente
      -P	afișează comenzile «trap» asociate cu fiecare SIGNAL_SPEC. Cel puțin
    		un SIGNAL_SPEC trebuie să fie furnizat. Opțiunile -P și -p nu pot fi
    		utilizate împreună.
    
    Fiecare SIGNAL_SPEC este fie un nume de semnal în <signal.h>, fie un număr
    de semnal.  Numele semnalelor nu fac distincție între majuscule și minuscule,
    iar prefixul SIG este opțional.  Un semnal poate fi trimis către shell cu
    «kill -signal $$».
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care un SIGSPEC este nevalid sau 
    este dată o opțiune nevalidă.Tastați «%s -c "help set"» pentru mai multe informații despre opțiunile shell-ului.
Tastați «%s -c help» pentru mai multe informații despre comenzile interne ale shell-ului.
Semnal necunoscut #%dEroare necunoscutăStare necunoscutăAnulează valorile și atributele variabilelor și funcțiilor shell.
    
    Pentru fiecare NUME, elimină variabila sau funcția corespunzătoare.
    
    Opțiuni:
      -f	tratează fiecare NUME ca pe o funcție shell
      -v	tratează fiecare NUME ca pe o variabilă shell
      -n	tratează fiecare NUME ca referință de nume și anulează variabila
    		în sine, în loc de variabila la care face referire
    
    Fără opțiuni, „unset” încearcă mai întâi să anuleze o variabilă și, dacă
    aceasta nu reușește, încearcă să anuleze o funcție.
    
    Unele variabile nu pot fi anulate; consultați, de asemenea, «readonly».
    
    Starea de ieșire:
    Returnează succes, cu excepția cazului în care este dată o opțiune nevalidă
    sau un NUME este doar pentru citire.Condiție In/Ieș urgentăUtilizare:	%s [GNU opțiune lungă] [opțiune] ...
	%s [GNU opțiune lungă] [opțiune] fișier-script ...
Utilizați „%s” pentru a părăsi shell-ul.
Utilizați comanda «bashbug» pentru a raporta erori.
Semnal utilizator 1Semnal utilizator 2Așteaptă finalizarea lucrării și returnează starea de ieșire.
    
    Așteaptă fiecare proces identificat printr-un ID, care poate fi un ID de
    proces sau o specificație de lucrare și raportează starea de terminare
    a acestuia.  Dacă ID-ul nu este dat, așteaptă toate procesele secundare
    active în prezent și starea de returnare este zero.  Dacă ID-ul este o
    specificație de lucrare, așteaptă toate procesele din secvența de comenzi
    respectivă a lucrării.
    
    Dacă este furnizată opțiunea „-n”, așteaptă o singură lucrare din lista de
    ID-uri sau, dacă nu sunt furnizate ID-uri, pentru finalizarea următoarei
    lucrări și returnează starea de ieșire.
    
    Dacă este furnizată opțiunea „-p”, identificatorul de proces sau de lucrare al
    lucrării pentru care este returnată starea de ieșire este atribuit variabilei
    VAR numită de argumentul opțiunii.  Variabila va fi anulată inițial, înainte
    de orice atribuire.  Acest lucru este util numai atunci când este furnizată
    opțiunea „-n”.
    
    Dacă este furnizată opțiunea „-f” și controlul lucrării este activat, 
    așteaptă ca ID-ul specificat să se termine, în loc să aștepte ca acesta să
    își schimbe starea.
    
    Starea de ieșire:
    Returnează starea ultimului ID; eșuează dacă ID-ul este nevalid sau este
    dată o opțiune nevalidă sau dacă „-n” este furnizată și shell-ul nu are
    niciun copil pe care să-l aștepte.Așteaptă finalizarea procesului și returnează starea de ieșire.
    
    Așteaptă fiecare proces specificat de un PID și raportează starea de terminare a
    acestuia.  Dacă nu este dat PID, așteaptă toate procesele copil active în prezent,
    iar starea returnată este zero.  PID trebuie să fie un ID de proces.
    
    Starea de ieșire:
    Returnează starea ultimului PID; eșuează dacă PID este nevalid sau este dată
    o opțiune nevalidă.Fereastră schimbatăScrie argumente la ieșirea standard.
    
    Afișează ARGumentele la ieșirea standard urmate de o linie nouă.
    
    Opțiuni:
      -n	nu adaugă o nouă linie
    
    Starea de ieșire:
    Returnează succes cu excepția cazului în care apare o eroare de scriere.Scrie argumente la ieșirea standard.
    
    Afișează ARGumentele, separate printr-un singur caracter de spațiu și urmate
    de o nouă linie, în ieșirea standard.
    
    Opțiuni:
      -n	nu adaugă o nouă linie
      -e	activează interpretarea următoarelor eludări de bară oblică inversă
      -E	suprimă în mod explicit interpretarea eludărilor de bară oblică inversă
    
    «echo» interpretează următoarele caractere de eludare de bară oblică inversă:
      	alertă (clopoțel)
      \b	mută cursorul înapoi cu unul sau mai multe spații
      \c	suprimă ieșirea ulterioară
      \e	caracter de eludare
      \E	caracter de eludare
      \f	alimentare cu „hîrtie”
      \n	linie nouă
      \r	returul de caret↵
      \t	tabulator orizontal
      \v	tabulator vertical
      \\	bară oblică inversă
      \0nnn	caracterul al cărui cod ASCII este NNN (octal).  NNN poate fi
    		de la 0 la 3 digiți octali
      \xHH	caracterul de opt biți a cărui valoare este HH (hexazecimal). HH
    		poate fi unu sau doi digiți hexazecimali
      \uHHHH	caracterul Unicode a cărui valoare este valoarea hexazecimală HHHH.
    		HHHH poate fi de la unu până la patru digiți hexazecimali.
      \UHHHHHHHH caracterul Unicode a cărui valoare este valoarea hexazecimală
    		HHHHHHHH. HHHHHHHH poate fi de la unu până la opt digiți hexazecimali.
    
    Starea de ieșire:
    Returnează succes cu excepția cazului în care apare o eroare de scriere.Aveți corespondență în $_Aveți corespondență nouă în $_[ arg... ][[ expresie ]]„%c”: comandă incorectă„%c”: caracter de format nevalid„%c”: caracter de mod simbolic nevalid„%c”: operator de mod simbolic nevalid„%c”: specificație a formatului de timp nevalidă„%s”: atribuirea nu poate fi ștearsă„%s”: nu se poate înlătura combinația de taste atribuită la comandă„%s”: nume alias nevalid`%s': nume de combinație de taste nevalid„%s”: nume de variabilă nevalid pentru referință la nume„%s”: este o comandă internă specială„%s”: lipsește caracterul de format„%s”: nu este un pid sau o specificație validă de lucru„%s” nu este un identificator valid„%s”: nume de funcție necunoscutse aștepta „)'”se aștepta „)”, s-a găsit %sse aștepta „:” după expresia condiționalăadd_process: pid %5ld (%s) marcat ca încă în viațăalias [-p] [nume[=valoare] ... ]all_local_variables: nu există context de funcție în domeniul actualredirecționare ambiguăargumentse aștepta un parametrueroare de sintaxă aritmetică în expresieeroare de sintaxă aritmetică în atribuirea variabileieroare de sintaxă aritmetică: operator aritmetic nevalideroare de sintaxă aritmetică: se aștepta un operandeste necesar suport pentru variabilă matrices-a încercat asignare către non-variabilăindice de matrice greșittip de comandă greșitconector greșitinterpret greșitsalt eronatînlocuire greșită: fără „`” de închidere în %sînlocuire greșită: nu se închide „%s” în %sPagina principală a lui „bash”: <http://www.gnu.org/software/bash>
bash_execute_unix_command: nu se poate găsi combinația de taste pentru comandăbg [id_lucrare ...]bgp_delete: BUCLĂ: psi (%d) == storage[psi].bucket_nextbgp_search: BUCLĂ: psi (%d) == storage[psi].bucket_nextbind [-lpsvPSVX] [-m comb_taste] [-f nume_fișier] [-q nume] [-u nume] [-r secv_taste] [-x secv_taste:comandă_shell] [secv_taste:funcție-readline sau comandă-readline]expansiunea de acolade: nu se poate aloca memorie pentru %sexpansiunea de acolade: a eșuat alocarea memoriei pentru %s elementeexpansiunea de acolade: a eșuat alocarea memoriei pentru „%s”break [n]eroare: simbol de atribuire al expresiei greșitbuiltin [comandă_internă-shell [arg ...]]caller [expr]„return”, se poate utiliza doar de la o funcție sau script executat(ă) de la „source”poate fi folosit doar într-o funcțienu se poate aloca un nou descriptor de fișier pentru intrarea bash din fd %dnu se poate atribui descriptorul de fișier variabileinu se poate schimba parametrul de limbănu s-a putut creanu se poate crea un fișier temporar pentru «here-document»nu se poate duplica descriptorul de fișier %d în descriptorul de fișier %dnu se poate duplica linia de conectare numită %s ca fd %dnu se poate executanu se poate executa fișierul binarnu se poate găsi %s în obiectul partajat %s: %snu se poate obține limitanu se poate crea un proces-copil pentru substituția de comandănu se poate crea un proces-copil pentru substituirea procesului: %snu se poate crea linia de conectare pentru substituția de comandănu se poate crea linia de conectare pentru substituția procesuluinu se poate modifica limitanu se poate deschidenu se poate deschide linia de conectare numită %s pentru citirenu se poate deschide linia de conectare numită %s pentru scrierenu poate deschide obiectul partajat %s: %snu se poate deschide fișierul temporalnu se poate suprascrie fișierul existentnu s-a putut citiinu se poate redirecționa intrarea standard de la /dev/nullnu se poate redefini modul „nodelay” pentru descriptorul de fișier %dnu se pot activa și dezactiva simultan opțiunile de shellnu se poate stabili gid la %d: gid efectiv %dnu se poate configura grupul de procese din terminal (%d)nu se poate stabili uid la %d: uid efectiv %dnu se pot anula simultan o funcție și o variabilănu se poate porni depanatorul; modul de depanare a fost dezactivatnu se poate suspendanu se poate suspenda un shell de autentificarenu se poate utiliza „-f” pentru a face funcțiinu se poate folosi mai mult de o opțiune dintre „-a, -n, -r sau -w”case CUVÂNT in [MODEL[[MODEL]..) COMENZI ;;]... esaccd [-L|[-P [-e]]] [-@] [dir]setpgid proces-copil (de la %ld la %ld)command [-pVv] comandă [arg ...]comandă negăsităsubstituție de comandă: octetul null din intrare este ignoratcommand_substitute: nu se poate duplica linia de conectare ca descriptor de fișier 1(fd 1)compgen [-V nume-variabilă] [-abcdefgjksuv] [-o opțiune] [-A acțiune] [-G tipar_glob] [-W listă_cuvinte] [-F funcție] [-C comandă] [-X tipar_filtru] [-P prefix] [-S sufix] [cuvânt]complete [-abcdefgjksuv] [-pr] [-DEI] [-o opțiune] [-A acțiune] [-G tipar_glob] [-W listă_cuvinte] [-F funcție] [-C comandă] [-X tipar_filtru [- P prefix] [-S sufix] [nume ...]completare: funcția „%s” nu a fost găsităcompopt [-o|+o opțiune] [-DEI] [nume ...]se aștepta operator binar condiționalcontinue [n]coproc [NUME] comanda [redirecționări]nu s-a putut găsi «/tmp», vă rugăm să-l creați!cprintf: „%c”: caracter de format nevalidactualdeclare [-aAfFgiIlnrtux] [nume[=valoare] ...] sau declare -p [-aAfFilnrtux] [nume ...]se șterge lucrarea oprită %d cu grupul de procese %lddescribe_pid: %ld: nu există un asemenea pidstiva de directoare este goalăindexul stivei de directoaredirs [-clpv] [+N] [-N]disown [-h] [-ar] [id_lucrare ... | pid ...]împărțire la 0încărcarea dinamică nu este disponibilăecho [-n] [arg ...]echo [-neE] [arg ...]nume de variabilă matrice golnume de fișier golenable [-a] [-dnps] [-f nume_fișier]] [nume ...]eroare la crearea fluxului cu memorie tamponeroare la obținerea atributelor terminaluluieroare în importarea definiției funcției pentru „%s”eroare la obținerea directorului curenteroare la configurarea atributelor terminaluluieval [arg ...]eval: s-a depășit nivelul maxim de suprapunere de «eval» (%d)exec [-cl] [-a nume] [comandă [argument ...]] [redirectare ...]execute_coproc: coproc [%d:%s] încă existăexit [n]se aștepta „)”exponent mai mic de 0export [-fn] [nume[=valoare] ...] sau export -p [-f]se așteaptă expresienivel de recursivitate al expresiei depășitfc [-e enume] [-lnr] [prim] [ultim] sau fc -s [pat=rep] [comandă]fg [id_lucrare]descriptor de fișier în afara intervaluluieste necesar argumentul nume_de_fișierfor (( exp1; exp2; exp3 )); do COMENZI; donefor NUME [in CUVINTE ... ] ; do COMENZI; donepid-ul bifurcat %d apare în lucrarea în execuție %dproblemă cu analizarea formatului: %scadrul nu a fost găsitfree: apelat cu un argument bloc deja eliberatfree: apelat cu un argument de bloc nealocatfree: dimensiunile bucăților de început și de sfârșit sunt diferitefree: s-a detectat o depășire insuficientă; magic8 coruptfree: s-a detectat o depășire insuficientă; mh_nbytes în afara intervaluluifunction nume { COMENZI ; } sau nume () { COMENZI ; }function_substitute: nu se poate duplica fișierul anonim ca ieșire standardfunction_substitute: nu se poate deschide un fișier anonim pentru ieșireversiunile viitoare ale shell-ului vor forța evaluarea ca o substituție aritmeticăgetcwd: nu s-au putut accesa directoarele părintegetopts șir_opțiuni nume [arg ...]hash [-lr] [-p nume_rută [-dt] [nume ...]asocierea este desactivatăhelp [-dms] [tipar ...]ajutorul nu este disponibil în această versiune«here-document» la linia %d delimitat de sfârșitul fișierului (se aștepta „%s”)history [-c] [-d decalaj] [n] sau history -anrw [nume_fișier] sau history -ps arg [arg...]poziție în registrul istoric al comenzilorspecificație de istoricpotriviri	comandă
se aștepta un identificator după pre-increment sau pre-decrementif COMENZI; then COMENZI; [elif COMENZI; then COMENZI; ]... [ else COMENZI; ] fiinitialize_job_control: getpgrp a eșuatinitialize_job_control: disciplină linieinitialize_job_control: nu există control de lucrări în fundalinitialize_job_control: setpgidbază aritmetică nevalidăbază nevalidăcaracter nevalid %d în exportstr pentru %sdescriptor de fișier nevalidtip de sortare globală (folosind caractere joker) nevalidnumăr hexazecimal nevalidconstantă de număr întreg nevalidănumăr nevalidnumăr octal nevalidexpresie regulată nevalidă „%s”expresie regulată nevalidă „%s”: %snumăr de semnal nevalidlucrarea %d a început fără controlul lucrăriiid_lucrare [&]jobs [-lnprs] [id_lucrare ...] sau jobs -x comandă [args]kill [-s id_semnal | -n num_semnal | -id_semnal] pid | id_lucrare ... sau kill -l [id_semnal]ultima comandă: %s
let arg [arg ...]limitălinia %d: editarea liniilor nu este activatăfuncția de încărcare pentru %s returnează eroarea (%d): încărcarea a eșuatlocal [opțiune] nume[=valoare] ...deautentificare
logout [n]contor buclămake_here_document: tip de instrucțiune greșit %dmake_local_variable: nu există context de funcție în domeniul actualmake_redirection: instrucțiunea de redirecționare „%d” este în afara intervaluluimalloc: bloc suprascris pe lista liberămalloc: a eșuat aserțiunea: %s
mapfile [-d delim] [-n cont] [-O origin] [-s cont] [-t] [-u fd] [-C apelare] [-c cantitate] [matrice]numărul maxim de «here-document» a fost depășitmigrare proces spre alt CPU„)” lipseștelipsește „]”lipsește o cifră hexazecimală pentru \xlipsește o cifră unicode pentru \%coperațiunile de rețea nu sunt acceptatenu există „=” în exportstr pentru %snu se închide „%c” în %snu s-a găsit nici-o comandăniciun subiect de ajutor nu se potrivește cu „%s”.  Încercați «help help» sau «man -k %s» sau «info %s».nu există un control de lucrărinu există niciun control de lucrări în acest shellnicio potrivire: %sniciun alt directornu sunt permise alte opțiuni cu „-x”în prezent funcția de completare nu ruleazănu este un shell de autentificare: utilizați „exit”director nulnumăr octalare sens numai într-o buclă „for”, „while” sau „until”eroare de linie de conectarepop_scope: partea de sus din shell_variables nu este un domeniu de mediu temporarpop_var_context: partea de sus din shell_variables nu este un context de funcțiepop_var_context: nu există un context global_variablespopd [-n] [+N | -N]probleme electrice iminentemodul de imprimare „drăguț” este ignorat în shell-urile interactiveprint_command: conector greșit „%d”printf [-v var] format [argumente]progcomp_insert: %s: COMPSPEC nullprogramable_completion: %s: posibilă buclă de reîncercareeroare de programarepushd [-n] [+N | -N | dir]pwd [-LP]read [-Eers] [-a matrice] [-d delim] [-i text] [-n nr_carac] [-N nr_carac [-p prompt] [-t timp-limită] [-u fd] [nume ...]eroare de citirereadarray [-d delim] [-n cantitate] [-O origine] [-s cantitate] [-t] [-u fd] [-C apelare] [-c sumă_de] [matrice]readonly [-aAf] [nume[=valoare] ...] sau readonly -prealloc: apelat cu un argument de bloc nealocatrealloc: dimensiunile bucăților de început și de sfârșit, diferărealloc: s-a detectat o depășire insuficientă; magic8 coruptrealloc: s-a detectat o depășire insuficientă; mh_nbytes țn afara intervaluluistivă recursivă sub nivelul de depășireeroare de redirectare: nu se poate duplica descriptorul de fișierregister_alloc: %p deja în tabel ca fiind alocat?
register_alloc: tabelul de alocare este plin cu FIND_ALLOC?
register_alloc: %p deja în tabel ca liber?
restricționatrestricționat: nu se poate redirecționa ieșireareturn [n]run_pending_traps: valoare greșită în trap_list[%d]: %prun_pending_traps: gestionarul de semnal este SIG_DFL, se retrimite %d (%s) către minesave_bash_input: memorie tampon deja existentă pentru noul descriptor de fișier %deroare de citire a fișierului scriptselect NUME [in CUVINTE ... ;] do COMENZI; doneset [-abefhkmnptuvxBCEHPT] [-o nume-opțiune] [--] [-] [arg ...]nivelul shell-ului (%d) prea mare, se reinițializează la 1shell_getc: shell_input_line_size (%zu) depășește SIZE_MAX (%lu): linie trunchiatăshift [n]contor deplasare(shift)shopt [-pqsu] [-o] [nume_opțiune ...]sigprocmask: %d: operație nevalidăsource [-p rută] nume_fișier [argumente]start_pipeline: linie de conectare pgrplungimea șiruluisuspend [-f]eroare de sintaxăeroare de sintaxă în expresia condiționalăeroare de sintaxă în expresia condițională: simbol neașteptat „%s”eroare de sintaxă neașteptată lângă „%s”eroare de sintaxă neașteptată lângă „%s”eroare de sintaxă lângă simbolul neașteptat „%s” în timp ce se căuta coincidența pentru „%c”eroare de sintaxă: „%s” neașteptateroare de sintaxă: „((%s))”eroare de sintaxă: „;” neașteptateroare de sintaxă: expresie aritmetică necesarăeroare de sintaxă: sfârșit de fișier neașteptateroare de sintaxă: sfârșit neașteptat de fișier de la comanda «%s» pe linia %deroare de sintaxă: sfârșit neașteptat de fișier de la comandă pe linia %dcădere iminentă a sistemuluitest [expr]time [-p] secvența_de_comenzi(pipeline)prea mulți parametritrap [-Plp] [[acțiune] id_semnal ...]gestionarul de capturare: nivelul maxim de gestionări de capturare a fost depășit (%d)trap_handler: semnal nevalid %dtype [-afptP] nume [nume ...]typeset [-aAfFgiIlnrtux] nume[=valoare] ... sau typeset -p [-aAfFilnrtux] [nume ...]ulimit [-SHabcdefiklmnpqrstuvxPRT] [limită]umask [-p] [-S] [mod]unalias [-a] nume [nume ...]sfârșit neașteptat al fișierului(EOF) în timp ce se căuta „]]”sfârșit neașteptat al fișierului(EOF) în timp ce se căuta coincidența pentru „%c”sfârșit neașteptat al fișierului în timp ce se căuta după perechea lui „)”argument neașteptat „%s” pentru operatorul binar condiționalargument neașteptat „%s” pentru operatorul unar condiționalargument neașteptat pentru operatorul binar condiționalargument neașteptat pentru operatorul unar condiționalidentificator neașteptat %d în comanda condiționalăidentificator neașteptat „%c” în comanda condiționalăidentificator neașteptat „%s” în comanda condiționalăidentificator neașteptat „%s”, se aștepta operator binar condiționalsimbol neașteptat „%s”, așteptat „)”necunoscuteroare de comandă necunoscutăunset [-f] [-v] [-n] [nume ...]until COMENZI; do COMENZI-2; donevaloare prea mare pentru bazăvariables - Numele și semnificațiile unor variabile din shellwait [-fn] [-p var] [id ...]wait [pid ...]wait: pid %ld nu este un proces-copil al acestui shellwait_for: Nu există nicio înregistrare a procesului %ldwait_for_job: lucrarea %d este oprităwaitchld: se activează WNOHANG pentru a evita blocarea pe termen nedefinitavertizare: avertisment: este posibil ca opțiunea „-C” să nu funcționeze așa cum vă așteptațiavertisment: este posibil ca opțiunea „-F” să nu funcționeze așa cum vă așteptațiwhile COMENZI; do COMENZI-2; doneeroare de scrierextrace fd (%d) != nrfișier xtrace fp (%d)xtrace_set: %d: descriptor de fișier nevalidxtrace_set: indicatorul pentru fișier este NULL{ COMENZI ; }