alpaca_linux.jsonl

{"instruction": "What is chgrp command", "input": "", "output": "# chgrp\n> Change group ownership of files and directories. More information:\n> https://www.gnu.org/software/coreutils/chgrp.\n  * Change the owner group of a file/directory:\n`chgrp {{group}} {{path/to/file_or_directory}}`\n  * Recursively change the owner group of a directory and its contents:\n`chgrp -R {{group}} {{path/to/directory}}`\n  * Change the owner group of a symbolic link:\n`chgrp -h {{group}} {{path/to/symlink}}`\n  * Change the owner group of a file/directory to match a reference file:\n`chgrp --reference={{path/to/reference_file}} {{path/to/file_or_directory}}`"}
{"instruction": "What is more command", "input": "", "output": "# more\n> Open a file for interactive reading, allowing scrolling and search. More\n> information: https://manned.org/more.\n  * Open a file:\n`more {{path/to/file}}`\n  * Open a file displaying from a specific line:\n`more +{{line_number}} {{path/to/file}}`\n  * Display help:\n`more --help`\n  * Go to the next page:\n`<Space>`\n  * Search for a string (press `n` to go to the next match):\n`/{{something}}`\n  * Exit:\n`q`\n  * Display help about interactive commands:\n`h`"}
{"instruction": "What is git-hash-object command", "input": "", "output": "# git hash-object\n> Computes the unique hash key of content and optionally creates an object\n> with specified type. More information: https://git-scm.com/docs/git-hash-\n> object.\n  * Compute the object ID without storing it:\n`git hash-object {{path/to/file}}`\n  * Compute the object ID and store it in the Git database:\n`git hash-object -w {{path/to/file}}`\n  * Compute the object ID specifying the object type:\n`git hash-object -t {{blob|commit|tag|tree}} {{path/to/file}}`\n  * Compute the object ID from `stdin`:\n`cat {{path/to/file}} | git hash-object --stdin`"}
{"instruction": "What is id command", "input": "", "output": "# id\n> Display current user and group identity. More information:\n> https://www.gnu.org/software/coreutils/id.\n  * Display current user's ID (UID), group ID (GID) and groups to which they belong:\n`id`\n  * Display the current user identity as a number:\n`id -u`\n  * Display the current group identity as a number:\n`id -g`\n  * Display an arbitrary user's ID (UID), group ID (GID) and groups to which they belong:\n`id {{username}}`"}
{"instruction": "What is nl command", "input": "", "output": "# nl\n> A utility for numbering lines, either from a file, or from `stdin`. More\n> information: https://www.gnu.org/software/coreutils/nl.\n  * Number non-blank lines in a file:\n`nl {{path/to/file}}`\n  * Read from `stdout`:\n`cat {{path/to/file}} | nl {{options}} -`\n  * Number only the lines with printable text:\n`nl -t {{path/to/file}}`\n  * Number all lines including blank lines:\n`nl -b a {{path/to/file}}`\n  * Number only the body lines that match a basic regular expression (BRE) pattern:\n`nl -b p'FooBar[0-9]' {{path/to/file}}`"}
{"instruction": "What is git-check-ignore command", "input": "", "output": "# git check-ignore\n> Analyze and debug Git ignore/exclude (\".gitignore\") files. More information:\n> https://git-scm.com/docs/git-check-ignore.\n  * Check whether a file or directory is ignored:\n`git check-ignore {{path/to/file_or_directory}}`\n  * Check whether multiple files or directories are ignored:\n`git check-ignore {{path/to/file}} {{path/to/directory}}`\n  * Use pathnames, one per line, from `stdin`:\n`git check-ignore --stdin < {{path/to/file_list}}`\n  * Do not check the index (used to debug why paths were tracked and not ignored):\n`git check-ignore --no-index {{path/to/files_or_directories}}`\n  * Include details about the matching pattern for each path:\n`git check-ignore --verbose {{path/to/files_or_directories}}`"}
{"instruction": "What is tcpdump command", "input": "", "output": "# tcpdump\n> Dump traffic on a network. More information: https://www.tcpdump.org.\n  * List available network interfaces:\n`tcpdump -D`\n  * Capture the traffic of a specific interface:\n`tcpdump -i {{eth0}}`\n  * Capture all TCP traffic showing contents (ASCII) in console:\n`tcpdump -A tcp`\n  * Capture the traffic from or to a host:\n`tcpdump host {{www.example.com}}`\n  * Capture the traffic from a specific interface, source, destination and destination port:\n`tcpdump -i {{eth0}} src {{192.168.1.1}} and dst {{192.168.1.2}} and dst port\n{{80}}`\n  * Capture the traffic of a network:\n`tcpdump net {{192.168.1.0/24}}`\n  * Capture all traffic except traffic over port 22 and save to a dump file:\n`tcpdump -w {{dumpfile.pcap}} port not {{22}}`\n  * Read from a given dump file:\n`tcpdump -r {{dumpfile.pcap}}`"}
{"instruction": "What is users command", "input": "", "output": "# users\n> Display a list of logged in users. See also: `useradd`, `userdel`,\n> `usermod`. More information: https://www.gnu.org/software/coreutils/users.\n  * Print logged in usernames:\n`users`\n  * Print logged in usernames according to a given file:\n`users {{/var/log/wmtp}}`"}
{"instruction": "What is git-rev-list command", "input": "", "output": "# git rev-list\n> List revisions (commits) in reverse chronological order. More information:\n> https://git-scm.com/docs/git-rev-list.\n  * List all commits on the current branch:\n`git rev-list {{HEAD}}`\n  * Print the latest commit that changed (add/edit/remove) a specific file on the current branch:\n`git rev-list -n 1 HEAD -- {{path/to/file}}`\n  * List commits more recent than a specific date, on a specific branch:\n`git rev-list --since={{'2019-12-01 00:00:00'}} {{branch_name}}`\n  * List all merge commits on a specific commit:\n`git rev-list --merges {{commit}}`\n  * Print the number of commits since a specific tag:\n`git rev-list {{tag_name}}..HEAD --count`"}
{"instruction": "What is lpr command", "input": "", "output": "# lpr\n> CUPS tool for printing files. See also: `lpstat` and `lpadmin`. More\n> information: https://www.cups.org/doc/man-lpr.html.\n  * Print a file to the default printer:\n`lpr {{path/to/file}}`\n  * Print 2 copies:\n`lpr -# {{2}} {{path/to/file}}`\n  * Print to a named printer:\n`lpr -P {{printer}} {{path/to/file}}`\n  * Print either a single page (e.g. 2) or a range of pages (e.g. 2–16):\n`lpr -o page-ranges={{2|2-16}} {{path/to/file}}`\n  * Print double-sided either in portrait (long) or in landscape (short):\n`lpr -o sides={{two-sided-long-edge|two-sided-short-edge}} {{path/to/file}}`\n  * Set page size (more options may be available depending on setup):\n`lpr -o media={{a4|letter|legal}} {{path/to/file}}`\n  * Print multiple pages per sheet:\n`lpr -o number-up={{2|4|6|9|16}} {{path/to/file}}`"}
{"instruction": "What is lp command", "input": "", "output": "# lp\n> Print files. More information: https://manned.org/lp.\n  * Print the output of a command to the default printer (see `lpstat` command):\n`echo \"test\" | lp`\n  * Print a file to the default printer:\n`lp {{path/to/filename}}`\n  * Print a file to a named printer (see `lpstat` command):\n`lp -d {{printer_name}} {{path/to/filename}}`\n  * Print N copies of file to default printer (replace N with desired number of copies):\n`lp -n {{N}} {{path/to/filename}}`\n  * Print only certain pages to the default printer (print pages 1, 3-5, and 16):\n`lp -P 1,3-5,16 {{path/to/filename}}`\n  * Resume printing a job:\n`lp -i {{job_id}} -H resume`"}
{"instruction": "What is uptime command", "input": "", "output": "# uptime\n> Tell how long the system has been running and other information. More\n> information: https://ss64.com/osx/uptime.html.\n  * Print current time, uptime, number of logged-in users and other information:\n`uptime`"}
{"instruction": "What is git-count-objects command", "input": "", "output": "# git count-objects\n> Count the number of unpacked objects and their disk consumption. More\n> information: https://git-scm.com/docs/git-count-objects.\n  * Count all objects and display the total disk usage:\n`git count-objects`\n  * Display a count of all objects and their total disk usage, displaying sizes in human-readable units:\n`git count-objects --human-readable`\n  * Display more verbose information:\n`git count-objects --verbose`\n  * Display more verbose information, displaying sizes in human-readable units:\n`git count-objects --human-readable --verbose`"}
{"instruction": "What is git-shortlog command", "input": "", "output": "# git shortlog\n> Summarizes the `git log` output. More information: https://git-\n> scm.com/docs/git-shortlog.\n  * View a summary of all the commits made, grouped alphabetically by author name:\n`git shortlog`\n  * View a summary of all the commits made, sorted by the number of commits made:\n`git shortlog -n`\n  * View a summary of all the commits made, grouped by the committer identities (name and email):\n`git shortlog -c`\n  * View a summary of the last 5 commits (i.e. specify a revision range):\n`git shortlog HEAD~{{5}}..HEAD`\n  * View all users, emails and the number of commits in the current branch:\n`git shortlog -sne`\n  * View all users, emails and the number of commits in all branches:\n`git shortlog -sne --all`"}
{"instruction": "What is pv command", "input": "", "output": "# pv\n> Monitor the progress of data through a pipe. More information:\n> https://manned.org/pv.\n  * Print the contents of the file and display a progress bar:\n`pv {{path/to/file}}`\n  * Measure the speed and amount of data flow between pipes (`--size` is optional):\n`command1 | pv --size {{expected_amount_of_data_for_eta}} | command2`\n  * Filter a file, see both progress and amount of output data:\n`pv -cN in {{big_text_file}} | grep {{pattern}} | pv -cN out >\n{{filtered_file}}`\n  * Attach to an already running process and see its file reading progress:\n`pv -d {{PID}}`\n  * Read an erroneous file, skip errors as `dd conv=sync,noerror` would:\n`pv -EE {{path/to/faulty_media}} > image.img`\n  * Stop reading after reading specified amount of data, rate limit to 1K/s:\n`pv -L 1K --stop-at --size {{maximum_file_size_to_be_read}}`"}
{"instruction": "What is nl command", "input": "", "output": "# nl\n> A utility for numbering lines, either from a file, or from `stdin`. More\n> information: https://www.gnu.org/software/coreutils/nl.\n  * Number non-blank lines in a file:\n`nl {{path/to/file}}`\n  * Read from `stdout`:\n`cat {{path/to/file}} | nl {{options}} -`\n  * Number only the lines with printable text:\n`nl -t {{path/to/file}}`\n  * Number all lines including blank lines:\n`nl -b a {{path/to/file}}`\n  * Number only the body lines that match a basic regular expression (BRE) pattern:\n`nl -b p'FooBar[0-9]' {{path/to/file}}`"}
{"instruction": "What is git-svn command", "input": "", "output": "# git svn\n> Bidirectional operation between a Subversion repository and Git. More\n> information: https://git-scm.com/docs/git-svn.\n  * Clone an SVN repository:\n`git svn clone {{https://example.com/subversion_repo}} {{local_dir}}`\n  * Clone an SVN repository starting at a given revision number:\n`git svn clone -r{{1234}}:HEAD {{https://svn.example.net/subversion/repo}}\n{{local_dir}}`\n  * Update local clone from the remote SVN repository:\n`git svn rebase`\n  * Fetch updates from the remote SVN repository without changing the Git HEAD:\n`git svn fetch`\n  * Commit back to the SVN repository:\n`git svn dcommit`"}
{"instruction": "What is grep command", "input": "", "output": "# grep\n> Find patterns in files using regular expressions. More information:\n> https://www.gnu.org/software/grep/manual/grep.html.\n  * Search for a pattern within a file:\n`grep \"{{search_pattern}}\" {{path/to/file}}`\n  * Search for an exact string (disables regular expressions):\n`grep --fixed-strings \"{{exact_string}}\" {{path/to/file}}`\n  * Search for a pattern in all files recursively in a directory, showing line numbers of matches, ignoring binary files:\n`grep --recursive --line-number --binary-files={{without-match}}\n\"{{search_pattern}}\" {{path/to/directory}}`\n  * Use extended regular expressions (supports `?`, `+`, `{}`, `()` and `|`), in case-insensitive mode:\n`grep --extended-regexp --ignore-case \"{{search_pattern}}\" {{path/to/file}}`\n  * Print 3 lines of context around, before, or after each match:\n`grep --{{context|before-context|after-context}}={{3}} \"{{search_pattern}}\"\n{{path/to/file}}`\n  * Print file name and line number for each match with color output:\n`grep --with-filename --line-number --color=always \"{{search_pattern}}\"\n{{path/to/file}}`\n  * Search for lines matching a pattern, printing only the matched text:\n`grep --only-matching \"{{search_pattern}}\" {{path/to/file}}`\n  * Search `stdin` for lines that do not match a pattern:\n`cat {{path/to/file}} | grep --invert-match \"{{search_pattern}}\"`"}
{"instruction": "What is systemd-run command", "input": "", "output": "# systemd-run\n> Run programs in transient scope units, service units, or path-, socket-, or\n> timer-triggered service units. More information:\n> https://www.freedesktop.org/software/systemd/man/systemd-run.html.\n  * Start a transient service:\n`sudo systemd-run {{command}} {{argument1 argument2 ...}}`\n  * Start a transient service under the service manager of the current user (no privileges):\n`systemd-run --user {{command}} {{argument1 argument2 ...}}`\n  * Start a transient service with a custom unit name and description:\n`sudo systemd-run --unit={{name}} --description={{string}} {{command}}\n{{argument1 argument2 ...}}`\n  * Start a transient service that does not get cleaned up after it terminates with a custom environment variable:\n`sudo systemd-run --remain-after-exit --set-env={{name}}={{value}} {{command}}\n{{argument1 argument2 ...}}`\n  * Start a transient timer that periodically runs its transient service (see `man systemd.time` for calendar event format):\n`sudo systemd-run --on-calendar={{calendar_event}} {{command}} {{argument1\nargument2 ...}}`\n  * Share the terminal with the program (allowing interactive input/output) and make sure the execution details remain after the program exits:\n`systemd-run --remain-after-exit --pty {{command}}`\n  * Set properties (e.g. CPUQuota, MemoryMax) of the process and wait until it exits:\n`systemd-run --property MemoryMax={{memory_in_bytes}} --property\nCPUQuota={{percentage_of_CPU_time}}% --wait {{command}}`\n  * Use the program in a shell pipeline:\n`{{command1}} | systemd-run --pipe {{command2}} | {{command3}}`"}
{"instruction": "What is tput command", "input": "", "output": "# tput\n> View and modify terminal settings and capabilities. More information:\n> https://manned.org/tput.\n  * Move the cursor to a screen location:\n`tput cup {{row}} {{column}}`\n  * Set foreground (af) or background (ab) color:\n`tput {{setaf|setab}} {{ansi_color_code}}`\n  * Show number of columns, lines, or colors:\n`tput {{cols|lines|colors}}`\n  * Ring the terminal bell:\n`tput bel`\n  * Reset all terminal attributes:\n`tput sgr0`\n  * Enable or disable word wrap:\n`tput {{smam|rmam}}`"}
{"instruction": "What is link command", "input": "", "output": "# link\n> Create a hard link to an existing file. For more options, see the `ln`\n> command. More information: https://www.gnu.org/software/coreutils/link.\n  * Create a hard link from a new file to an existing file:\n`link {{path/to/existing_file}} {{path/to/new_file}}`"}
{"instruction": "What is logname command", "input": "", "output": "# logname\n> Shows the user's login name. More information:\n> https://www.gnu.org/software/coreutils/logname.\n  * Display the currently logged in user's name:\n`logname`"}
{"instruction": "What is iconv command", "input": "", "output": "# iconv\n> Converts text from one encoding to another. More information:\n> https://manned.org/iconv.\n  * Convert file to a specific encoding, and print to `stdout`:\n`iconv -f {{from_encoding}} -t {{to_encoding}} {{input_file}}`\n  * Convert file to the current locale's encoding, and output to a file:\n`iconv -f {{from_encoding}} {{input_file}} > {{output_file}}`\n  * List supported encodings:\n`iconv -l`"}
{"instruction": "What is paste command", "input": "", "output": "# paste\n> Merge lines of files. More information:\n> https://www.gnu.org/software/coreutils/paste.\n  * Join all the lines into a single line, using TAB as delimiter:\n`paste -s {{path/to/file}}`\n  * Join all the lines into a single line, using the specified delimiter:\n`paste -s -d {{delimiter}} {{path/to/file}}`\n  * Merge two files side by side, each in its column, using TAB as delimiter:\n`paste {{file1}} {{file2}}`\n  * Merge two files side by side, each in its column, using the specified delimiter:\n`paste -d {{delimiter}} {{file1}} {{file2}}`\n  * Merge two files, with lines added alternatively:\n`paste -d '\\n' {{file1}} {{file2}}`"}
{"instruction": "What is ls command", "input": "", "output": "# ls\n> List directory contents. More information:\n> https://www.gnu.org/software/coreutils/ls.\n  * List files one per line:\n`ls -1`\n  * List all files, including hidden files:\n`ls -a`\n  * List all files, with trailing `/` added to directory names:\n`ls -F`\n  * Long format list (permissions, ownership, size, and modification date) of all files:\n`ls -la`\n  * Long format list with size displayed using human-readable units (KiB, MiB, GiB):\n`ls -lh`\n  * Long format list sorted by size (descending):\n`ls -lS`\n  * Long format list of all files, sorted by modification date (oldest first):\n`ls -ltr`\n  * Only list directories:\n`ls -d */`"}
{"instruction": "What is mktemp command", "input": "", "output": "# mktemp\n> Create a temporary file or directory. More information:\n> https://ss64.com/osx/mktemp.html.\n  * Create an empty temporary file and print the absolute path to it:\n`mktemp`\n  * Create an empty temporary file with a given suffix and print the absolute path to file:\n`mktemp --suffix \"{{.ext}}\"`\n  * Create a temporary directory and print the absolute path to it:\n`mktemp -d`"}
{"instruction": "What is git-range-diff command", "input": "", "output": "# git range-diff\n> Compare two commit ranges (e.g. two versions of a branch). More information:\n> https://git-scm.com/docs/git-range-diff.\n  * Diff the changes of two individual commits:\n`git range-diff {{commit_1}}^! {{commit_2}}^!`\n  * Diff the changes of ours and theirs from their common ancestor, e.g. after an interactive rebase:\n`git range-diff {{theirs}}...{{ours}}`\n  * Diff the changes of two commit ranges, e.g. to check whether conflicts have been resolved appropriately when rebasing commits from `base1` to `base2`:\n`git range-diff {{base1}}..{{rev1}} {{base2}}..{{rev2}}`"}
{"instruction": "What is quilt command", "input": "", "output": "# quilt\n> Tool to manage a series of patches. More information:\n> https://savannah.nongnu.org/projects/quilt.\n  * Import an existing patch from a file:\n`quilt import {{path/to/filename.patch}}`\n  * Create a new patch:\n`quilt new {{filename.patch}}`\n  * Add a file to the current patch:\n`quilt add {{path/to/file}}`\n  * After editing the file, refresh the current patch with the changes:\n`quilt refresh`\n  * Apply all the patches in the series file:\n`quilt push -a`\n  * Remove all applied patches:\n`quilt pop -a`"}
{"instruction": "What is nohup command", "input": "", "output": "# nohup\n> Allows for a process to live when the terminal gets killed. More\n> information: https://www.gnu.org/software/coreutils/nohup.\n  * Run a process that can live beyond the terminal:\n`nohup {{command}} {{argument1 argument2 ...}}`\n  * Launch `nohup` in background mode:\n`nohup {{command}} {{argument1 argument2 ...}} &`\n  * Run a shell script that can live beyond the terminal:\n`nohup {{path/to/script.sh}} &`\n  * Run a process and write the output to a specific file:\n`nohup {{command}} {{argument1 argument2 ...}} > {{path/to/output_file}} &`"}
{"instruction": "What is expand command", "input": "", "output": "# expand\n> Convert tabs to spaces. More information:\n> https://www.gnu.org/software/coreutils/expand.\n  * Convert tabs in each file to spaces, writing to `stdout`:\n`expand {{path/to/file}}`\n  * Convert tabs to spaces, reading from `stdin`:\n`expand`\n  * Do not convert tabs after non blanks:\n`expand -i {{path/to/file}}`\n  * Have tabs a certain number of characters apart, not 8:\n`expand -t={{number}} {{path/to/file}}`\n  * Use a comma separated list of explicit tab positions:\n`expand -t={{1,4,6}}`"}
{"instruction": "What is strace command", "input": "", "output": "# strace\n> Troubleshooting tool for tracing system calls. More information:\n> https://manned.org/strace.\n  * Start tracing a specific process by its PID:\n`strace -p {{pid}}`\n  * Trace a process and filter output by system call:\n`strace -p {{pid}} -e {{system_call_name}}`\n  * Count time, calls, and errors for each system call and report a summary on program exit:\n`strace -p {{pid}} -c`\n  * Show the time spent in every system call:\n`strace -p {{pid}} -T`\n  * Start tracing a program by executing it:\n`strace {{program}}`\n  * Start tracing file operations of a program:\n`strace -e trace=file {{program}}`"}
{"instruction": "What is cmp command", "input": "", "output": "# cmp\n> Compare two files byte by byte. More information:\n> https://www.gnu.org/software/diffutils/manual/html_node/Invoking-cmp.html.\n  * Output char and line number of the first difference between two files:\n`cmp {{path/to/file1}} {{path/to/file2}}`\n  * Output info of the first difference: char, line number, bytes, and values:\n`cmp --print-bytes {{path/to/file1}} {{path/to/file2}}`\n  * Output the byte numbers and values of every difference:\n`cmp --verbose {{path/to/file1}} {{path/to/file2}}`\n  * Compare files but output nothing, yield only the exit status:\n`cmp --quiet {{path/to/file1}} {{path/to/file2}}`"}
{"instruction": "What is chmod command", "input": "", "output": "# chmod\n> Change the access permissions of a file or directory. More information:\n> https://www.gnu.org/software/coreutils/chmod.\n  * Give the [u]ser who owns a file the right to e[x]ecute it:\n`chmod u+x {{path/to/file}}`\n  * Give the [u]ser rights to [r]ead and [w]rite to a file/directory:\n`chmod u+rw {{path/to/file_or_directory}}`\n  * Remove e[x]ecutable rights from the [g]roup:\n`chmod g-x {{path/to/file}}`\n  * Give [a]ll users rights to [r]ead and e[x]ecute:\n`chmod a+rx {{path/to/file}}`\n  * Give [o]thers (not in the file owner's group) the same rights as the [g]roup:\n`chmod o=g {{path/to/file}}`\n  * Remove all rights from [o]thers:\n`chmod o= {{path/to/file}}`\n  * Change permissions recursively giving [g]roup and [o]thers the ability to [w]rite:\n`chmod -R g+w,o+w {{path/to/directory}}`\n  * Recursively give [a]ll users [r]ead permissions to files and e[X]ecute permissions to sub-directories within a directory:\n`chmod -R a+rX {{path/to/directory}}`"}
{"instruction": "What is chsh command", "input": "", "output": "# chsh\n> Change user's login shell. More information: https://manned.org/chsh.\n  * Set a specific login shell for the current user interactively:\n`chsh`\n  * Set a specific login [s]hell for the current user:\n`chsh -s {{path/to/shell}}`\n  * Set a login [s]hell for a specific user:\n`chsh -s {{path/to/shell}} {{username}}`\n  * [l]ist available shells:\n`chsh -l`"}
{"instruction": "What is coredumpctl command", "input": "", "output": "# coredumpctl\n> Retrieve and process saved core dumps and metadata. More information:\n> https://www.freedesktop.org/software/systemd/man/coredumpctl.html.\n  * List all captured core dumps:\n`coredumpctl list`\n  * List captured core dumps for a program:\n`coredumpctl list {{program}}`\n  * Show information about the core dumps matching a program with `PID`:\n`coredumpctl info {{PID}}`\n  * Invoke debugger using the last core dump of a program:\n`coredumpctl debug {{program}}`\n  * Extract the last core dump of a program to a file:\n`coredumpctl --output={{path/to/file}} dump {{program}}`"}
{"instruction": "What is git-check-mailmap command", "input": "", "output": "# git check-mailmap\n> Show canonical names and email addresses of contacts. More information:\n> https://git-scm.com/docs/git-check-mailmap.\n  * Look up the canonical name associated with an email address:\n`git check-mailmap \"<{{email@example.com}}>\"`"}
{"instruction": "What is top command", "input": "", "output": "# top\n> Display dynamic real-time information about running processes. More\n> information: https://ss64.com/osx/top.html.\n  * Start `top`, all options are available in the interface:\n`top`\n  * Start `top` sorting processes by internal memory size (default order - process ID):\n`top -o mem`\n  * Start `top` sorting processes first by CPU, then by running time:\n`top -o cpu -O time`\n  * Start `top` displaying only processes owned by given user:\n`top -user {{user_name}}`\n  * Get help about interactive commands:\n`?`"}
{"instruction": "What is unshare command", "input": "", "output": "# unshare\n> Execute a command in new user-defined namespaces. More information:\n> https://www.kernel.org/doc/html/latest/userspace-api/unshare.html.\n  * Execute a command without sharing access to connected networks:\n`unshare --net {{command}} {{command_arguments}}`\n  * Execute a command as a child process without sharing mounts, processes, or networks:\n`unshare --mount --pid --net --fork {{command}} {{command_arguments}}`"}
{"instruction": "What is git-switch command", "input": "", "output": "# git switch\n> Switch between Git branches. Requires Git version 2.23+. See also `git\n> checkout`. More information: https://git-scm.com/docs/git-switch.\n  * Switch to an existing branch:\n`git switch {{branch_name}}`\n  * Create a new branch and switch to it:\n`git switch --create {{branch_name}}`\n  * Create a new branch based on an existing commit and switch to it:\n`git switch --create {{branch_name}} {{commit}}`\n  * Switch to the previous branch:\n`git switch -`\n  * Switch to a branch and update all submodules to match:\n`git switch --recurse-submodules {{branch_name}}`\n  * Switch to a branch and automatically merge the current branch and any uncommitted changes into it:\n`git switch --merge {{branch_name}}`"}
{"instruction": "What is dpkg command", "input": "", "output": "# dpkg\n> Debian package manager. Some subcommands such as `dpkg deb` have their own\n> usage documentation. For equivalent commands in other package managers, see\n> https://wiki.archlinux.org/title/Pacman/Rosetta. More information:\n> https://manpages.debian.org/latest/dpkg/dpkg.html.\n  * Install a package:\n`dpkg -i {{path/to/file.deb}}`\n  * Remove a package:\n`dpkg -r {{package}}`\n  * List installed packages:\n`dpkg -l {{pattern}}`\n  * List a package's contents:\n`dpkg -L {{package}}`\n  * List contents of a local package file:\n`dpkg -c {{path/to/file.deb}}`\n  * Find out which package owns a file:\n`dpkg -S {{path/to/file}}`"}
{"instruction": "What is m4 command", "input": "", "output": "# m4\n> Macro processor. More information: https://www.gnu.org/software/m4.\n  * Process macros in a file:\n`m4 {{path/to/file}}`\n  * Define a macro before processing files:\n`m4 -D{{macro_name}}={{macro_value}} {{path/to/file}}`"}
{"instruction": "What is git-check-ref-format command", "input": "", "output": "# git check-ref-format\n> Checks if a given refname is acceptable, and exits with a non-zero status if\n> it is not. More information: https://git-scm.com/docs/git-check-ref-format.\n  * Check the format of the specified refname:\n`git check-ref-format {{refs/head/refname}}`\n  * Print the name of the last branch checked out:\n`git check-ref-format --branch @{-1}`\n  * Normalize a refname:\n`git check-ref-format --normalize {{refs/head/refname}}`"}
{"instruction": "What is date command", "input": "", "output": "# date\n> Set or display the system date. More information:\n> https://ss64.com/osx/date.html.\n  * Display the current date using the default locale's format:\n`date +%c`\n  * Display the current date in UTC and ISO 8601 format:\n`date -u +%Y-%m-%dT%H:%M:%SZ`\n  * Display the current date as a Unix timestamp (seconds since the Unix epoch):\n`date +%s`\n  * Display a specific date (represented as a Unix timestamp) using the default format:\n`date -r 1473305798`"}
{"instruction": "What is git-rebase command", "input": "", "output": "# git rebase\n> Reapply commits from one branch on top of another branch. Commonly used to\n> \"move\" an entire branch to another base, creating copies of the commits in\n> the new location. More information: https://git-scm.com/docs/git-rebase.\n  * Rebase the current branch on top of another specified branch:\n`git rebase {{new_base_branch}}`\n  * Start an interactive rebase, which allows the commits to be reordered, omitted, combined or modified:\n`git rebase -i {{target_base_branch_or_commit_hash}}`\n  * Continue a rebase that was interrupted by a merge failure, after editing conflicting files:\n`git rebase --continue`\n  * Continue a rebase that was paused due to merge conflicts, by skipping the conflicted commit:\n`git rebase --skip`\n  * Abort a rebase in progress (e.g. if it is interrupted by a merge conflict):\n`git rebase --abort`\n  * Move part of the current branch onto a new base, providing the old base to start from:\n`git rebase --onto {{new_base}} {{old_base}}`\n  * Reapply the last 5 commits in-place, stopping to allow them to be reordered, omitted, combined or modified:\n`git rebase -i {{HEAD~5}}`\n  * Auto-resolve any conflicts by favoring the working branch version (`theirs` keyword has reversed meaning in this case):\n`git rebase -X theirs {{branch_name}}`"}
{"instruction": "What is git-commit-graph command", "input": "", "output": "# git commit-graph\n> Write and verify Git commit-graph files. More information: https://git-\n> scm.com/docs/git-commit-graph.\n  * Write a commit-graph file for the packed commits in the repository's local `.git` directory:\n`git commit-graph write`\n  * Write a commit-graph file containing all reachable commits:\n`git show-ref --hash | git commit-graph write --stdin-commits`\n  * Write a commit-graph file containing all commits in the current commit-graph file along with those reachable from `HEAD`:\n`git rev-parse {{HEAD}} | git commit-graph write --stdin-commits --append`"}
{"instruction": "What is chroot command", "input": "", "output": "# chroot\n> Run command or interactive shell with special root directory. More\n> information: https://www.gnu.org/software/coreutils/chroot.\n  * Run command as new root directory:\n`chroot {{path/to/new/root}} {{command}}`\n  * Specify user and group (ID or name) to use:\n`chroot --userspec={{user:group}}`"}
{"instruction": "What is mesg command", "input": "", "output": "# mesg\n> Check or set a terminal's ability to receive messages from other users,\n> usually from the write command. See also `write`. More information:\n> https://manned.org/mesg.\n  * Check terminal's openness to write messages:\n`mesg`\n  * Disable receiving messages from the write command:\n`mesg n`\n  * Enable receiving messages from the write command:\n`mesg y`"}
{"instruction": "What is grep command", "input": "", "output": "# grep\n> Find patterns in files using regular expressions. More information:\n> https://www.gnu.org/software/grep/manual/grep.html.\n  * Search for a pattern within a file:\n`grep \"{{search_pattern}}\" {{path/to/file}}`\n  * Search for an exact string (disables regular expressions):\n`grep --fixed-strings \"{{exact_string}}\" {{path/to/file}}`\n  * Search for a pattern in all files recursively in a directory, showing line numbers of matches, ignoring binary files:\n`grep --recursive --line-number --binary-files={{without-match}}\n\"{{search_pattern}}\" {{path/to/directory}}`\n  * Use extended regular expressions (supports `?`, `+`, `{}`, `()` and `|`), in case-insensitive mode:\n`grep --extended-regexp --ignore-case \"{{search_pattern}}\" {{path/to/file}}`\n  * Print 3 lines of context around, before, or after each match:\n`grep --{{context|before-context|after-context}}={{3}} \"{{search_pattern}}\"\n{{path/to/file}}`\n  * Print file name and line number for each match with color output:\n`grep --with-filename --line-number --color=always \"{{search_pattern}}\"\n{{path/to/file}}`\n  * Search for lines matching a pattern, printing only the matched text:\n`grep --only-matching \"{{search_pattern}}\" {{path/to/file}}`\n  * Search `stdin` for lines that do not match a pattern:\n`cat {{path/to/file}} | grep --invert-match \"{{search_pattern}}\"`"}
{"instruction": "What is less command", "input": "", "output": "# less\n> Open a file for interactive reading, allowing scrolling and search. More\n> information: https://greenwoodsoftware.com/less/.\n  * Open a file:\n`less {{source_file}}`\n  * Page down/up:\n`<Space> (down), b (up)`\n  * Go to end/start of file:\n`G (end), g (start)`\n  * Forward search for a string (press `n`/`N` to go to next/previous match):\n`/{{something}}`\n  * Backward search for a string (press `n`/`N` to go to next/previous match):\n`?{{something}}`\n  * Follow the output of the currently opened file:\n`F`\n  * Open the current file in an editor:\n`v`\n  * Exit:\n`q`"}
{"instruction": "What is git-add command", "input": "", "output": "# git add\n> Adds changed files to the index. More information: https://git-\n> scm.com/docs/git-add.\n  * Add a file to the index:\n`git add {{path/to/file}}`\n  * Add all files (tracked and untracked):\n`git add -A`\n  * Only add already tracked files:\n`git add -u`\n  * Also add ignored files:\n`git add -f`\n  * Interactively stage parts of files:\n`git add -p`\n  * Interactively stage parts of a given file:\n`git add -p {{path/to/file}}`\n  * Interactively stage a file:\n`git add -i`"}
{"instruction": "What is indent command", "input": "", "output": "# indent\n> Change the appearance of a C/C++ program by inserting or deleting\n> whitespace. More information:\n> https://www.freebsd.org/cgi/man.cgi?query=indent.\n  * Format C/C++ source according to the Berkeley style:\n`indent {{path/to/source_file.c}} {{path/to/indented_file.c}} -nbad -nbap -bc\n-br -c33 -cd33 -cdb -ce -ci4 -cli0 -di16 -fc1 -fcb -i4 -ip -l75 -lp -npcs\n-nprs -psl -sc -nsob -ts8`\n  * Format C/C++ source according to the style of Kernighan & Ritchie (K&R):\n`indent {{path/to/source_file.c}} {{path/to/indented_file.c}} -nbad -bap -nbc\n-br -c33 -cd33 -ncdb -ce -ci4 -cli0 -cs -d0 -di1 -nfc1 -nfcb -i4 -nip -l75 -lp\n-npcs -nprs -npsl -nsc -nsob`"}
{"instruction": "What is stty command", "input": "", "output": "# stty\n> Set options for a terminal device interface. More information:\n> https://www.gnu.org/software/coreutils/stty.\n  * Display all settings for the current terminal:\n`stty --all`\n  * Set the number of rows or columns:\n`stty {{rows|cols}} {{count}}`\n  * Get the actual transfer speed of a device:\n`stty --file {{path/to/device_file}} speed`\n  * Reset all modes to reasonable values for the current terminal:\n`stty sane`"}
{"instruction": "What is git-column command", "input": "", "output": "# git column\n> Display data in columns. More information: https://git-scm.com/docs/git-\n> column.\n  * Format `stdin` as multiple columns:\n`ls | git column --mode={{column}}`\n  * Format `stdin` as multiple columns with a maximum width of `100`:\n`ls | git column --mode=column --width={{100}}`\n  * Format `stdin` as multiple columns with a maximum padding of `30`:\n`ls | git column --mode=column --padding={{30}}`"}
{"instruction": "What is who command", "input": "", "output": "# who\n> Display who is logged in and related data (processes, boot time). More\n> information: https://www.gnu.org/software/coreutils/who.\n  * Display the username, line, and time of all currently logged-in sessions:\n`who`\n  * Display information only for the current terminal session:\n`who am i`\n  * Display all available information:\n`who -a`\n  * Display all available information with table headers:\n`who -a -H`"}
{"instruction": "What is git-notes command", "input": "", "output": "# git notes\n> Add or inspect object notes. More information: https://git-scm.com/docs/git-\n> notes.\n  * List all notes and the objects they are attached to:\n`git notes list`\n  * List all notes attached to a given object (defaults to HEAD):\n`git notes list [{{object}}]`\n  * Show the notes attached to a given object (defaults to HEAD):\n`git notes show [{{object}}]`\n  * Append a note to a specified object (opens the default text editor):\n`git notes append {{object}}`\n  * Append a note to a specified object, specifying the message:\n`git notes append --message=\"{{message_text}}\"`\n  * Edit an existing note (defaults to HEAD):\n`git notes edit [{{object}}]`\n  * Copy a note from one object to another:\n`git notes copy {{source_object}} {{target_object}}`\n  * Remove all the notes added to a specified object:\n`git notes remove {{object}}`"}
{"instruction": "What is git-mv command", "input": "", "output": "# git mv\n> Move or rename files and update the Git index. More information:\n> https://git-scm.com/docs/git-mv.\n  * Move a file inside the repo and add the movement to the next commit:\n`git mv {{path/to/file}} {{new/path/to/file}}`\n  * Rename a file or directory and add the renaming to the next commit:\n`git mv {{path/to/file_or_directory}} {{path/to/destination}}`\n  * Overwrite the file or directory in the target path if it exists:\n`git mv --force {{path/to/file_or_directory}} {{path/to/destination}}`"}
{"instruction": "What is strip command", "input": "", "output": "# strip\n> Discard symbols from executables or object files. More information:\n> https://manned.org/strip.\n  * Replace the input file with its stripped version:\n`strip {{path/to/file}}`\n  * Strip symbols from a file, saving the output to a specific file:\n`strip {{path/to/input_file}} -o {{path/to/output_file}}`\n  * Strip debug symbols only:\n`strip --strip-debug {{path/to/file.o}}`"}
{"instruction": "What is bash command", "input": "", "output": "# bash\n> Bourne-Again SHell, an `sh`-compatible command-line interpreter. See also:\n> `zsh`, `histexpand` (history expansion). More information:\n> https://gnu.org/software/bash/.\n  * Start an interactive shell session:\n`bash`\n  * Start an interactive shell session without loading startup configs:\n`bash --norc`\n  * Execute specific [c]ommands:\n`bash -c \"{{echo 'bash is executed'}}\"`\n  * Execute a specific script:\n`bash {{path/to/script.sh}}`\n  * Execute a specific script while printing each command before executing it:\n`bash -x {{path/to/script.sh}}`\n  * Execute a specific script and stop at the first [e]rror:\n`bash -e {{path/to/script.sh}}`\n  * Execute specific commands from `stdin`:\n`{{echo \"echo 'bash is executed'\"}} | bash`\n  * Start a [r]estricted shell session:\n`bash -r`"}
{"instruction": "What is exit command", "input": "", "output": "# exit\n> Exit the shell. More information: https://manned.org/exit.\n  * Exit the shell with the exit code of the last command executed:\n`exit`\n  * Exit the shell with the specified exit code:\n`exit {{exit_code}}`"}
{"instruction": "What is uniq command", "input": "", "output": "# uniq\n> Output the unique lines from the given input or file. Since it does not\n> detect repeated lines unless they are adjacent, we need to sort them first.\n> More information: https://www.gnu.org/software/coreutils/uniq.\n  * Display each line once:\n`sort {{path/to/file}} | uniq`\n  * Display only unique lines:\n`sort {{path/to/file}} | uniq -u`\n  * Display only duplicate lines:\n`sort {{path/to/file}} | uniq -d`\n  * Display number of occurrences of each line along with that line:\n`sort {{path/to/file}} | uniq -c`\n  * Display number of occurrences of each line, sorted by the most frequent:\n`sort {{path/to/file}} | uniq -c | sort -nr`"}
{"instruction": "What is git-mailinfo command", "input": "", "output": "# git mailinfo\n> Extract patch and authorship information from a single email message. More\n> information: https://git-scm.com/docs/git-mailinfo.\n  * Extract the patch and author data from an email message:\n`git mailinfo {{message|patch}}`\n  * Extract but remove leading and trailing whitespace:\n`git mailinfo -k {{message|patch}}`\n  * Remove everything from the body before a scissors line (e.g. \"-->* --\") and retrieve the message or patch:\n`git mailinfo --scissors {{message|patch}}`"}
{"instruction": "What is git-annotate command", "input": "", "output": "# git annotate\n> Show commit hash and last author on each line of a file. See `git blame`,\n> which is preferred over `git annotate`. `git annotate` is provided for those\n> familiar with other version control systems. More information: https://git-\n> scm.com/docs/git-annotate.\n  * Print a file with the author name and commit hash prepended to each line:\n`git annotate {{path/to/file}}`\n  * Print a file with the author email and commit hash prepended to each line:\n`git annotate -e {{path/to/file}}`\n  * Print only rows that match a regular expression:\n`git annotate -L :{{regexp}} {{path/to/file}}`"}
{"instruction": "What is pstree command", "input": "", "output": "# pstree\n> A convenient tool to show running processes as a tree. More information:\n> https://manned.org/pstree.\n  * Display a tree of processes:\n`pstree`\n  * Display a tree of processes with PIDs:\n`pstree -p`\n  * Display all process trees rooted at processes owned by specified user:\n`pstree {{user}}`"}
{"instruction": "What is ac command", "input": "", "output": "# ac\n> Print statistics on how long users have been connected. More information:\n> https://man.openbsd.org/ac.\n  * Print how long the current user has been connected in hours:\n`ac`\n  * Print how long users have been connected in hours:\n`ac -p`\n  * Print how long a particular user has been connected in hours:\n`ac -p {{username}}`\n  * Print how long a particular user has been connected in hours per day (with total):\n`ac -dp {{username}}`"}
{"instruction": "What is sha1sum command", "input": "", "output": "# sha1sum\n> Calculate SHA1 cryptographic checksums. More information:\n> https://www.gnu.org/software/coreutils/sha1sum.\n  * Calculate the SHA1 checksum for one or more files:\n`sha1sum {{path/to/file1 path/to/file2 ...}}`\n  * Calculate and save the list of SHA1 checksums to a file:\n`sha1sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha1}}`\n  * Calculate a SHA1 checksum from `stdin`:\n`{{command}} | sha1sum`\n  * Read a file of SHA1 sums and filenames and verify all files have matching checksums:\n`sha1sum --check {{path/to/file.sha1}}`\n  * Only show a message for missing files or when verification fails:\n`sha1sum --check --quiet {{path/to/file.sha1}}`\n  * Only show a message when verification fails, ignoring missing files:\n`sha1sum --ignore-missing --check --quiet {{path/to/file.sha1}}`"}
{"instruction": "What is ed command", "input": "", "output": "# ed\n> The original Unix text editor. See also: `awk`, `sed`. More information:\n> https://www.gnu.org/software/ed/manual/ed_manual.html.\n  * Start an interactive editor session with an empty document:\n`ed`\n  * Start an interactive editor session with an empty document and a specific [p]rompt:\n`ed -p '> '`\n  * Start an interactive editor session with an empty document and without diagnostics, byte counts and '!' prompt:\n`ed -s`\n  * Edit a specific file (this shows the byte count of the loaded file):\n`ed {{path/to/file}}`\n  * Replace a string with a specific replacement for all lines:\n`,s/{{regular_expression}}/{{replacement}}/g`"}
{"instruction": "What is systemd-analyze command", "input": "", "output": "# systemd-analyze\n> Analyze and debug system manager. Show timing details about the boot process\n> of units (services, mount points, devices, sockets). More information:\n> https://www.freedesktop.org/software/systemd/man/systemd-analyze.html.\n  * List all running units, ordered by the time they took to initialize:\n`systemd-analyze blame`\n  * Print a tree of the time-critical chain of units:\n`systemd-analyze critical-chain`\n  * Create an SVG file showing when each system service started, highlighting the time that they spent on initialization:\n`systemd-analyze plot > {{path/to/file.svg}}`\n  * Plot a dependency graph and convert it to an SVG file:\n`systemd-analyze dot | dot -T{{svg}} > {{path/to/file.svg}}`\n  * Show security scores of running units:\n`systemd-analyze security`"}
{"instruction": "What is timeout command", "input": "", "output": "# timeout\n> Run a command with a time limit. More information:\n> https://www.gnu.org/software/coreutils/timeout.\n  * Run `sleep 10` and terminate it, if it runs for more than 3 seconds:\n`timeout {{3s}} {{sleep 10}}`\n  * Specify the signal to be sent to the command after the time limit expires. (By default, TERM is sent):\n`timeout --signal {{INT}} {{5s}} {{sleep 10}}`"}
{"instruction": "What is git-am command", "input": "", "output": "# git am\n> Apply patch files and create a commit. Useful when receiving commits via\n> email. See also `git format-patch`, which can generate patch files. More\n> information: https://git-scm.com/docs/git-am.\n  * Apply and commit changes following a local patch file:\n`git am {{path/to/file.patch}}`\n  * Apply and commit changes following a remote patch file:\n`curl -L {{https://example.com/file.patch}} | git apply`\n  * Abort the process of applying a patch file:\n`git am --abort`\n  * Apply as much of a patch file as possible, saving failed hunks to reject files:\n`git am --reject {{path/to/file.patch}}`"}
{"instruction": "What is strings command", "input": "", "output": "# strings\n> Find printable strings in an object file or binary. More information:\n> https://manned.org/strings.\n  * Print all strings in a binary:\n`strings {{path/to/file}}`\n  * Limit results to strings at least length characters long:\n`strings -n {{length}} {{path/to/file}}`\n  * Prefix each result with its offset within the file:\n`strings -t d {{path/to/file}}`\n  * Prefix each result with its offset within the file in hexadecimal:\n`strings -t x {{path/to/file}}`"}
{"instruction": "What is git-pull command", "input": "", "output": "# git pull\n> Fetch branch from a remote repository and merge it to local repository. More\n> information: https://git-scm.com/docs/git-pull.\n  * Download changes from default remote repository and merge it:\n`git pull`\n  * Download changes from default remote repository and use fast-forward:\n`git pull --rebase`\n  * Download changes from given remote repository and branch, then merge them into HEAD:\n`git pull {{remote_name}} {{branch}}`"}
{"instruction": "What is yacc command", "input": "", "output": "# yacc\n> Generate an LALR parser (in C) with a given formal grammar specification\n> file. See also: `bison`. More information: https://manned.org/man/yacc.1p.\n  * Create a file `y.tab.c` containing the C parser code and compile the grammar file with all necessary constant declarations for values. (Constant declarations file `y.tab.h` is created only when the `-d` flag is used):\n`yacc -d {{path/to/grammar_file.y}}`\n  * Compile a grammar file containing the description of the parser and a report of conflicts generated by ambiguities in the grammar:\n`yacc -d {{path/to/grammar_file.y}} -v`\n  * Compile a grammar file, and prefix output filenames with `prefix` instead of `y`:\n`yacc -d {{path/to/grammar_file.y}} -v -b {{prefix}}`"}
{"instruction": "What is df command", "input": "", "output": "# df\n> Gives an overview of the filesystem disk space usage. More information:\n> https://www.gnu.org/software/coreutils/df.\n  * Display all filesystems and their disk usage:\n`df`\n  * Display all filesystems and their disk usage in human-readable form:\n`df -h`\n  * Display the filesystem and its disk usage containing the given file or directory:\n`df {{path/to/file_or_directory}}`\n  * Display statistics on the number of free inodes:\n`df -i`\n  * Display filesystems but exclude the specified types:\n`df -x {{squashfs}} -x {{tmpfs}}`"}
{"instruction": "What is ipcmk command", "input": "", "output": "# ipcmk\n> Create IPC (Inter-process Communication) resources. More information:\n> https://manned.org/ipcmk.\n  * Create a shared memory segment:\n`ipcmk --shmem {{segment_size_in_bytes}}`\n  * Create a semaphore:\n`ipcmk --semaphore {{element_size}}`\n  * Create a message queue:\n`ipcmk --queue`\n  * Create a shared memory segment with specific permissions (default is 0644):\n`ipcmk --shmem {{segment_size_in_bytes}} {{octal_permissions}}`"}
{"instruction": "What is newgrp command", "input": "", "output": "# newgrp\n> Switch primary group membership. More information:\n> https://manned.org/newgrp.\n  * Change user's primary group membership:\n`newgrp {{group_name}}`\n  * Reset primary group membership to user's default group in `/etc/passwd`:\n`newgrp`"}
{"instruction": "What is ssh-agent command", "input": "", "output": "# ssh-agent\n> Spawn an SSH Agent process. An SSH Agent holds SSH keys decrypted in memory\n> until removed or the process is killed. See also `ssh-add`, which can add\n> and manage keys held by an SSH Agent. More information:\n> https://man.openbsd.org/ssh-agent.\n  * Start an SSH Agent for the current shell:\n`eval $(ssh-agent)`\n  * Kill the currently running agent:\n`ssh-agent -k`"}
{"instruction": "What is basenc command", "input": "", "output": "# basenc\n> Encode or decode file or `stdin` using a specified encoding, to `stdout`.\n> More information: https://www.gnu.org/software/coreutils/basenc.\n  * Encode a file with base64 encoding:\n`basenc --base64 {{path/to/file}}`\n  * Decode a file with base64 encoding:\n`basenc --decode --base64 {{path/to/file}}`\n  * Encode from `stdin` with base32 encoding with 42 columns:\n`{{command}} | basenc --base32 -w42`\n  * Encode from `stdin` with base32 encoding:\n`{{command}} | basenc --base32`"}
{"instruction": "What is locale command", "input": "", "output": "# locale\n> Get locale-specific information. More information:\n> https://manned.org/locale.\n  * List all global environment variables describing the user's locale:\n`locale`\n  * List all available locales:\n`locale --all-locales`\n  * Display all available locales and the associated metadata:\n`locale --all-locales --verbose`\n  * Display the current date format:\n`locale date_fmt`"}
{"instruction": "What is unlink command", "input": "", "output": "# unlink\n> Remove a link to a file from the filesystem. The file contents is lost if\n> the link is the last one to the file. More information:\n> https://www.gnu.org/software/coreutils/unlink.\n  * Remove the specified file if it is the last link:\n`unlink {{path/to/file}}`"}
{"instruction": "What is diff3 command", "input": "", "output": "# diff3\n> Compare three files line by line. More information:\n> https://www.gnu.org/software/diffutils/manual/html_node/Invoking-diff3.html.\n  * Compare files:\n`diff3 {{path/to/file1}} {{path/to/file2}} {{path/to/file3}}`\n  * Show all changes, outlining conflicts:\n`diff3 --show-all {{path/to/file1}} {{path/to/file2}} {{path/to/file3}}`"}
{"instruction": "What is gpasswd command", "input": "", "output": "# gpasswd\n> Administer `/etc/group` and `/etc/gshadow`. More information:\n> https://manned.org/gpasswd.\n  * Define group administrators:\n`sudo gpasswd -A {{user1,user2}} {{group}}`\n  * Set the list of group members:\n`sudo gpasswd -M {{user1,user2}} {{group}}`\n  * Create a password for the named group:\n`gpasswd {{group}}`\n  * Add a user to the named group:\n`gpasswd -a {{user}} {{group}}`\n  * Remove a user from the named group:\n`gpasswd -d {{user}} {{group}}`"}
{"instruction": "What is htop command", "input": "", "output": "# htop\n> Display dynamic real-time information about running processes. An enhanced\n> version of `top`. More information: https://htop.dev/.\n  * Start `htop`:\n`htop`\n  * Start `htop` displaying processes owned by a specific user:\n`htop --user {{username}}`\n  * Sort processes by a specified `sort_item` (use `htop --sort help` for available options):\n`htop --sort {{sort_item}}`\n  * See interactive commands while running htop:\n`?`\n  * Switch to a different tab:\n`tab`\n  * Display help:\n`htop --help`"}
{"instruction": "What is git-show command", "input": "", "output": "# git show\n> Show various types of Git objects (commits, tags, etc.). More information:\n> https://git-scm.com/docs/git-show.\n  * Show information about the latest commit (hash, message, changes, and other metadata):\n`git show`\n  * Show information about a given commit:\n`git show {{commit}}`\n  * Show information about the commit associated with a given tag:\n`git show {{tag}}`\n  * Show information about the 3rd commit from the HEAD of a branch:\n`git show {{branch}}~{{3}}`\n  * Show a commit's message in a single line, suppressing the diff output:\n`git show --oneline -s {{commit}}`\n  * Show only statistics (added/removed characters) about the changed files:\n`git show --stat {{commit}}`\n  * Show only the list of added, renamed or deleted files:\n`git show --summary {{commit}}`\n  * Show the contents of a file as it was at a given revision (e.g. branch, tag or commit):\n`git show {{revision}}:{{path/to/file}}`"}
{"instruction": "What is tar command", "input": "", "output": "# tar\n> Archiving utility. Often combined with a compression method, such as gzip or\n> bzip2. More information: https://www.gnu.org/software/tar.\n  * [c]reate an archive and write it to a [f]ile:\n`tar cf {{path/to/target.tar}} {{path/to/file1 path/to/file2 ...}}`\n  * [c]reate a g[z]ipped archive and write it to a [f]ile:\n`tar czf {{path/to/target.tar.gz}} {{path/to/file1 path/to/file2 ...}}`\n  * [c]reate a g[z]ipped archive from a directory using relative paths:\n`tar czf {{path/to/target.tar.gz}} --directory={{path/to/directory}} .`\n  * E[x]tract a (compressed) archive [f]ile into the current directory [v]erbosely:\n`tar xvf {{path/to/source.tar[.gz|.bz2|.xz]}}`\n  * E[x]tract a (compressed) archive [f]ile into the target directory:\n`tar xf {{path/to/source.tar[.gz|.bz2|.xz]}}\n--directory={{path/to/directory}}`\n  * [c]reate a compressed archive and write it to a [f]ile, using [a]rchive suffix to determine the compression program:\n`tar caf {{path/to/target.tar.xz}} {{path/to/file1 path/to/file2 ...}}`\n  * Lis[t] the contents of a tar [f]ile [v]erbosely:\n`tar tvf {{path/to/source.tar}}`\n  * E[x]tract files matching a pattern from an archive [f]ile:\n`tar xf {{path/to/source.tar}} --wildcards \"{{*.html}}\"`"}
{"instruction": "What is pr command", "input": "", "output": "# pr\n> Paginate or columnate files for printing. More information:\n> https://www.gnu.org/software/coreutils/pr.\n  * Print multiple files with a default header and footer:\n`pr {{file1}} {{file2}} {{file3}}`\n  * Print with a custom centered header:\n`pr -h \"{{header}}\" {{file1}} {{file2}} {{file3}}`\n  * Print with numbered lines and a custom date format:\n`pr -n -D \"{{format}}\" {{file1}} {{file2}} {{file3}}`\n  * Print all files together, one in each column, without a header or footer:\n`pr -m -T {{file1}} {{file2}} {{file3}}`\n  * Print, beginning at page 2 up to page 5, with a given page length (including header and footer):\n`pr +{{2}}:{{5}} -l {{page_length}} {{file1}} {{file2}} {{file3}}`\n  * Print with an offset for each line and a truncating custom page width:\n`pr -o {{offset}} -W {{width}} {{file1}} {{file2}} {{file3}}`"}
{"instruction": "What is git-restore command", "input": "", "output": "# git restore\n> Restore working tree files. Requires Git version 2.23+. See also `git\n> checkout` and `git reset`. More information: https://git-scm.com/docs/git-\n> restore.\n  * Restore an unstaged file to the version of the current commit (HEAD):\n`git restore {{path/to/file}}`\n  * Restore an unstaged file to the version of a specific commit:\n`git restore --source {{commit}} {{path/to/file}}`\n  * Discard all unstaged changes to tracked files:\n`git restore :/`\n  * Unstage a file:\n`git restore --staged {{path/to/file}}`\n  * Unstage all files:\n`git restore --staged :/`\n  * Discard all changes to files, both staged and unstaged:\n`git restore --worktree --staged :/`\n  * Interactively select sections of files to restore:\n`git restore --patch`"}
{"instruction": "What is git-archive command", "input": "", "output": "# git archive\n> Create an archive of files from a named tree. More information: https://git-\n> scm.com/docs/git-archive.\n  * Create a tar archive from the contents of the current HEAD and print it to `stdout`:\n`git archive --verbose HEAD`\n  * Create a zip archive from the current HEAD and print it to `stdout`:\n`git archive --verbose --format=zip HEAD`\n  * Same as above, but write the zip archive to file:\n`git archive --verbose --output={{path/to/file.zip}} HEAD`\n  * Create a tar archive from the contents of the latest commit on a specific branch:\n`git archive --output={{path/to/file.tar}} {{branch_name}}`\n  * Create a tar archive from the contents of a specific directory:\n`git archive --output={{path/to/file.tar}} HEAD:{{path/to/directory}}`\n  * Prepend a path to each file to archive it inside a specific directory:\n`git archive --output={{path/to/file.tar}} --prefix={{path/to/prepend}}/ HEAD`"}
{"instruction": "What is uname command", "input": "", "output": "# uname\n> Print details about the current machine and the operating system running on\n> it. Note: for additional information about the operating system, try the\n> `sw_vers` command. More information: https://ss64.com/osx/uname.html.\n  * Print kernel name:\n`uname`\n  * Print system architecture and processor information:\n`uname -mp`\n  * Print kernel name, kernel release and kernel version:\n`uname -srv`\n  * Print system hostname:\n`uname -n`\n  * Print all available system information:\n`uname -a`"}
{"instruction": "What is tee command", "input": "", "output": "# tee\n> Read from `stdin` and write to `stdout` and files (or commands). More\n> information: https://www.gnu.org/software/coreutils/tee.\n  * Copy `stdin` to each file, and also to `stdout`:\n`echo \"example\" | tee {{path/to/file}}`\n  * Append to the given files, do not overwrite:\n`echo \"example\" | tee -a {{path/to/file}}`\n  * Print `stdin` to the terminal, and also pipe it into another program for further processing:\n`echo \"example\" | tee {{/dev/tty}} | {{xargs printf \"[%s]\"}}`\n  * Create a directory called \"example\", count the number of characters in \"example\" and write \"example\" to the terminal:\n`echo \"example\" | tee >(xargs mkdir) >(wc -c)`"}
{"instruction": "What is join command", "input": "", "output": "# join\n> Join lines of two sorted files on a common field. More information:\n> https://www.gnu.org/software/coreutils/join.\n  * Join two files on the first (default) field:\n`join {{file1}} {{file2}}`\n  * Join two files using a comma (instead of a space) as the field separator:\n`join -t {{','}} {{file1}} {{file2}}`\n  * Join field3 of file1 with field1 of file2:\n`join -1 {{3}} -2 {{1}} {{file1}} {{file2}}`\n  * Produce a line for each unpairable line for file1:\n`join -a {{1}} {{file1}} {{file2}}`\n  * Join a file from `stdin`:\n`cat {{path/to/file1}} | join - {{path/to/file2}}`"}
{"instruction": "What is pidof command", "input": "", "output": "# pidof\n> Gets the ID of a process using its name. More information:\n> https://manned.org/pidof.\n  * List all process IDs with given name:\n`pidof {{bash}}`\n  * List a single process ID with given name:\n`pidof -s {{bash}}`\n  * List process IDs including scripts with given name:\n`pidof -x {{script.py}}`\n  * Kill all processes with given name:\n`kill $(pidof {{name}})`"}
{"instruction": "What is wait command", "input": "", "output": "# wait\n> Wait for a process to complete before proceeding. More information:\n> https://manned.org/wait.\n  * Wait for a process to finish given its process ID (PID) and return its exit status:\n`wait {{pid}}`\n  * Wait for all processes known to the invoking shell to finish:\n`wait`"}
{"instruction": "What is git-difftool command", "input": "", "output": "# git difftool\n> Show file changes using external diff tools. Accepts the same options and\n> arguments as `git diff`. See also: `git diff`. More information:\n> https://git-scm.com/docs/git-difftool.\n  * List available diff tools:\n`git difftool --tool-help`\n  * Set the default diff tool to meld:\n`git config --global diff.tool \"{{meld}}\"`\n  * Use the default diff tool to show staged changes:\n`git difftool --staged`\n  * Use a specific tool (opendiff) to show changes since a given commit:\n`git difftool --tool={{opendiff}} {{commit}}`"}
{"instruction": "What is wc command", "input": "", "output": "# wc\n> Count lines, words, or bytes. More information:\n> https://ss64.com/osx/wc.html.\n  * Count lines in file:\n`wc -l {{path/to/file}}`\n  * Count words in file:\n`wc -w {{path/to/file}}`\n  * Count characters (bytes) in file:\n`wc -c {{path/to/file}}`\n  * Count characters in file (taking multi-byte character sets into account):\n`wc -m {{path/to/file}}`\n  * Use `stdin` to count lines, words and characters (bytes) in that order:\n`{{find .}} | wc`"}
{"instruction": "What is passwd command", "input": "", "output": "# passwd\n> Passwd is a tool used to change a user's password. More information:\n> https://manned.org/passwd.\n  * Change the password of the current user interactively:\n`passwd`\n  * Change the password of a specific user:\n`passwd {{username}}`\n  * Get the current status of the user:\n`passwd -S`\n  * Make the password of the account blank (it will set the named account passwordless):\n`passwd -d`"}
{"instruction": "What is command command", "input": "", "output": "# command\n> Command forces the shell to execute the program and ignore any functions,\n> builtins and aliases with the same name. More information:\n> https://manned.org/command.\n  * Execute the `ls` program literally, even if an `ls` alias exists:\n`command {{ls}}`\n  * Display the path to the executable or the alias definition of a specific command:\n`command -v {{command_name}}`"}
{"instruction": "What is getent command", "input": "", "output": "# getent\n> Get entries from Name Service Switch libraries. More information:\n> https://manned.org/getent.\n  * Get list of all groups:\n`getent group`\n  * See the members of a group:\n`getent group {{group_name}}`\n  * Get list of all services:\n`getent services`\n  * Find a username by UID:\n`getent passwd 1000`\n  * Perform a reverse DNS lookup:\n`getent hosts {{host}}`"}
{"instruction": "What is dd command", "input": "", "output": "# dd\n> Convert and copy a file. More information: https://keith.github.io/xcode-\n> man-pages/dd.1.html.\n  * Make a bootable USB drive from an isohybrid file (such like `archlinux-xxx.iso`) and show the progress:\n`dd if={{path/to/file.iso}} of={{/dev/usb_device}} status=progress`\n  * Clone a drive to another drive with 4 MB block, ignore error and show the progress:\n`dd if={{/dev/source_device}} of={{/dev/dest_device}} bs={{4m}}\nconv={{noerror}} status=progress`\n  * Generate a file of 100 random bytes by using kernel random driver:\n`dd if=/dev/urandom of={{path/to/random_file}} bs={{100}} count={{1}}`\n  * Benchmark the write performance of a disk:\n`dd if=/dev/zero of={{path/to/1GB_file}} bs={{1024}} count={{1000000}}`\n  * Generate a system backup into an IMG file and show the progress:\n`dd if=/dev/{{drive_device}} of={{path/to/file.img}} status=progress`\n  * Restore a drive from an IMG file and show the progress:\n`dd if={{path/to/file.img}} of={{/dev/drive_device}} status=progress`\n  * Check the progress of an ongoing dd operation (run this command from another shell):\n`kill -USR1 $(pgrep ^dd)`"}
{"instruction": "What is join command", "input": "", "output": "# join\n> Join lines of two sorted files on a common field. More information:\n> https://www.gnu.org/software/coreutils/join.\n  * Join two files on the first (default) field:\n`join {{file1}} {{file2}}`\n  * Join two files using a comma (instead of a space) as the field separator:\n`join -t {{','}} {{file1}} {{file2}}`\n  * Join field3 of file1 with field1 of file2:\n`join -1 {{3}} -2 {{1}} {{file1}} {{file2}}`\n  * Produce a line for each unpairable line for file1:\n`join -a {{1}} {{file1}} {{file2}}`\n  * Join a file from `stdin`:\n`cat {{path/to/file1}} | join - {{path/to/file2}}`"}
{"instruction": "What is bg command", "input": "", "output": "# bg\n> Resumes jobs that have been suspended (e.g. using `Ctrl + Z`), and keeps\n> them running in the background. More information: https://manned.org/bg.\n  * Resume the most recently suspended job and run it in the background:\n`bg`\n  * Resume a specific job (use `jobs -l` to get its ID) and run it in the background:\n`bg %{{job_id}}`"}
{"instruction": "What is git-var command", "input": "", "output": "# git var\n> Prints a Git logical variable's value. See `git config`, which is preferred\n> over `git var`. More information: https://git-scm.com/docs/git-var.\n  * Print the value of a Git logical variable:\n`git var {{GIT_AUTHOR_IDENT|GIT_COMMITTER_IDENT|GIT_EDITOR|GIT_PAGER}}`\n  * [l]ist all Git logical variables:\n`git var -l`"}
{"instruction": "What is make command", "input": "", "output": "# make\n> Task runner for targets described in Makefile. Mostly used to control the\n> compilation of an executable from source code. More information:\n> https://www.gnu.org/software/make/manual/make.html.\n  * Call the first target specified in the Makefile (usually named \"all\"):\n`make`\n  * Call a specific target:\n`make {{target}}`\n  * Call a specific target, executing 4 jobs at a time in parallel:\n`make -j{{4}} {{target}}`\n  * Use a specific Makefile:\n`make --file {{path/to/file}}`\n  * Execute make from another directory:\n`make --directory {{path/to/directory}}`\n  * Force making of a target, even if source files are unchanged:\n`make --always-make {{target}}`\n  * Override a variable defined in the Makefile:\n`make {{target}} {{variable}}={{new_value}}`\n  * Override variables defined in the Makefile by the environment:\n`make --environment-overrides {{target}}`"}
{"instruction": "What is uudecode command", "input": "", "output": "# uudecode\n> Decode files encoded by `uuencode`. More information:\n> https://manned.org/uudecode.\n  * Decode a file that was encoded with `uuencode` and print the result to `stdout`:\n`uudecode {{path/to/encoded_file}}`\n  * Decode a file that was encoded with `uuencode` and write the result to a file:\n`uudecode -o {{path/to/decoded_file}} {{path/to/encoded_file}}`"}
{"instruction": "What is diff command", "input": "", "output": "# diff\n> Compare files and directories. More information: https://man7.org/linux/man-\n> pages/man1/diff.1.html.\n  * Compare files (lists changes to turn `old_file` into `new_file`):\n`diff {{old_file}} {{new_file}}`\n  * Compare files, ignoring white spaces:\n`diff --ignore-all-space {{old_file}} {{new_file}}`\n  * Compare files, showing the differences side by side:\n`diff --side-by-side {{old_file}} {{new_file}}`\n  * Compare files, showing the differences in unified format (as used by `git diff`):\n`diff --unified {{old_file}} {{new_file}}`\n  * Compare directories recursively (shows names for differing files/directories as well as changes made to files):\n`diff --recursive {{old_directory}} {{new_directory}}`\n  * Compare directories, only showing the names of files that differ:\n`diff --recursive --brief {{old_directory}} {{new_directory}}`\n  * Create a patch file for Git from the differences of two text files, treating nonexistent files as empty:\n`diff --text --unified --new-file {{old_file}} {{new_file}} > {{diff.patch}}`"}
{"instruction": "What is ln command", "input": "", "output": "# ln\n> Creates links to files and directories. More information:\n> https://www.gnu.org/software/coreutils/ln.\n  * Create a symbolic link to a file or directory:\n`ln -s {{/path/to/file_or_directory}} {{path/to/symlink}}`\n  * Overwrite an existing symbolic link to point to a different file:\n`ln -sf {{/path/to/new_file}} {{path/to/symlink}}`\n  * Create a hard link to a file:\n`ln {{/path/to/file}} {{path/to/hardlink}}`"}
{"instruction": "What is cal command", "input": "", "output": "# cal\n> Prints calendar information. More information:\n> https://ss64.com/osx/cal.html.\n  * Display a calendar for the current month:\n`cal`\n  * Display previous, current and next month:\n`cal -3`\n  * Display a calendar for a specific month (1-12 or name):\n`cal -m {{month}}`\n  * Display a calendar for the current year:\n`cal -y`\n  * Display a calendar for a specific year (4 digits):\n`cal {{year}}`\n  * Display a calendar for a specific month and year:\n`cal {{month}} {{year}}`\n  * Display date of Easter (Western Christian churches) in a given year:\n`ncal -e {{year}}`"}
{"instruction": "What is file command", "input": "", "output": "# file\n> Determine file type. More information: https://manned.org/file.\n  * Give a description of the type of the specified file. Works fine for files with no file extension:\n`file {{path/to/file}}`\n  * Look inside a zipped file and determine the file type(s) inside:\n`file -z {{foo.zip}}`\n  * Allow file to work with special or device files:\n`file -s {{path/to/file}}`\n  * Don't stop at first file type match; keep going until the end of the file:\n`file -k {{path/to/file}}`\n  * Determine the MIME encoding type of a file:\n`file -i {{path/to/file}}`"}
{"instruction": "What is vi command", "input": "", "output": "# vi\n> This command is an alias of `vim`.\n  * View documentation for the original command:\n`tldr vim`"}
{"instruction": "What is pwdx command", "input": "", "output": "# pwdx\n> Print working directory of a process. More information:\n> https://manned.org/pwdx.\n  * Print current working directory of a process:\n`pwdx {{process_id}}`"}
{"instruction": "What is locate command", "input": "", "output": "# locate\n> Find filenames quickly. More information: https://manned.org/locate.\n  * Look for pattern in the database. Note: the database is recomputed periodically (usually weekly or daily):\n`locate \"{{pattern}}\"`\n  * Look for a file by its exact filename (a pattern containing no globbing characters is interpreted as `*pattern*`):\n`locate */{{filename}}`\n  * Recompute the database. You need to do it if you want to find recently added files:\n`sudo /usr/libexec/locate.updatedb`"}
{"instruction": "What is rm command", "input": "", "output": "# rm\n> Remove files or directories. See also: `rmdir`. More information:\n> https://www.gnu.org/software/coreutils/rm.\n  * Remove specific files:\n`rm {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files ignoring nonexistent ones:\n`rm -f {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files [i]nteractively prompting before each removal:\n`rm -i {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files printing info about each removal:\n`rm -v {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files and directories [r]ecursively:\n`rm -r {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}`"}
{"instruction": "What is ldapsearch command", "input": "", "output": "# ldapsearch\n> Query an LDAP directory. More information: https://docs.ldap.com/ldap-\n> sdk/docs/tool-usages/ldapsearch.html.\n  * Query an LDAP server for all items that are a member of the given group and return the object's displayName value:\n`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b\n{{base_ou}} '{{memberOf=group1}}' displayName`\n  * Query an LDAP server with a no-newline password file for all items that are a member of the given group and return the object's displayName value:\n`ldapsearch -D '{{admin_DN}}' -y '{{password_file}}' -h {{ldap_host}} -b\n{{base_ou}} '{{memberOf=group1}}' displayName`\n  * Return 5 items that match the given filter:\n`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b\n{{base_ou}} '{{memberOf=group1}}' -z 5 displayName`\n  * Wait up to 7 seconds for a response:\n`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b\n{{base_ou}} '{{memberOf=group1}}' -l 7 displayName`\n  * Invert the filter:\n`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}} -b\n{{base_ou}} '(!(memberOf={{group1}}))' displayName`\n  * Return all items that are part of multiple groups, returning the display name for each item:\n`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}}\n'(&({{memberOf=group1}})({{memberOf=group2}})({{memberOf=group3}}))'\n\"displayName\"`\n  * Return all items that are members of at least 1 of the specified groups:\n`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}}\n'(|({{memberOf=group1}})({{memberOf=group1}})({{memberOf=group3}}))'\ndisplayName`\n  * Combine multiple boolean logic filters:\n`ldapsearch -D '{{admin_DN}}' -w '{{password}}' -h {{ldap_host}}\n'(&({{memberOf=group1}})({{memberOf=group2}})(!({{memberOf=group3}})))'\ndisplayName`"}
{"instruction": "What is git-clean command", "input": "", "output": "# git clean\n> Remove untracked files from the working tree. More information: https://git-\n> scm.com/docs/git-clean.\n  * Delete files that are not tracked by Git:\n`git clean`\n  * Interactively delete files that are not tracked by Git:\n`git clean -i`\n  * Show what files would be deleted without actually deleting them:\n`git clean --dry-run`\n  * Forcefully delete files that are not tracked by Git:\n`git clean -f`\n  * Forcefully delete directories that are not tracked by Git:\n`git clean -fd`\n  * Delete untracked files, including ignored files in `.gitignore` and `.git/info/exclude`:\n`git clean -x`"}
{"instruction": "What is git-bugreport command", "input": "", "output": "# git bugreport\n> Captures debug information from the system and user, generating a text file\n> to aid in the reporting of a bug in Git. More information: https://git-\n> scm.com/docs/git-bugreport.\n  * Create a new bug report file in the current directory:\n`git bugreport`\n  * Create a new bug report file in the specified directory, creating it if it does not exist:\n`git bugreport --output-directory {{path/to/directory}}`\n  * Create a new bug report file with the specified filename suffix in `strftime` format:\n`git bugreport --suffix {{%m%d%y}}`"}
{"instruction": "What is keyctl command", "input": "", "output": "# keyctl\n> Manipulate the Linux kernel keyring. More information:\n> https://manned.org/keyctl.\n  * List keys in a specific keyring:\n`keyctl list {{target_keyring}}`\n  * List current keys in the user default session:\n`keyctl list {{@us}}`\n  * Store a key in a specific keyring:\n`keyctl add {{type_keyring}} {{key_name}} {{key_value}} {{target_keyring}}`\n  * Store a key with its value from `stdin`:\n`echo -n {{key_value}} | keyctl padd {{type_keyring}} {{key_name}}\n{{target_keyring}}`\n  * Put a timeout on a key:\n`keyctl timeout {{key_name}} {{timeout_in_seconds}}`\n  * Read a key and format it as a hex-dump if not printable:\n`keyctl read {{key_name}}`\n  * Read a key and format as-is:\n`keyctl pipe {{key_name}}`\n  * Revoke a key and prevent any further action on it:\n`keyctl revoke {{key_name}}`"}
{"instruction": "What is dpkg-query command", "input": "", "output": "# dpkg-query\n> A tool that shows information about installed packages. More information:\n> https://manpages.debian.org/latest/dpkg/dpkg-query.1.html.\n  * List all installed packages:\n`dpkg-query --list`\n  * List installed packages matching a pattern:\n`dpkg-query --list '{{libc6*}}'`\n  * List all files installed by a package:\n`dpkg-query --listfiles {{libc6}}`\n  * Show information about a package:\n`dpkg-query --status {{libc6}}`\n  * Search for packages that own files matching a pattern:\n`dpkg-query --search {{/etc/ld.so.conf.d}}`"}
{"instruction": "What is git-blame command", "input": "", "output": "# git blame\n> Show commit hash and last author on each line of a file. More information:\n> https://git-scm.com/docs/git-blame.\n  * Print file with author name and commit hash on each line:\n`git blame {{path/to/file}}`\n  * Print file with author email and commit hash on each line:\n`git blame -e {{path/to/file}}`\n  * Print file with author name and commit hash on each line at a specific commit:\n`git blame {{commit}} {{path/to/file}}`\n  * Print file with author name and commit hash on each line before a specific commit:\n`git blame {{commit}}~ {{path/to/file}}`"}
{"instruction": "What is login command", "input": "", "output": "# login\n> Initiates a session for a user. More information: https://manned.org/login.\n  * Log in as a user:\n`login {{user}}`\n  * Log in as user without authentication if user is preauthenticated:\n`login -f {{user}}`\n  * Log in as user and preserve environment:\n`login -p {{user}}`\n  * Log in as a user on a remote host:\n`login -h {{host}} {{user}}`"}
{"instruction": "What is git-show-index command", "input": "", "output": "# git show-index\n> Show the packed archive index of a Git repository. More information:\n> https://git-scm.com/docs/git-show-index.\n  * Read an IDX file for a Git packfile and dump its contents to `stdout`:\n`git show-index {{path/to/file.idx}}`\n  * Specify the hash algorithm for the index file (experimental):\n`git show-index --object-format={{sha1|sha256}} {{path/to/file}}`"}
{"instruction": "What is crontab command", "input": "", "output": "# crontab\n> Schedule cron jobs to run on a time interval for the current user. More\n> information: https://crontab.guru/.\n  * Edit the crontab file for the current user:\n`crontab -e`\n  * Edit the crontab file for a specific user:\n`sudo crontab -e -u {{user}}`\n  * Replace the current crontab with the contents of the given file:\n`crontab {{path/to/file}}`\n  * View a list of existing cron jobs for current user:\n`crontab -l`\n  * Remove all cron jobs for the current user:\n`crontab -r`\n  * Sample job which runs at 10:00 every day (* means any value):\n`0 10 * * * {{command_to_execute}}`\n  * Sample crontab entry, which runs a command every 10 minutes:\n`*/10 * * * * {{command_to_execute}}`\n  * Sample crontab entry, which runs a certain script at 02:30 every Friday:\n`30 2 * * Fri {{/absolute/path/to/script.sh}}`"}
{"instruction": "What is install command", "input": "", "output": "# install\n> Copy files and set attributes. Copy files (often executable) to a system\n> location like `/usr/local/bin`, give them the appropriate\n> permissions/ownership. More information:\n> https://www.gnu.org/software/coreutils/install.\n  * Copy files to the destination:\n`install {{path/to/source_file1 path/to/source_file2 ...}}\n{{path/to/destination}}`\n  * Copy files to the destination, setting their ownership:\n`install --owner {{user}} {{path/to/source_file1 path/to/source_file2 ...}}\n{{path/to/destination}}`\n  * Copy files to the destination, setting their group ownership:\n`install --group {{user}} {{path/to/source_file1 path/to/source_file2 ...}}\n{{path/to/destination}}`\n  * Copy files to the destination, setting their `mode`:\n`install --mode {{+x}} {{path/to/source_file1 path/to/source_file2 ...}}\n{{path/to/destination}}`\n  * Copy files and apply access/modification times of source to the destination:\n`install --preserve-timestamps {{path/to/source_file1 path/to/source_file2\n...}} {{path/to/destination}}`\n  * Copy files and create the directories at the destination if they don't exist:\n`install -D {{path/to/source_file1 path/to/source_file2 ...}}\n{{path/to/destination}}`"}
{"instruction": "What is colrm command", "input": "", "output": "# colrm\n> Remove columns from `stdin`. More information: https://manned.org/colrm.\n  * Remove first column of `stdin`:\n`colrm {{1 1}}`\n  * Remove from 3rd column till the end of each line:\n`colrm {{3}}`\n  * Remove from the 3rd column till the 5th column of each line:\n`colrm {{3 5}}`"}
{"instruction": "What is resolvectl command", "input": "", "output": "# resolvectl\n> Resolve domain names, IPv4 and IPv6 addresses, DNS resource records, and\n> services. Introspect and reconfigure the DNS resolver. More information:\n> https://www.freedesktop.org/software/systemd/man/resolvectl.html.\n  * Show DNS settings:\n`resolvectl status`\n  * Resolve the IPv4 and IPv6 addresses for one or more domains:\n`resolvectl query {{domain1 domain2 ...}}`\n  * Retrieve the domain of a specified IP address:\n`resolvectl query {{ip_address}}`\n  * Retrieve an MX record of a domain:\n`resolvectl --legend={{no}} --type={{MX}} query {{domain}}`\n  * Resolve an SRV record, for example _xmpp-server._tcp gmail.com:\n`resolvectl service _{{service}}._{{protocol}} {{name}}`\n  * Retrieve the public key from an email address from an OPENPGPKEY DNS record:\n`resolvectl openpgp {{email}}`\n  * Retrieve a TLS key:\n`resolvectl tlsa tcp {{domain}}:443`"}
{"instruction": "What is ssh-keygen command", "input": "", "output": "# ssh-keygen\n> Generate ssh keys used for authentication, password-less logins, and other\n> things. More information: https://man.openbsd.org/ssh-keygen.\n  * Generate a key interactively:\n`ssh-keygen`\n  * Generate an ed25519 key with 32 key derivation function rounds and save the key to a specific file:\n`ssh-keygen -t {{ed25519}} -a {{32}} -f {{~/.ssh/filename}}`\n  * Generate an RSA 4096-bit key with email as a comment:\n`ssh-keygen -t {{rsa}} -b {{4096}} -C \"{{comment|email}}\"`\n  * Remove the keys of a host from the known_hosts file (useful when a known host has a new key):\n`ssh-keygen -R {{remote_host}}`\n  * Retrieve the fingerprint of a key in MD5 Hex:\n`ssh-keygen -l -E {{md5}} -f {{~/.ssh/filename}}`\n  * Change the password of a key:\n`ssh-keygen -p -f {{~/.ssh/filename}}`\n  * Change the type of the key format (for example from OPENSSH format to PEM), the file will be rewritten in-place:\n`ssh-keygen -p -N \"\" -m {{PEM}} -f {{~/.ssh/OpenSSH_private_key}}`\n  * Retrieve public key from secret key:\n`ssh-keygen -y -f {{~/.ssh/OpenSSH_private_key}}`"}
{"instruction": "What is pidstat command", "input": "", "output": "# pidstat\n> Show system resource usage, including CPU, memory, IO etc. More information:\n> https://manned.org/pidstat.\n  * Show CPU statistics at a 2 second interval for 10 times:\n`pidstat {{2}} {{10}}`\n  * Show page faults and memory utilization:\n`pidstat -r`\n  * Show input/output usage per process id:\n`pidstat -d`\n  * Show information on a specific PID:\n`pidstat -p {{PID}}`\n  * Show memory statistics for all processes whose command name include \"fox\" or \"bird\":\n`pidstat -C \"{{fox|bird}}\" -r -p ALL`"}
{"instruction": "What is git-stash command", "input": "", "output": "# git stash\n> Stash local Git changes in a temporary area. More information: https://git-\n> scm.com/docs/git-stash.\n  * Stash current changes, except new (untracked) files:\n`git stash push -m {{optional_stash_message}}`\n  * Stash current changes, including new (untracked) files:\n`git stash -u`\n  * Interactively select parts of changed files for stashing:\n`git stash -p`\n  * List all stashes (shows stash name, related branch and message):\n`git stash list`\n  * Show the changes as a patch between the stash (default is stash@{0}) and the commit back when stash entry was first created:\n`git stash show -p {{stash@{0}}}`\n  * Apply a stash (default is the latest, named stash@{0}):\n`git stash apply {{optional_stash_name_or_commit}}`\n  * Drop or apply a stash (default is stash@{0}) and remove it from the stash list if applying doesn't cause conflicts:\n`git stash pop {{optional_stash_name}}`\n  * Drop all stashes:\n`git stash clear`"}
{"instruction": "What is git-bisect command", "input": "", "output": "# git bisect\n> Use binary search to find the commit that introduced a bug. Git\n> automatically jumps back and forth in the commit graph to progressively\n> narrow down the faulty commit. More information: https://git-\n> scm.com/docs/git-bisect.\n  * Start a bisect session on a commit range bounded by a known buggy commit, and a known clean (typically older) one:\n`git bisect start {{bad_commit}} {{good_commit}}`\n  * For each commit that `git bisect` selects, mark it as \"bad\" or \"good\" after testing it for the issue:\n`git bisect {{good|bad}}`\n  * After `git bisect` pinpoints the faulty commit, end the bisect session and return to the previous branch:\n`git bisect reset`\n  * Skip a commit during a bisect (e.g. one that fails the tests due to a different issue):\n`git bisect skip`\n  * Display a log of what has been done so far:\n`git bisect log`"}
{"instruction": "What is systemd-ac-power command", "input": "", "output": "# systemd-ac-power\n> Report whether the computer is connected to an external power source. More\n> information: https://www.freedesktop.org/software/systemd/man/systemd-ac-\n> power.html.\n  * Silently check and return a 0 status code when running on AC power, and a non-zero code otherwise:\n`systemd-ac-power`\n  * Additionally print `yes` or `no` to `stdout`:\n`systemd-ac-power --verbose`"}
{"instruction": "What is getopt command", "input": "", "output": "# getopt\n> Parse command-line arguments. More information:\n> https://www.gnu.org/software/libc/manual/html_node/Getopt.html.\n  * Parse optional `verbose`/`version` flags with shorthands:\n`getopt --options vV --longoptions verbose,version -- --version --verbose`\n  * Add a `--file` option with a required argument with shorthand `-f`:\n`getopt --options f: --longoptions file: -- --file=somefile`\n  * Add a `--verbose` option with an optional argument with shorthand `-v`, and pass a non-option parameter `arg`:\n`getopt --options v:: --longoptions verbose:: -- --verbose arg`\n  * Accept a `-r` and `--verbose` flag, a `--accept` option with an optional argument and add a `--target` with a required argument option with shorthands:\n`getopt --options rv::s::t: --longoptions verbose,source::,target: -- -v\n--target target`"}
{"instruction": "What is pkill command", "input": "", "output": "# pkill\n> Signal process by name. Mostly used for stopping processes. More\n> information: https://www.man7.org/linux/man-pages/man1/pkill.1.html.\n  * Kill all processes which match:\n`pkill \"{{process_name}}\"`\n  * Kill all processes which match their full command instead of just the process name:\n`pkill -f \"{{command_name}}\"`\n  * Force kill matching processes (can't be blocked):\n`pkill -9 \"{{process_name}}\"`\n  * Send SIGUSR1 signal to processes which match:\n`pkill -USR1 \"{{process_name}}\"`\n  * Kill the main `firefox` process to close the browser:\n`pkill --oldest \"{{firefox}}\"`"}
{"instruction": "What is ssh-keyscan command", "input": "", "output": "# ssh-keyscan\n> Get the public ssh keys of remote hosts. More information:\n> https://man.openbsd.org/ssh-keyscan.\n  * Retrieve all public ssh keys of a remote host:\n`ssh-keyscan {{host}}`\n  * Retrieve all public ssh keys of a remote host listening on a specific port:\n`ssh-keyscan -p {{port}} {{host}}`\n  * Retrieve certain types of public ssh keys of a remote host:\n`ssh-keyscan -t {{rsa,dsa,ecdsa,ed25519}} {{host}}`\n  * Manually update the ssh known_hosts file with the fingerprint of a given host:\n`ssh-keyscan -H {{host}} >> ~/.ssh/known_hosts`"}
{"instruction": "What is test command", "input": "", "output": "# test\n> Check file types and compare values. Returns 0 if the condition evaluates to\n> true, 1 if it evaluates to false. More information:\n> https://www.gnu.org/software/coreutils/test.\n  * Test if a given variable is equal to a given string:\n`test \"{{$MY_VAR}}\" == \"{{/bin/zsh}}\"`\n  * Test if a given variable is empty:\n`test -z \"{{$GIT_BRANCH}}\"`\n  * Test if a file exists:\n`test -f \"{{path/to/file_or_directory}}\"`\n  * Test if a directory does not exist:\n`test ! -d \"{{path/to/directory}}\"`\n  * If A is true, then do B, or C in the case of an error (notice that C may run even if A fails):\n`test {{condition}} && {{echo \"true\"}} || {{echo \"false\"}}`"}
{"instruction": "What is systemd-notify command", "input": "", "output": "# systemd-notify\n> Notify the service manager about start-up completion and other daemon status\n> changes. This command is useless outside systemd service scripts. More\n> information: https://www.freedesktop.org/software/systemd/man/systemd-\n> notify.html.\n  * Notify systemd that the service has completed its initialization and is fully started. It should be invoked when the service is ready to accept incoming requests:\n`systemd-notify --booted`\n  * Signal to systemd that the service is ready to handle incoming connections or perform its tasks:\n`systemd-notify --ready`\n  * Provide a custom status message to systemd (this information is shown by `systemctl status`):\n`systemd-notify --status=\"{{Add custom status message here...}}\"`"}
{"instruction": "What is pr command", "input": "", "output": "# pr\n> Paginate or columnate files for printing. More information:\n> https://www.gnu.org/software/coreutils/pr.\n  * Print multiple files with a default header and footer:\n`pr {{file1}} {{file2}} {{file3}}`\n  * Print with a custom centered header:\n`pr -h \"{{header}}\" {{file1}} {{file2}} {{file3}}`\n  * Print with numbered lines and a custom date format:\n`pr -n -D \"{{format}}\" {{file1}} {{file2}} {{file3}}`\n  * Print all files together, one in each column, without a header or footer:\n`pr -m -T {{file1}} {{file2}} {{file3}}`\n  * Print, beginning at page 2 up to page 5, with a given page length (including header and footer):\n`pr +{{2}}:{{5}} -l {{page_length}} {{file1}} {{file2}} {{file3}}`\n  * Print with an offset for each line and a truncating custom page width:\n`pr -o {{offset}} -W {{width}} {{file1}} {{file2}} {{file3}}`"}
{"instruction": "What is git-symbolic-ref command", "input": "", "output": "# git symbolic-ref\n> Read, change, or delete files that store references. More information:\n> https://git-scm.com/docs/git-symbolic-ref.\n  * Store a reference by a name:\n`git symbolic-ref refs/{{name}} {{ref}}`\n  * Store a reference by name, including a message with a reason for the update:\n`git symbolic-ref -m \"{{message}}\" refs/{{name}} refs/heads/{{branch_name}}`\n  * Read a reference by name:\n`git symbolic-ref refs/{{name}}`\n  * Delete a reference by name:\n`git symbolic-ref --delete refs/{{name}}`\n  * For scripting, hide errors with `--quiet` and use `--short` to simplify (\"refs/heads/X\" prints as \"X\"):\n`git symbolic-ref --quiet --short refs/{{name}}`"}
{"instruction": "What is tty command", "input": "", "output": "# tty\n> Returns terminal name. More information:\n> https://www.gnu.org/software/coreutils/tty.\n  * Print the file name of this terminal:\n`tty`"}
{"instruction": "What is git-instaweb command", "input": "", "output": "# git instaweb\n> Helper to launch a GitWeb server. More information: https://git-\n> scm.com/docs/git-instaweb.\n  * Launch a GitWeb server for the current Git repository:\n`git instaweb --start`\n  * Listen only on localhost:\n`git instaweb --start --local`\n  * Listen on a specific port:\n`git instaweb --start --port {{1234}}`\n  * Use a specified HTTP daemon:\n`git instaweb --start --httpd {{lighttpd|apache2|mongoose|plackup|webrick}}`\n  * Also auto-launch a web browser:\n`git instaweb --start --browser`\n  * Stop the currently running GitWeb server:\n`git instaweb --stop`\n  * Restart the currently running GitWeb server:\n`git instaweb --restart`"}
{"instruction": "What is newgrp command", "input": "", "output": "# newgrp\n> Switch primary group membership. More information:\n> https://manned.org/newgrp.\n  * Change user's primary group membership:\n`newgrp {{group_name}}`\n  * Reset primary group membership to user's default group in `/etc/passwd`:\n`newgrp`"}
{"instruction": "What is dircolors command", "input": "", "output": "# dircolors\n> Output commands to set the LS_COLOR environment variable and style `ls`,\n> `dir`, etc. More information:\n> https://www.gnu.org/software/coreutils/dircolors.\n  * Output commands to set LS_COLOR using default colors:\n`dircolors`\n  * Output commands to set LS_COLOR using colors from a file:\n`dircolors {{path/to/file}}`\n  * Output commands for Bourne shell:\n`dircolors --bourne-shell`\n  * Output commands for C shell:\n`dircolors --c-shell`\n  * View the default colors for file types and extensions:\n`dircolors --print-data`"}
{"instruction": "What is utmpdump command", "input": "", "output": "# utmpdump\n> Dump and load btmp, utmp and wtmp accounting files. More information:\n> https://manned.org/utmpdump.\n  * Dump the `/var/log/wtmp` file to `stdout` as plain text:\n`utmpdump {{/var/log/wtmp}}`\n  * Load a previously dumped file into `/var/log/wtmp`:\n`utmpdump -r {{dumpfile}} > {{/var/log/wtmp}}`"}
{"instruction": "What is lp command", "input": "", "output": "# lp\n> Print files. More information: https://manned.org/lp.\n  * Print the output of a command to the default printer (see `lpstat` command):\n`echo \"test\" | lp`\n  * Print a file to the default printer:\n`lp {{path/to/filename}}`\n  * Print a file to a named printer (see `lpstat` command):\n`lp -d {{printer_name}} {{path/to/filename}}`\n  * Print N copies of file to default printer (replace N with desired number of copies):\n`lp -n {{N}} {{path/to/filename}}`\n  * Print only certain pages to the default printer (print pages 1, 3-5, and 16):\n`lp -P 1,3-5,16 {{path/to/filename}}`\n  * Resume printing a job:\n`lp -i {{job_id}} -H resume`"}
{"instruction": "What is git-verify-tag command", "input": "", "output": "# git verify-tag\n> Check for GPG verification of tags. If a tag wasn't signed, an error will\n> occur. More information: https://git-scm.com/docs/git-verify-tag.\n  * Check tags for a GPG signature:\n`git verify-tag {{tag1 optional_tag2 ...}}`\n  * Check tags for a GPG signature and show details for each tag:\n`git verify-tag {{tag1 optional_tag2 ...}} --verbose`\n  * Check tags for a GPG signature and print the raw details:\n`git verify-tag {{tag1 optional_tag2 ...}} --raw`"}
{"instruction": "What is du command", "input": "", "output": "# du\n> Disk usage: estimate and summarize file and directory space usage. More\n> information: https://ss64.com/osx/du.html.\n  * List the sizes of a directory and any subdirectories, in the given unit (KiB/MiB/GiB):\n`du -{{k|m|g}} {{path/to/directory}}`\n  * List the sizes of a directory and any subdirectories, in human-readable form (i.e. auto-selecting the appropriate unit for each size):\n`du -h {{path/to/directory}}`\n  * Show the size of a single directory, in human-readable units:\n`du -sh {{path/to/directory}}`\n  * List the human-readable sizes of a directory and of all the files and directories within it:\n`du -ah {{path/to/directory}}`\n  * List the human-readable sizes of a directory and any subdirectories, up to N levels deep:\n`du -h -d {{2}} {{path/to/directory}}`\n  * List the human-readable size of all `.jpg` files in subdirectories of the current directory, and show a cumulative total at the end:\n`du -ch {{*/*.jpg}}`"}
{"instruction": "What is pgrep command", "input": "", "output": "# pgrep\n> Find or signal processes by name. More information:\n> https://www.man7.org/linux/man-pages/man1/pkill.1.html.\n  * Return PIDs of any running processes with a matching command string:\n`pgrep {{process_name}}`\n  * Search for processes including their command-line options:\n`pgrep --full \"{{process_name}} {{parameter}}\"`\n  * Search for processes run by a specific user:\n`pgrep --euid root {{process_name}}`"}
{"instruction": "What is bc command", "input": "", "output": "# bc\n> An arbitrary precision calculator language. See also: `dc`. More\n> information: https://manned.org/man/freebsd-13.0/bc.1.\n  * Start an interactive session:\n`bc`\n  * Start an interactive session with the standard math library enabled:\n`bc --mathlib`\n  * Calculate an expression:\n`bc --expression='{{5 / 3}}'`\n  * Execute a script:\n`bc {{path/to/script.bc}}`\n  * Calculate an expression with the specified scale:\n`bc --expression='scale = {{10}}; {{5 / 3}}'`\n  * Calculate a sine/cosine/arctangent/natural logarithm/exponential function using `mathlib`:\n`bc --mathlib --expression='{{s|c|a|l|e}}({{1}})'`"}
{"instruction": "What is git-credential-cache command", "input": "", "output": "# git credential-cache\n> Git helper to temporarily store passwords in memory. More information:\n> https://git-scm.com/docs/git-credential-cache.\n  * Store Git credentials for a specific amount of time:\n`git config credential.helper 'cache --timeout={{time_in_seconds}}'`"}
{"instruction": "What is git-log command", "input": "", "output": "# git log\n> Show a history of commits. More information: https://git-scm.com/docs/git-\n> log.\n  * Show the sequence of commits starting from the current one, in reverse chronological order of the Git repository in the current working directory:\n`git log`\n  * Show the history of a particular file or directory, including differences:\n`git log -p {{path/to/file_or_directory}}`\n  * Show an overview of which file(s) changed in each commit:\n`git log --stat`\n  * Show a graph of commits in the current branch using only the first line of each commit message:\n`git log --oneline --graph`\n  * Show a graph of all commits, tags and branches in the entire repo:\n`git log --oneline --decorate --all --graph`\n  * Show only commits whose messages include a given string (case-insensitively):\n`git log -i --grep {{search_string}}`\n  * Show the last N commits from a certain author:\n`git log -n {{number}} --author={{author}}`\n  * Show commits between two dates (yyyy-mm-dd):\n`git log --before=\"{{2017-01-29}}\" --after=\"{{2017-01-17}}\"`"}
{"instruction": "What is quota command", "input": "", "output": "# quota\n> Display users' disk space usage and allocated limits. More information:\n> https://manned.org/quota.\n  * Show disk quotas in human-readable units for the current user:\n`quota -s`\n  * Verbose output (also display quotas on filesystems where no storage is allocated):\n`quota -v`\n  * Quiet output (only display quotas on filesystems where usage is over quota):\n`quota -q`\n  * Print quotas for the groups of which the current user is a member:\n`quota -g`\n  * Show disk quotas for another user:\n`sudo quota -u {{username}}`"}
{"instruction": "What is git-format-patch command", "input": "", "output": "# git format-patch\n> Prepare .patch files. Useful when emailing commits elsewhere. See also `git\n> am`, which can apply generated .patch files. More information: https://git-\n> scm.com/docs/git-format-patch.\n  * Create an auto-named `.patch` file for all the unpushed commits:\n`git format-patch {{origin}}`\n  * Write a `.patch` file for all the commits between 2 revisions to `stdout`:\n`git format-patch {{revision_1}}..{{revision_2}}`\n  * Write a `.patch` file for the 3 latest commits:\n`git format-patch -{{3}}`"}
{"instruction": "What is false command", "input": "", "output": "# false\n> Returns a non-zero exit code. More information:\n> https://www.gnu.org/software/coreutils/false.\n  * Return a non-zero exit code:\n`false`"}
{"instruction": "What is iconv command", "input": "", "output": "# iconv\n> Converts text from one encoding to another. More information:\n> https://manned.org/iconv.\n  * Convert file to a specific encoding, and print to `stdout`:\n`iconv -f {{from_encoding}} -t {{to_encoding}} {{input_file}}`\n  * Convert file to the current locale's encoding, and output to a file:\n`iconv -f {{from_encoding}} {{input_file}} > {{output_file}}`\n  * List supported encodings:\n`iconv -l`"}
{"instruction": "What is sync command", "input": "", "output": "# sync\n> Flushes all pending write operations to the appropriate disks. More\n> information: https://www.gnu.org/software/coreutils/sync.\n  * Flush all pending write operations on all disks:\n`sync`\n  * Flush all pending write operations on a single file to disk:\n`sync {{path/to/file}}`"}
{"instruction": "What is diff command", "input": "", "output": "# diff\n> Compare files and directories. More information: https://man7.org/linux/man-\n> pages/man1/diff.1.html.\n  * Compare files (lists changes to turn `old_file` into `new_file`):\n`diff {{old_file}} {{new_file}}`\n  * Compare files, ignoring white spaces:\n`diff --ignore-all-space {{old_file}} {{new_file}}`\n  * Compare files, showing the differences side by side:\n`diff --side-by-side {{old_file}} {{new_file}}`\n  * Compare files, showing the differences in unified format (as used by `git diff`):\n`diff --unified {{old_file}} {{new_file}}`\n  * Compare directories recursively (shows names for differing files/directories as well as changes made to files):\n`diff --recursive {{old_directory}} {{new_directory}}`\n  * Compare directories, only showing the names of files that differ:\n`diff --recursive --brief {{old_directory}} {{new_directory}}`\n  * Create a patch file for Git from the differences of two text files, treating nonexistent files as empty:\n`diff --text --unified --new-file {{old_file}} {{new_file}} > {{diff.patch}}`"}
{"instruction": "What is rmdir command", "input": "", "output": "# rmdir\n> Remove directories without files. See also: `rm`. More information:\n> https://www.gnu.org/software/coreutils/rmdir.\n  * Remove specific directories:\n`rmdir {{path/to/directory1 path/to/directory2 ...}}`\n  * Remove specific nested directories recursively:\n`rmdir -p {{path/to/directory1 path/to/directory2 ...}}`"}
{"instruction": "What is shuf command", "input": "", "output": "# shuf\n> Generate random permutations. More information: https://www.unix.com/man-\n> page/linux/1/shuf/.\n  * Randomize the order of lines in a file and output the result:\n`shuf {{filename}}`\n  * Only output the first 5 entries of the result:\n`shuf --head-count={{5}} {{filename}}`\n  * Write output to another file:\n`shuf {{filename}} --output={{output_filename}}`\n  * Generate random numbers in range 1-10:\n`shuf --input-range={{1-10}}`"}
{"instruction": "What is git-bundle command", "input": "", "output": "# git bundle\n> Package objects and references into an archive. More information:\n> https://git-scm.com/docs/git-bundle.\n  * Create a bundle file that contains all objects and references of a specific branch:\n`git bundle create {{path/to/file.bundle}} {{branch_name}}`\n  * Create a bundle file of all branches:\n`git bundle create {{path/to/file.bundle}} --all`\n  * Create a bundle file of the last 5 commits of the current branch:\n`git bundle create {{path/to/file.bundle}} -{{5}} {{HEAD}}`\n  * Create a bundle file of the latest 7 days:\n`git bundle create {{path/to/file.bundle}} --since={{7.days}} {{HEAD}}`\n  * Verify that a bundle file is valid and can be applied to the current repository:\n`git bundle verify {{path/to/file.bundle}}`\n  * Print to `stdout` the list of references contained in a bundle:\n`git bundle unbundle {{path/to/file.bundle}}`\n  * Unbundle a specific branch from a bundle file into the current repository:\n`git pull {{path/to/file.bundle}} {{branch_name}}`"}
{"instruction": "What is link command", "input": "", "output": "# link\n> Create a hard link to an existing file. For more options, see the `ln`\n> command. More information: https://www.gnu.org/software/coreutils/link.\n  * Create a hard link from a new file to an existing file:\n`link {{path/to/existing_file}} {{path/to/new_file}}`"}
{"instruction": "What is systemd-delta command", "input": "", "output": "# systemd-delta\n> Find overridden systemd-related configuration files. More information:\n> https://www.freedesktop.org/software/systemd/man/systemd-delta.html.\n  * Show all overridden configuration files:\n`systemd-delta`\n  * Show only files of specific types (comma-separated list):\n`systemd-delta --type\n{{masked|equivalent|redirected|overridden|extended|unchanged}}`\n  * Show only files whose path starts with the specified prefix (Note: a prefix is a directory containing subdirectories with systemd configuration files):\n`systemd-delta {{/etc|/run|/usr/lib|...}}`\n  * Further restrict the search path by adding a suffix (the prefix is optional):\n`systemd-delta {{prefix}}/{{tmpfiles.d|sysctl.d|systemd/system|...}}`"}
{"instruction": "What is namei command", "input": "", "output": "# namei\n> Follows a pathname (which can be a symbolic link) until a terminal point is\n> found (a file/directory/char device etc). This program is useful for finding\n> \"too many levels of symbolic links\" problems. More information:\n> https://manned.org/namei.\n  * Resolve the pathnames specified as the argument parameters:\n`namei {{path/to/a}} {{path/to/b}} {{path/to/c}}`\n  * Display the results in a long-listing format:\n`namei --long {{path/to/a}} {{path/to/b}} {{path/to/c}}`\n  * Show the mode bits of each file type in the style of `ls`:\n`namei --modes {{path/to/a}} {{path/to/b}} {{path/to/c}}`\n  * Show owner and group name of each file:\n`namei --owners {{path/to/a}} {{path/to/b}} {{path/to/c}}`\n  * Don't follow symlinks while resolving:\n`namei --nosymlinks {{path/to/a}} {{path/to/b}} {{path/to/c}}`"}
{"instruction": "What is lastcomm command", "input": "", "output": "# lastcomm\n> Show last commands executed. More information:\n> https://manpages.debian.org/latest/acct/lastcomm.1.en.html.\n  * Print information about all the commands in the acct (record file):\n`lastcomm`\n  * Display commands executed by a given user:\n`lastcomm --user {{user}}`\n  * Display information about a given command executed on the system:\n`lastcomm --command {{command}}`\n  * Display information about commands executed on a given terminal:\n`lastcomm --tty {{terminal_name}}`"}
{"instruction": "What is egrep command", "input": "", "output": "# egrep\n> Find patterns in files using extended regular expression (supports `?`, `+`,\n> `{}`, `()` and `|`). More information: https://manned.org/egrep.\n  * Search for a pattern within a file:\n`egrep \"{{search_pattern}}\" {{path/to/file}}`\n  * Search for a pattern within multiple files:\n`egrep \"{{search_pattern}}\" {{path/to/file1}} {{path/to/file2}}\n{{path/to/file3}}`\n  * Search `stdin` for a pattern:\n`cat {{path/to/file}} | egrep {{search_pattern}}`\n  * Print file name and line number for each match:\n`egrep --with-filename --line-number \"{{search_pattern}}\" {{path/to/file}}`\n  * Search for a pattern in all files recursively in a directory, ignoring binary files:\n`egrep --recursive --binary-files={{without-match}} \"{{search_pattern}}\"\n{{path/to/directory}}`\n  * Search for lines that do not match a pattern:\n`egrep --invert-match \"{{search_pattern}}\" {{path/to/file}}`"}
{"instruction": "What is setfacl command", "input": "", "output": "# setfacl\n> Set file access control lists (ACL). More information:\n> https://manned.org/setfacl.\n  * Modify ACL of a file for user with read and write access:\n`setfacl -m u:{{username}}:rw {{file}}`\n  * Modify default ACL of a file for all users:\n`setfacl -d -m u::rw {{file}}`\n  * Remove ACL of a file for a user:\n`setfacl -x u:{{username}} {{file}}`\n  * Remove all ACL entries of a file:\n`setfacl -b {{file}}`"}
{"instruction": "What is paste command", "input": "", "output": "# paste\n> Merge lines of files. More information:\n> https://www.gnu.org/software/coreutils/paste.\n  * Join all the lines into a single line, using TAB as delimiter:\n`paste -s {{path/to/file}}`\n  * Join all the lines into a single line, using the specified delimiter:\n`paste -s -d {{delimiter}} {{path/to/file}}`\n  * Merge two files side by side, each in its column, using TAB as delimiter:\n`paste {{file1}} {{file2}}`\n  * Merge two files side by side, each in its column, using the specified delimiter:\n`paste -d {{delimiter}} {{file1}} {{file2}}`\n  * Merge two files, with lines added alternatively:\n`paste -d '\\n' {{file1}} {{file2}}`"}
{"instruction": "What is busctl command", "input": "", "output": "# busctl\n> Introspect and monitor the D-Bus bus. More information:\n> https://www.freedesktop.org/software/systemd/man/busctl.html.\n  * Show all peers on the bus, by their service names:\n`busctl list`\n  * Show process information and credentials of a bus service, a process, or the owner of the bus (if no parameter is specified):\n`busctl status {{service|pid}}`\n  * Dump messages being exchanged. If no service is specified, show all messages on the bus:\n`busctl monitor {{service1 service2 ...}}`\n  * Show an object tree of one or more services (or all services if no service is specified):\n`busctl tree {{service1 service2 ...}}`\n  * Show interfaces, methods, properties and signals of the specified object on the specified service:\n`busctl introspect {{service}} {{path/to/object}}`\n  * Retrieve the current value of one or more object properties:\n`busctl get-property {{service}} {{path/to/object}} {{interface_name}}\n{{property_name}}`\n  * Invoke a method and show the response:\n`busctl call {{service}} {{path/to/object}} {{interface_name}}\n{{method_name}}`"}
{"instruction": "What is readlink command", "input": "", "output": "# readlink\n> Follow symlinks and get symlink information. More information:\n> https://www.gnu.org/software/coreutils/readlink.\n  * Print the absolute path which the symlink points to:\n`readlink {{path/to/symlink_file}}`"}
{"instruction": "What is sh command", "input": "", "output": "# sh\n> Bourne shell, the standard command language interpreter. See also\n> `histexpand` for history expansion. More information: https://manned.org/sh.\n  * Start an interactive shell session:\n`sh`\n  * Execute a command and then exit:\n`sh -c \"{{command}}\"`\n  * Execute a script:\n`sh {{path/to/script.sh}}`\n  * Read and execute commands from `stdin`:\n`sh -s`"}
{"instruction": "What is mpstat command", "input": "", "output": "# mpstat\n> Report CPU statistics. More information: https://manned.org/mpstat.\n  * Display CPU statistics every 2 seconds:\n`mpstat {{2}}`\n  * Display 5 reports, one by one, at 2 second intervals:\n`mpstat {{2}} {{5}}`\n  * Display 5 reports, one by one, from a given processor, at 2 second intervals:\n`mpstat -P {{0}} {{2}} {{5}}`"}
{"instruction": "What is nm command", "input": "", "output": "# nm\n> List symbol names in object files. More information: https://manned.org/nm.\n  * List global (extern) functions in a file (prefixed with T):\n`nm -g {{path/to/file.o}}`\n  * List only undefined symbols in a file:\n`nm -u {{path/to/file.o}}`\n  * List all symbols, even debugging symbols:\n`nm -a {{path/to/file.o}}`\n  * Demangle C++ symbols (make them readable):\n`nm --demangle {{path/to/file.o}}`"}
{"instruction": "What is logger command", "input": "", "output": "# logger\n> Add messages to syslog (/var/log/syslog). More information:\n> https://manned.org/logger.\n  * Log a message to syslog:\n`logger {{message}}`\n  * Take input from `stdin` and log to syslog:\n`echo {{log_entry}} | logger`\n  * Send the output to a remote syslog server running at a given port. Default port is 514:\n`echo {{log_entry}} | logger --server {{hostname}} --port {{port}}`\n  * Use a specific tag for every line logged. Default is the name of logged in user:\n`echo {{log_entry}} | logger --tag {{tag}}`\n  * Log messages with a given priority. Default is `user.notice`. See `man logger` for all priority options:\n`echo {{log_entry}} | logger --priority {{user.warning}}`"}
{"instruction": "What is fallocate command", "input": "", "output": "# fallocate\n> Reserve or deallocate disk space to files. The utility allocates space\n> without zeroing. More information: https://manned.org/fallocate.\n  * Reserve a file taking up 700 MiB of disk space:\n`fallocate --length {{700M}} {{path/to/file}}`\n  * Shrink an already allocated file by 200 MiB:\n`fallocate --collapse-range --length {{200M}} {{path/to/file}}`\n  * Shrink 20 MB of space after 100 MiB in a file:\n`fallocate --collapse-range --offset {{100M}} --length {{20M}}\n{{path/to/file}}`"}
{"instruction": "What is mkfifo command", "input": "", "output": "# mkfifo\n> Makes FIFOs (named pipes). More information:\n> https://www.gnu.org/software/coreutils/mkfifo.\n  * Create a named pipe at a given path:\n`mkfifo {{path/to/pipe}}`"}
{"instruction": "What is git-credential-store command", "input": "", "output": "# git credential-store\n> `git` helper to store passwords on disk. More information: https://git-\n> scm.com/docs/git-credential-store.\n  * Store Git credentials in a specific file:\n`git config credential.helper 'store --file={{path/to/file}}'`"}
{"instruction": "What is kill command", "input": "", "output": "# kill\n> Sends a signal to a process, usually related to stopping the process. All\n> signals except for SIGKILL and SIGSTOP can be intercepted by the process to\n> perform a clean exit. More information: https://manned.org/kill.\n  * Terminate a program using the default SIGTERM (terminate) signal:\n`kill {{process_id}}`\n  * List available signal names (to be used without the `SIG` prefix):\n`kill -l`\n  * Terminate a background job:\n`kill %{{job_id}}`\n  * Terminate a program using the SIGHUP (hang up) signal. Many daemons will reload instead of terminating:\n`kill -{{1|HUP}} {{process_id}}`\n  * Terminate a program using the SIGINT (interrupt) signal. This is typically initiated by the user pressing `Ctrl + C`:\n`kill -{{2|INT}} {{process_id}}`\n  * Signal the operating system to immediately terminate a program (which gets no chance to capture the signal):\n`kill -{{9|KILL}} {{process_id}}`\n  * Signal the operating system to pause a program until a SIGCONT (\"continue\") signal is received:\n`kill -{{17|STOP}} {{process_id}}`\n  * Send a `SIGUSR1` signal to all processes with the given GID (group id):\n`kill -{{SIGUSR1}} -{{group_id}}`"}
{"instruction": "What is exec command", "input": "", "output": "# exec\n> Replace the current process with another process. More information:\n> https://linuxcommand.org/lc3_man_pages/exech.html.\n  * Replace with the specified command using the current environment variables:\n`exec {{command -with -flags}}`\n  * Replace with the specified command, clearing environment variables:\n`exec -c {{command -with -flags}}`\n  * Replace with the specified command and login using the default shell:\n`exec -l {{command -with -flags}}`\n  * Replace with the specified command and change the process name:\n`exec -a {{process_name}} {{command -with -flags}}`"}
{"instruction": "What is ln command", "input": "", "output": "# ln\n> Creates links to files and directories. More information:\n> https://www.gnu.org/software/coreutils/ln.\n  * Create a symbolic link to a file or directory:\n`ln -s {{/path/to/file_or_directory}} {{path/to/symlink}}`\n  * Overwrite an existing symbolic link to point to a different file:\n`ln -sf {{/path/to/new_file}} {{path/to/symlink}}`\n  * Create a hard link to a file:\n`ln {{/path/to/file}} {{path/to/hardlink}}`"}
{"instruction": "What is sha224sum command", "input": "", "output": "# sha224sum\n> Calculate SHA224 cryptographic checksums. More information:\n> https://www.gnu.org/software/coreutils/manual/html_node/sha2-utilities.html.\n  * Calculate the SHA224 checksum for one or more files:\n`sha224sum {{path/to/file1 path/to/file2 ...}}`\n  * Calculate and save the list of SHA224 checksums to a file:\n`sha224sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha224}}`\n  * Calculate a SHA224 checksum from `stdin`:\n`{{command}} | sha224sum`\n  * Read a file of SHA224 sums and filenames and verify all files have matching checksums:\n`sha224sum --check {{path/to/file.sha224}}`\n  * Only show a message for missing files or when verification fails:\n`sha224sum --check --quiet {{path/to/file.sha224}}`\n  * Only show a message when verification fails, ignoring missing files:\n`sha224sum --ignore-missing --check --quiet {{path/to/file.sha224}}`"}
{"instruction": "What is tr command", "input": "", "output": "# tr\n> Translate characters: run replacements based on single characters and\n> character sets. More information: https://www.gnu.org/software/coreutils/tr.\n  * Replace all occurrences of a character in a file, and print the result:\n`tr {{find_character}} {{replace_character}} < {{path/to/file}}`\n  * Replace all occurrences of a character from another command's output:\n`echo {{text}} | tr {{find_character}} {{replace_character}}`\n  * Map each character of the first set to the corresponding character of the second set:\n`tr '{{abcd}}' '{{jkmn}}' < {{path/to/file}}`\n  * Delete all occurrences of the specified set of characters from the input:\n`tr -d '{{input_characters}}' < {{path/to/file}}`\n  * Compress a series of identical characters to a single character:\n`tr -s '{{input_characters}}' < {{path/to/file}}`\n  * Translate the contents of a file to upper-case:\n`tr \"[:lower:]\" \"[:upper:]\" < {{path/to/file}}`\n  * Strip out non-printable characters from a file:\n`tr -cd \"[:print:]\" < {{path/to/file}}`"}
{"instruction": "What is chattr command", "input": "", "output": "# chattr\n> Change attributes of files or directories. More information:\n> https://manned.org/chattr.\n  * Make a file or directory immutable to changes and deletion, even by superuser:\n`chattr +i {{path/to/file_or_directory}}`\n  * Make a file or directory mutable:\n`chattr -i {{path/to/file_or_directory}}`\n  * Recursively make an entire directory and contents immutable:\n`chattr -R +i {{path/to/directory}}`"}
{"instruction": "What is git-reset command", "input": "", "output": "# git reset\n> Undo commits or unstage changes, by resetting the current Git HEAD to the\n> specified state. If a path is passed, it works as \"unstage\"; if a commit\n> hash or branch is passed, it works as \"uncommit\". More information:\n> https://git-scm.com/docs/git-reset.\n  * Unstage everything:\n`git reset`\n  * Unstage specific file(s):\n`git reset {{path/to/file1 path/to/file2 ...}}`\n  * Interactively unstage portions of a file:\n`git reset --patch {{path/to/file}}`\n  * Undo the last commit, keeping its changes (and any further uncommitted changes) in the filesystem:\n`git reset HEAD~`\n  * Undo the last two commits, adding their changes to the index, i.e. staged for commit:\n`git reset --soft HEAD~2`\n  * Discard any uncommitted changes, staged or not (for only unstaged changes, use `git checkout`):\n`git reset --hard`\n  * Reset the repository to a given commit, discarding committed, staged and uncommitted changes since then:\n`git reset --hard {{commit}}`"}
{"instruction": "What is uuidgen command", "input": "", "output": "# uuidgen\n> Generate new UUID (Universally Unique IDentifier) strings. More information:\n> https://www.ss64.com/osx/uuidgen.html.\n  * Generate a UUID string:\n`uuidgen`"}
{"instruction": "What is git-clone command", "input": "", "output": "# git clone\n> Clone an existing repository. More information: https://git-\n> scm.com/docs/git-clone.\n  * Clone an existing repository into a new directory (the default directory is the repository name):\n`git clone {{remote_repository_location}} {{path/to/directory}}`\n  * Clone an existing repository and its submodules:\n`git clone --recursive {{remote_repository_location}}`\n  * Clone only the `.git` directory of an existing repository:\n`git clone --no-checkout {{remote_repository_location}}`\n  * Clone a local repository:\n`git clone --local {{path/to/local/repository}}`\n  * Clone quietly:\n`git clone --quiet {{remote_repository_location}}`\n  * Clone an existing repository only fetching the 10 most recent commits on the default branch (useful to save time):\n`git clone --depth {{10}} {{remote_repository_location}}`\n  * Clone an existing repository only fetching a specific branch:\n`git clone --branch {{name}} --single-branch {{remote_repository_location}}`\n  * Clone an existing repository using a specific SSH command:\n`git clone --config core.sshCommand=\"{{ssh -i path/to/private_ssh_key}}\"\n{{remote_repository_location}}`"}
{"instruction": "What is cups-config command", "input": "", "output": "# cups-config\n> Show technical information about your CUPS print server installation. More\n> information: https://www.cups.org/doc/man-cups-config.html.\n  * Show the currently installed version of CUPS:\n`cups-config --version`\n  * Show where CUPS is currently installed:\n`cups-config --serverbin`\n  * Show the location of CUPS' configuration directory:\n`cups-config --serverroot`\n  * Show the location of CUPS' data directory:\n`cups-config --datadir`\n  * Display all available options:\n`cups-config --help`"}
{"instruction": "What is mkfifo command", "input": "", "output": "# mkfifo\n> Makes FIFOs (named pipes). More information:\n> https://www.gnu.org/software/coreutils/mkfifo.\n  * Create a named pipe at a given path:\n`mkfifo {{path/to/pipe}}`"}
{"instruction": "What is logger command", "input": "", "output": "# logger\n> Add messages to syslog (/var/log/syslog). More information:\n> https://manned.org/logger.\n  * Log a message to syslog:\n`logger {{message}}`\n  * Take input from `stdin` and log to syslog:\n`echo {{log_entry}} | logger`\n  * Send the output to a remote syslog server running at a given port. Default port is 514:\n`echo {{log_entry}} | logger --server {{hostname}} --port {{port}}`\n  * Use a specific tag for every line logged. Default is the name of logged in user:\n`echo {{log_entry}} | logger --tag {{tag}}`\n  * Log messages with a given priority. Default is `user.notice`. See `man logger` for all priority options:\n`echo {{log_entry}} | logger --priority {{user.warning}}`"}
{"instruction": "What is git-apply command", "input": "", "output": "# git apply\n> Apply a patch to files and/or to the index without creating a commit. See\n> also `git am`, which applies a patch and also creates a commit. More\n> information: https://git-scm.com/docs/git-apply.\n  * Print messages about the patched files:\n`git apply --verbose {{path/to/file}}`\n  * Apply and add the patched files to the index:\n`git apply --index {{path/to/file}}`\n  * Apply a remote patch file:\n`curl -L {{https://example.com/file.patch}} | git apply`\n  * Output diffstat for the input and apply the patch:\n`git apply --stat --apply {{path/to/file}}`\n  * Apply the patch in reverse:\n`git apply --reverse {{path/to/file}}`\n  * Store the patch result in the index without modifying the working tree:\n`git apply --cache {{path/to/file}}`"}
{"instruction": "What is strings command", "input": "", "output": "# strings\n> Find printable strings in an object file or binary. More information:\n> https://manned.org/strings.\n  * Print all strings in a binary:\n`strings {{path/to/file}}`\n  * Limit results to strings at least length characters long:\n`strings -n {{length}} {{path/to/file}}`\n  * Prefix each result with its offset within the file:\n`strings -t d {{path/to/file}}`\n  * Prefix each result with its offset within the file in hexadecimal:\n`strings -t x {{path/to/file}}`"}
{"instruction": "What is hexdump command", "input": "", "output": "# hexdump\n> An ASCII, decimal, hexadecimal, octal dump. More information:\n> https://manned.org/hexdump.\n  * Print the hexadecimal representation of a file, replacing duplicate lines by '*':\n`hexdump {{path/to/file}}`\n  * Display the input offset in hexadecimal and its ASCII representation in two columns:\n`hexdump -C {{path/to/file}}`\n  * Display the hexadecimal representation of a file, but interpret only n bytes of the input:\n`hexdump -C -n{{number_of_bytes}} {{path/to/file}}`\n  * Don't replace duplicate lines with '*':\n`hexdump --no-squeezing {{path/to/file}}`"}
{"instruction": "What is git-update-index command", "input": "", "output": "# git update-index\n> Git command for manipulating the index. More information: https://git-\n> scm.com/docs/git-update-index.\n  * Pretend that a modified file is unchanged (`git status` will not show this as changed):\n`git update-index --skip-worktree {{path/to/modified_file}}`"}
{"instruction": "What is valgrind command", "input": "", "output": "# valgrind\n> Wrapper for a set of expert tools for profiling, optimizing and debugging\n> programs. Commonly used tools include `memcheck`, `cachegrind`, `callgrind`,\n> `massif`, `helgrind`, and `drd`. More information: http://www.valgrind.org.\n  * Use the (default) Memcheck tool to show a diagnostic of memory usage by `program`:\n`valgrind {{program}}`\n  * Use Memcheck to report all possible memory leaks of `program` in full detail:\n`valgrind --leak-check=full --show-leak-kinds=all {{program}}`\n  * Use the Cachegrind tool to profile and log CPU cache operations of `program`:\n`valgrind --tool=cachegrind {{program}}`\n  * Use the Massif tool to profile and log heap memory and stack usage of `program`:\n`valgrind --tool=massif --stacks=yes {{program}}`"}
{"instruction": "What is od command", "input": "", "output": "# od\n> Display file contents in octal, decimal or hexadecimal format. Optionally\n> display the byte offsets and/or printable representation for each line. More\n> information: https://www.gnu.org/software/coreutils/od.\n  * Display file using default settings: octal format, 8 bytes per line, byte offsets in octal, and duplicate lines replaced with `*`:\n`od {{path/to/file}}`\n  * Display file in verbose mode, i.e. without replacing duplicate lines with `*`:\n`od -v {{path/to/file}}`\n  * Display file in hexadecimal format (2-byte units), with byte offsets in decimal format:\n`od --format={{x}} --address-radix={{d}} -v {{path/to/file}}`\n  * Display file in hexadecimal format (1-byte units), and 4 bytes per line:\n`od --format={{x1}} --width={{4}} -v {{path/to/file}}`\n  * Display file in hexadecimal format along with its character representation, and do not print byte offsets:\n`od --format={{xz}} --address-radix={{n}} -v {{path/to/file}}`\n  * Read only 100 bytes of a file starting from the 500th byte:\n`od --read-bytes {{100}} --skip-bytes={{500}} -v {{path/to/file}}`"}
{"instruction": "What is uuencode command", "input": "", "output": "# uuencode\n> Encode binary files into ASCII for transport via mediums that only support\n> simple ASCII encoding. More information: https://manned.org/uuencode.\n  * Encode a file and print the result to `stdout`:\n`uuencode {{path/to/input_file}} {{output_file_name_after_decoding}}`\n  * Encode a file and write the result to a file:\n`uuencode -o {{path/to/output_file}} {{path/to/input_file}}\n{{output_file_name_after_decoding}}`\n  * Encode a file using Base64 instead of the default uuencode encoding and write the result to a file:\n`uuencode -m -o {{path/to/output_file}} {{path/to/input_file}}\n{{output_file_name_after_decoding}}`"}
{"instruction": "What is cmp command", "input": "", "output": "# cmp\n> Compare two files byte by byte. More information:\n> https://www.gnu.org/software/diffutils/manual/html_node/Invoking-cmp.html.\n  * Output char and line number of the first difference between two files:\n`cmp {{path/to/file1}} {{path/to/file2}}`\n  * Output info of the first difference: char, line number, bytes, and values:\n`cmp --print-bytes {{path/to/file1}} {{path/to/file2}}`\n  * Output the byte numbers and values of every difference:\n`cmp --verbose {{path/to/file1}} {{path/to/file2}}`\n  * Compare files but output nothing, yield only the exit status:\n`cmp --quiet {{path/to/file1}} {{path/to/file2}}`"}
{"instruction": "What is hostname command", "input": "", "output": "# hostname\n> Show or set the system's host name. More information:\n> https://manned.org/hostname.\n  * Show current host name:\n`hostname`\n  * Show the network address of the host name:\n`hostname -i`\n  * Show all network addresses of the host:\n`hostname -I`\n  * Show the FQDN (Fully Qualified Domain Name):\n`hostname --fqdn`\n  * Set current host name:\n`hostname {{new_hostname}}`"}
{"instruction": "What is od command", "input": "", "output": "# od\n> Display file contents in octal, decimal or hexadecimal format. Optionally\n> display the byte offsets and/or printable representation for each line. More\n> information: https://www.gnu.org/software/coreutils/od.\n  * Display file using default settings: octal format, 8 bytes per line, byte offsets in octal, and duplicate lines replaced with `*`:\n`od {{path/to/file}}`\n  * Display file in verbose mode, i.e. without replacing duplicate lines with `*`:\n`od -v {{path/to/file}}`\n  * Display file in hexadecimal format (2-byte units), with byte offsets in decimal format:\n`od --format={{x}} --address-radix={{d}} -v {{path/to/file}}`\n  * Display file in hexadecimal format (1-byte units), and 4 bytes per line:\n`od --format={{x1}} --width={{4}} -v {{path/to/file}}`\n  * Display file in hexadecimal format along with its character representation, and do not print byte offsets:\n`od --format={{xz}} --address-radix={{n}} -v {{path/to/file}}`\n  * Read only 100 bytes of a file starting from the 500th byte:\n`od --read-bytes {{100}} --skip-bytes={{500}} -v {{path/to/file}}`"}
{"instruction": "What is b2sum command", "input": "", "output": "# b2sum\n> Calculate BLAKE2 cryptographic checksums. More information:\n> https://www.gnu.org/software/coreutils/b2sum.\n  * Calculate the BLAKE2 checksum for one or more files:\n`b2sum {{path/to/file1 path/to/file2 ...}}`\n  * Calculate and save the list of BLAKE2 checksums to a file:\n`b2sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.b2}}`\n  * Calculate a BLAKE2 checksum from `stdin`:\n`{{command}} | b2sum`\n  * Read a file of BLAKE2 sums and filenames and verify all files have matching checksums:\n`b2sum --check {{path/to/file.b2}}`\n  * Only show a message for missing files or when verification fails:\n`b2sum --check --quiet {{path/to/file.b2}}`\n  * Only show a message when verification fails, ignoring missing files:\n`b2sum --ignore-missing --check --quiet {{path/to/file.b2}}`"}
{"instruction": "What is git-status command", "input": "", "output": "# git status\n> Show the changes to files in a Git repository. Lists changed, added and\n> deleted files compared to the currently checked-out commit. More\n> information: https://git-scm.com/docs/git-status.\n  * Show changed files which are not yet added for commit:\n`git status`\n  * Give output in [s]hort format:\n`git status -s`\n  * Don't show untracked files in the output:\n`git status --untracked-files=no`\n  * Show output in [s]hort format along with [b]ranch info:\n`git status -sb`"}
{"instruction": "What is time command", "input": "", "output": "# time\n> Measure how long a command took to run. Note: `time` can either exist as a\n> shell builtin, a standalone program or both. More information:\n> https://manned.org/time.\n  * Run the `command` and print the time measurements to `stdout`:\n`time {{command}}`"}
{"instruction": "What is split command", "input": "", "output": "# split\n> Split a file into pieces. More information: https://ss64.com/osx/split.html.\n  * Split a file, each split having 10 lines (except the last split):\n`split -l {{10}} {{filename}}`\n  * Split a file by a regular expression. The matching line will be the first line of the next output file:\n`split -p {{cat|^[dh]og}} {{filename}}`\n  * Split a file with 512 bytes in each split (except the last split; use 512k for kilobytes and 512m for megabytes):\n`split -b {{512}} {{filename}}`\n  * Split a file into 5 files. File is split such that each split has same size (except the last split):\n`split -n {{5}} {{filename}}`"}
{"instruction": "What is su command", "input": "", "output": "# su\n> Switch shell to another user. More information: https://manned.org/su.\n  * Switch to superuser (requires the root password):\n`su`\n  * Switch to a given user (requires the user's password):\n`su {{username}}`\n  * Switch to a given user and simulate a full login shell:\n`su - {{username}}`\n  * Execute a command as another user:\n`su - {{username}} -c \"{{command}}\"`"}
{"instruction": "What is w command", "input": "", "output": "# w\n> Show who is logged on and what they are doing. Print user login, TTY, remote\n> host, login time, idle time, current process. More information:\n> https://ss64.com/osx/w.html.\n  * Show logged-in users information:\n`w`\n  * Show logged-in users information without a header:\n`w -h`\n  * Show information about logged-in users, sorted by their idle time:\n`w -i`"}
{"instruction": "What is git-reflog command", "input": "", "output": "# git reflog\n> Show a log of changes to local references like HEAD, branches or tags. More\n> information: https://git-scm.com/docs/git-reflog.\n  * Show the reflog for HEAD:\n`git reflog`\n  * Show the reflog for a given branch:\n`git reflog {{branch_name}}`\n  * Show only the 5 latest entries in the reflog:\n`git reflog -n {{5}}`"}
{"instruction": "What is git-cat-file command", "input": "", "output": "# git cat-file\n> Provide content or type and size information for Git repository objects.\n> More information: https://git-scm.com/docs/git-cat-file.\n  * Get the [s]ize of the HEAD commit in bytes:\n`git cat-file -s HEAD`\n  * Get the [t]ype (blob, tree, commit, tag) of a given Git object:\n`git cat-file -t {{8c442dc3}}`\n  * Pretty-[p]rint the contents of a given Git object based on its type:\n`git cat-file -p {{HEAD~2}}`"}
{"instruction": "What is clear command", "input": "", "output": "# clear\n> Clears the screen of the terminal. More information:\n> https://manned.org/clear.\n  * Clear the screen (equivalent to pressing Control-L in Bash shell):\n`clear`\n  * Clear the screen but keep the terminal's scrollback buffer:\n`clear -x`\n  * Indicate the type of terminal to clean (defaults to the value of the environment variable `TERM`):\n`clear -T {{type_of_terminal}}`\n  * Show the version of `ncurses` used by `clear`:\n`clear -V`"}
{"instruction": "What is tput command", "input": "", "output": "# tput\n> View and modify terminal settings and capabilities. More information:\n> https://manned.org/tput.\n  * Move the cursor to a screen location:\n`tput cup {{row}} {{column}}`\n  * Set foreground (af) or background (ab) color:\n`tput {{setaf|setab}} {{ansi_color_code}}`\n  * Show number of columns, lines, or colors:\n`tput {{cols|lines|colors}}`\n  * Ring the terminal bell:\n`tput bel`\n  * Reset all terminal attributes:\n`tput sgr0`\n  * Enable or disable word wrap:\n`tput {{smam|rmam}}`"}
{"instruction": "What is nice command", "input": "", "output": "# nice\n> Execute a program with a custom scheduling priority (niceness). Niceness\n> values range from -20 (the highest priority) to 19 (the lowest). More\n> information: https://www.gnu.org/software/coreutils/nice.\n  * Launch a program with altered priority:\n`nice -n {{niceness_value}} {{command}}`"}
{"instruction": "What is echo command", "input": "", "output": "# echo\n> Print given arguments. More information:\n> https://www.gnu.org/software/coreutils/echo.\n  * Print a text message. Note: quotes are optional:\n`echo \"{{Hello World}}\"`\n  * Print a message with environment variables:\n`echo \"{{My path is $PATH}}\"`\n  * Print a message without the trailing newline:\n`echo -n \"{{Hello World}}\"`\n  * Append a message to the file:\n`echo \"{{Hello World}}\" >> {{file.txt}}`\n  * Enable interpretation of backslash escapes (special characters):\n`echo -e \"{{Column 1\\tColumn 2}}\"`\n  * Print the exit status of the last executed command (Note: In Windows Command Prompt and PowerShell the equivalent commands are `echo %errorlevel%` and `$lastexitcode` respectively):\n`echo $?`"}
{"instruction": "What is expand command", "input": "", "output": "# expand\n> Convert tabs to spaces. More information:\n> https://www.gnu.org/software/coreutils/expand.\n  * Convert tabs in each file to spaces, writing to `stdout`:\n`expand {{path/to/file}}`\n  * Convert tabs to spaces, reading from `stdin`:\n`expand`\n  * Do not convert tabs after non blanks:\n`expand -i {{path/to/file}}`\n  * Have tabs a certain number of characters apart, not 8:\n`expand -t={{number}} {{path/to/file}}`\n  * Use a comma separated list of explicit tab positions:\n`expand -t={{1,4,6}}`"}
{"instruction": "What is systemd-firstboot command", "input": "", "output": "# systemd-firstboot\n> Initialize basic system settings on or before the first boot-up of a system.\n> More information: https://www.freedesktop.org/software/systemd/man/systemd-\n> firstboot.html.\n  * Operate on the specified directory instead of the root directory of the host system:\n`sudo systemd-firstboot --root={{path/to/root_directory}}`\n  * Set the system keyboard layout:\n`sudo systemd-firstboot --keymap={{keymap}}`\n  * Set the system hostname:\n`sudo systemd-firstboot --hostname={{hostname}}`\n  * Set the root user's password:\n`sudo systemd-firstboot --root-password={{password}}`\n  * Prompt the user interactively for a specific basic setting:\n`sudo systemd-firstboot --prompt={{setting}}`\n  * Force writing configuration even if the relevant files already exist:\n`sudo systemd-firstboot --force`\n  * Remove all existing files that are configured by `systemd-firstboot`:\n`sudo systemd-firstboot --reset`\n  * Remove the password of the system's root user:\n`sudo systemd-firstboot --delete-root-password`"}
{"instruction": "What is last command", "input": "", "output": "# last\n> View the last logged in users. More information: https://manned.org/last.\n  * View last logins, their duration and other information as read from `/var/log/wtmp`:\n`last`\n  * Specify how many of the last logins to show:\n`last -n {{login_count}}`\n  * Print the full date and time for entries and then display the hostname column last to prevent truncation:\n`last -F -a`\n  * View all logins by a specific user and show the IP address instead of the hostname:\n`last {{username}} -i`\n  * View all recorded reboots (i.e., the last logins of the pseudo user \"reboot\"):\n`last reboot`\n  * View all recorded shutdowns (i.e., the last logins of the pseudo user \"shutdown\"):\n`last shutdown`"}
{"instruction": "What is flatpak command", "input": "", "output": "# flatpak\n> Build, install and run flatpak applications and runtimes. More information:\n> https://docs.flatpak.org/en/latest/flatpak-command-reference.html#flatpak.\n  * Run an installed application:\n`flatpak run {{name}}`\n  * Install an application from a remote source:\n`flatpak install {{remote}} {{name}}`\n  * List all installed applications and runtimes:\n`flatpak list`\n  * Update all installed applications and runtimes:\n`flatpak update`\n  * Add a remote source:\n`flatpak remote-add --if-not-exists {{remote_name}} {{remote_url}}`\n  * Remove an installed application:\n`flatpak remove {{name}}`\n  * Remove all unused applications:\n`flatpak remove --unused`\n  * Show information about an installed application:\n`flatpak info {{name}}`"}
{"instruction": "What is cksum command", "input": "", "output": "# cksum\n> Calculates CRC checksums and byte counts of a file. Note, on old UNIX\n> systems the CRC implementation may differ. More information:\n> https://www.gnu.org/software/coreutils/cksum.\n  * Display a 32-bit checksum, size in bytes and filename:\n`cksum {{path/to/file}}`"}
{"instruction": "What is git-for-each-repo command", "input": "", "output": "# git for-each-repo\n> Run a Git command on a list of repositories. Note: this command is\n> experimental and may change. More information: https://git-scm.com/docs/git-\n> for-each-repo.\n  * Run maintenance on each of a list of repositories stored in the `maintenance.repo` user configuration variable:\n`git for-each-repo --config={{maintenance.repo}} {{maintenance run}}`\n  * Run `git pull` on each repository listed in a global configuration variable:\n`git for-each-repo --config={{global_configuration_variable}} {{pull}}`"}
{"instruction": "What is more command", "input": "", "output": "# more\n> Open a file for interactive reading, allowing scrolling and search. More\n> information: https://manned.org/more.\n  * Open a file:\n`more {{path/to/file}}`\n  * Open a file displaying from a specific line:\n`more +{{line_number}} {{path/to/file}}`\n  * Display help:\n`more --help`\n  * Go to the next page:\n`<Space>`\n  * Search for a string (press `n` to go to the next match):\n`/{{something}}`\n  * Exit:\n`q`\n  * Display help about interactive commands:\n`h`"}
{"instruction": "What is apropos command", "input": "", "output": "# apropos\n> Search the manual pages for names and descriptions. More information:\n> https://manned.org/apropos.\n  * Search for a keyword using a regular expression:\n`apropos {{regular_expression}}`\n  * Search without restricting the output to the terminal width:\n`apropos -l {{regular_expression}}`\n  * Search for pages that contain all the expressions given:\n`apropos {{regular_expression_1}} -a {{regular_expression_2}} -a\n{{regular_expression_3}}`"}
{"instruction": "What is cat command", "input": "", "output": "# cat\n> Print and concatenate files. More information:\n> https://keith.github.io/xcode-man-pages/cat.1.html.\n  * Print the contents of a file to `stdout`:\n`cat {{path/to/file}}`\n  * Concatenate several files into an output file:\n`cat {{path/to/file1 path/to/file2 ...}} > {{path/to/output_file}}`\n  * Append several files to an output file:\n`cat {{path/to/file1 path/to/file2 ...}} >> {{path/to/output_file}}`\n  * Copy the contents of a file into an output file without buffering:\n`cat -u {{/dev/tty12}} > {{/dev/tty13}}`\n  * Write `stdin` to a file:\n`cat - > {{path/to/file}}`\n  * Number all output lines:\n`cat -n {{path/to/file}}`\n  * Display non-printable and whitespace characters (with `M-` prefix if non-ASCII):\n`cat -v -t -e {{path/to/file}}`"}
{"instruction": "What is arch command", "input": "", "output": "# arch\n> Display the name of the system architecture, or run a command under a\n> different architecture. See also `uname`. More information:\n> https://www.unix.com/man-page/osx/1/arch/.\n  * Display the system's architecture:\n`arch`\n  * Run a command using x86_64:\n`arch -x86_64 \"{{command}}\"`\n  * Run a command using arm:\n`arch -arm64 \"{{command}}\"`"}
{"instruction": "What is update-alternatives command", "input": "", "output": "# update-alternatives\n> A convenient tool for maintaining symbolic links to determine default\n> commands. More information: https://manned.org/update-alternatives.\n  * Add a symbolic link:\n`sudo update-alternatives --install {{path/to/symlink}} {{command_name}}\n{{path/to/command_binary}} {{priority}}`\n  * Configure a symbolic link for `java`:\n`sudo update-alternatives --config {{java}}`\n  * Remove a symbolic link:\n`sudo update-alternatives --remove {{java}}\n{{/opt/java/jdk1.8.0_102/bin/java}}`\n  * Display information about a specified command:\n`update-alternatives --display {{java}}`\n  * Display all commands and their current selection:\n`update-alternatives --get-selections`"}
{"instruction": "What is mailx command", "input": "", "output": "# mailx\n> Send and receive mail. More information: https://manned.org/mailx.\n  * Send mail (the content should be typed after the command, and ended with `Ctrl+D`):\n`mailx -s \"{{subject}}\" {{to_addr}}`\n  * Send mail with content passed from another command:\n`echo \"{{content}}\" | mailx -s \"{{subject}}\" {{to_addr}}`\n  * Send mail with content read from a file:\n`mailx -s \"{{subject}}\" {{to_addr}} < {{content.txt}}`\n  * Send mail to a recipient and CC to another address:\n`mailx -s \"{{subject}}\" -c {{cc_addr}} {{to_addr}}`\n  * Send mail specifying the sender address:\n`mailx -s \"{{subject}}\" -r {{from_addr}} {{to_addr}}`\n  * Send mail with an attachment:\n`mailx -a {{path/to/file}} -s \"{{subject}}\" {{to_addr}}`"}
{"instruction": "What is dot command", "input": "", "output": "# dot\n> Render an image of a `linear directed` network graph from a `graphviz` file.\n> Layouts: `dot`, `neato`, `twopi`, `circo`, `fdp`, `sfdp`, `osage` &\n> `patchwork`. More information: https://graphviz.org/doc/info/command.html.\n  * Render a `png` image with a filename based on the input filename and output format (uppercase -O):\n`dot -T {{png}} -O {{path/to/input.gv}}`\n  * Render a `svg` image with the specified output filename (lowercase -o):\n`dot -T {{svg}} -o {{path/to/image.svg}} {{path/to/input.gv}}`\n  * Render the output in `ps`, `pdf`, `svg`, `fig`, `png`, `gif`, `jpg`, `json`, or `dot` format:\n`dot -T {{format}} -O {{path/to/input.gv}}`\n  * Render a `gif` image using `stdin` and `stdout`:\n`echo \"{{digraph {this -> that} }}\" | dot -T {{gif}} > {{path/to/image.gif}}`\n  * Display help:\n`dot -?`"}
{"instruction": "What is gcc command", "input": "", "output": "# gcc\n> Preprocess and compile C and C++ source files, then assemble and link them\n> together. More information: https://gcc.gnu.org.\n  * Compile multiple source files into an executable:\n`gcc {{path/to/source1.c path/to/source2.c ...}} -o\n{{path/to/output_executable}}`\n  * Show common warnings, debug symbols in output, and optimize without affecting debugging:\n`gcc {{path/to/source.c}} -Wall -g -Og -o {{path/to/output_executable}}`\n  * Include libraries from a different path:\n`gcc {{path/to/source.c}} -o {{path/to/output_executable}}\n-I{{path/to/header}} -L{{path/to/library}} -l{{library_name}}`\n  * Compile source code into Assembler instructions:\n`gcc -S {{path/to/source.c}}`\n  * Compile source code into an object file without linking:\n`gcc -c {{path/to/source.c}}`"}
{"instruction": "What is whoami command", "input": "", "output": "# whoami\n> Print the username associated with the current effective user ID. More\n> information: https://www.gnu.org/software/coreutils/whoami.\n  * Display currently logged username:\n`whoami`\n  * Display the username after a change in the user ID:\n`sudo whoami`"}
{"instruction": "What is gitk command", "input": "", "output": "# gitk\n> A graphical Git repository browser. More information: https://git-\n> scm.com/docs/gitk.\n  * Show the repository browser for the current Git repository:\n`gitk`\n  * Show repository browser for a specific file or directory:\n`gitk {{path/to/file_or_directory}}`\n  * Show commits made since 1 week ago:\n`gitk --since=\"{{1 week ago}}\"`\n  * Show commits older than 1/1/2016:\n`gitk --until=\"{{1/1/2015}}\"`\n  * Show at most 100 changes in all branches:\n`gitk --max-count={{100}} --all`"}
{"instruction": "What is realpath command", "input": "", "output": "# realpath\n> Display the resolved absolute path for a file or directory. More\n> information: https://www.gnu.org/software/coreutils/realpath.\n  * Display the absolute path for a file or directory:\n`realpath {{path/to/file_or_directory}}`\n  * Require all path components to exist:\n`realpath --canonicalize-existing {{path/to/file_or_directory}}`\n  * Resolve \"..\" components before symlinks:\n`realpath --logical {{path/to/file_or_directory}}`\n  * Disable symlink expansion:\n`realpath --no-symlinks {{path/to/file_or_directory}}`\n  * Suppress error messages:\n`realpath --quiet {{path/to/file_or_directory}}`"}
{"instruction": "What is csplit command", "input": "", "output": "# csplit\n> Split a file into pieces. This generates files named \"xx00\", \"xx01\", and so\n> on. More information: https://www.gnu.org/software/coreutils/csplit.\n  * Split a file at lines 5 and 23:\n`csplit {{path/to/file}} {{5}} {{23}}`\n  * Split a file every 5 lines (this will fail if the total number of lines is not divisible by 5):\n`csplit {{path/to/file}} {{5}} {*}`\n  * Split a file every 5 lines, ignoring exact-division error:\n`csplit -k {{path/to/file}} {{5}} {*}`\n  * Split a file at line 5 and use a custom prefix for the output files:\n`csplit {{path/to/file}} {{5}} -f {{prefix}}`\n  * Split a file at a line matching a regular expression:\n`csplit {{path/to/file}} /{{regular_expression}}/`"}
{"instruction": "What is ps command", "input": "", "output": "# ps\n> Information about running processes. More information:\n> https://www.unix.com/man-page/osx/1/ps/.\n  * List all running processes:\n`ps aux`\n  * List all running processes including the full command string:\n`ps auxww`\n  * Search for a process that matches a string:\n`ps aux | grep {{string}}`\n  * Get the parent PID of a process:\n`ps -o ppid= -p {{pid}}`\n  * Sort processes by memory usage:\n`ps -m`\n  * Sort processes by CPU usage:\n`ps -r`"}
{"instruction": "What is journalctl command", "input": "", "output": "# journalctl\n> Query the systemd journal. More information: https://manned.org/journalctl.\n  * Show all messages with priority level 3 (errors) from this [b]oot:\n`journalctl -b --priority={{3}}`\n  * Show all messages from last [b]oot:\n`journalctl -b -1`\n  * Delete journal logs which are older than 2 days:\n`journalctl --vacuum-time={{2d}}`\n  * [f]ollow new messages (like `tail -f` for traditional syslog):\n`journalctl -f`\n  * Show all messages by a specific [u]nit:\n`journalctl -u {{unit}}`\n  * Filter messages within a time range (either timestamp or placeholders like \"yesterday\"):\n`journalctl --since {{now|today|yesterday|tomorrow}} --until {{YYYY-MM-DD\nHH:MM:SS}}`\n  * Show all messages by a specific process:\n`journalctl _PID={{pid}}`\n  * Show all messages by a specific executable:\n`journalctl {{path/to/executable}}`"}
{"instruction": "What is head command", "input": "", "output": "# head\n> Output the first part of files. More information:\n> https://keith.github.io/xcode-man-pages/head.1.html.\n  * Output the first few lines of a file:\n`head --lines {{8}} {{path/to/file}}`\n  * Output the first few bytes of a file:\n`head --bytes {{8}} {{path/to/file}}`\n  * Output everything but the last few lines of a file:\n`head --lines -{{8}} {{path/to/file}}`\n  * Output everything but the last few bytes of a file:\n`head --bytes -{{8}} {{path/to/file}}`"}
{"instruction": "What is basename command", "input": "", "output": "# basename\n> Remove leading directory portions from a path. More information:\n> https://www.gnu.org/software/coreutils/basename.\n  * Show only the file name from a path:\n`basename {{path/to/file}}`\n  * Show only the rightmost directory name from a path:\n`basename {{path/to/directory/}}`\n  * Show only the file name from a path, with a suffix removed:\n`basename {{path/to/file}} {{suffix}}`"}
{"instruction": "What is git-maintenance command", "input": "", "output": "# git-maintenance\n> Run tasks to optimize Git repository data. More information: https://git-\n> scm.com/docs/git-maintenance.\n  * Register the current repository in the user's list of repositories to daily have maintenance run:\n`git maintenance register`\n  * Start running maintenance on the current repository:\n`git maintenance start`\n  * Halt the background maintenance schedule for the current repository:\n`git maintenance stop`\n  * Remove the current repository from the user's maintenance repository list:\n`git maintenance unregister`\n  * Run a specific maintenance task on the current repository:\n`git maintenance run --task={{commit-graph|gc|incremental-repack|loose-\nobjects|pack-refs|prefetch}}`"}
{"instruction": "What is git-diff-files command", "input": "", "output": "# git diff-files\n> Compare files using their sha1 hashes and modes. More information:\n> https://git-scm.com/docs/git-diff-files.\n  * Compare all changed files:\n`git diff-files`\n  * Compare only specified files:\n`git diff-files {{path/to/file}}`\n  * Show only the names of changed files:\n`git diff-files --name-only`\n  * Output a summary of extended header information:\n`git diff-files --summary`"}
{"instruction": "What is expr command", "input": "", "output": "# expr\n> Evaluate expressions and manipulate strings. More information:\n> https://www.gnu.org/software/coreutils/expr.\n  * Get the length of a specific string:\n`expr length \"{{string}}\"`\n  * Get the substring of a string with a specific length:\n`expr substr \"{{string}}\" {{from}} {{length}}`\n  * Match a specific substring against an anchored pattern:\n`expr match \"{{string}}\" '{{pattern}}'`\n  * Get the first char position from a specific set in a string:\n`expr index \"{{string}}\" \"{{chars}}\"`\n  * Calculate a specific mathematic expression:\n`expr {{expression1}} {{+|-|*|/|%}} {{expression2}}`\n  * Get the first expression if its value is non-zero and not null otherwise get the second one:\n`expr {{expression1}} \\| {{expression2}}`\n  * Get the first expression if both expressions are non-zero and not null otherwise get zero:\n`expr {{expression1}} \\& {{expression2}}`"}
{"instruction": "What is mv command", "input": "", "output": "# mv\n> Move or rename files and directories. More information:\n> https://www.gnu.org/software/coreutils/mv.\n  * Rename a file or directory when the target is not an existing directory:\n`mv {{path/to/source}} {{path/to/target}}`\n  * Move a file or directory into an existing directory:\n`mv {{path/to/source}} {{path/to/existing_directory}}`\n  * Move multiple files into an existing directory, keeping the filenames unchanged:\n`mv {{path/to/source1 path/to/source2 ...}} {{path/to/existing_directory}}`\n  * Do not prompt for confirmation before overwriting existing files:\n`mv -f {{path/to/source}} {{path/to/target}}`\n  * Prompt for confirmation before overwriting existing files, regardless of file permissions:\n`mv -i {{path/to/source}} {{path/to/target}}`\n  * Do not overwrite existing files at the target:\n`mv -n {{path/to/source}} {{path/to/target}}`\n  * Move files in verbose mode, showing files after they are moved:\n`mv -v {{path/to/source}} {{path/to/target}}`"}
{"instruction": "What is loginctl command", "input": "", "output": "# loginctl\n> Manage the systemd login manager. More information:\n> https://www.freedesktop.org/software/systemd/man/loginctl.html.\n  * Print all current sessions:\n`loginctl list-sessions`\n  * Print all properties of a specific session:\n`loginctl show-session {{session_id}} --all`\n  * Print all properties of a specific user:\n`loginctl show-user {{username}}`\n  * Print a specific property of a user:\n`loginctl show-user {{username}} --property={{property_name}}`\n  * Execute a `loginctl` operation on a remote host:\n`loginctl list-users -H {{hostname}}`"}
{"instruction": "What is cut command", "input": "", "output": "# cut\n> Cut out fields from `stdin` or files. More information:\n> https://manned.org/man/freebsd-13.0/cut.1.\n  * Print a specific character/field range of each line:\n`{{command}} | cut -{{c|f}} {{1|1,10|1-10|1-|-10}}`\n  * Print a range of each line with a specific delimiter:\n`{{command}} | cut -d \"{{,}}\" -{{c}} {{1}}`\n  * Print a range of each line of a specific file:\n`cut -{{c}} {{1}} {{path/to/file}}`"}
{"instruction": "What is kill command", "input": "", "output": "# kill\n> Sends a signal to a process, usually related to stopping the process. All\n> signals except for SIGKILL and SIGSTOP can be intercepted by the process to\n> perform a clean exit. More information: https://manned.org/kill.\n  * Terminate a program using the default SIGTERM (terminate) signal:\n`kill {{process_id}}`\n  * List available signal names (to be used without the `SIG` prefix):\n`kill -l`\n  * Terminate a background job:\n`kill %{{job_id}}`\n  * Terminate a program using the SIGHUP (hang up) signal. Many daemons will reload instead of terminating:\n`kill -{{1|HUP}} {{process_id}}`\n  * Terminate a program using the SIGINT (interrupt) signal. This is typically initiated by the user pressing `Ctrl + C`:\n`kill -{{2|INT}} {{process_id}}`\n  * Signal the operating system to immediately terminate a program (which gets no chance to capture the signal):\n`kill -{{9|KILL}} {{process_id}}`\n  * Signal the operating system to pause a program until a SIGCONT (\"continue\") signal is received:\n`kill -{{17|STOP}} {{process_id}}`\n  * Send a `SIGUSR1` signal to all processes with the given GID (group id):\n`kill -{{SIGUSR1}} -{{group_id}}`"}
{"instruction": "What is sleep command", "input": "", "output": "# sleep\n> Delay for a specified amount of time. More information:\n> https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sleep.html.\n  * Delay in seconds:\n`sleep {{seconds}}`\n  * Execute a specific command after 20 seconds delay:\n`sleep 20 && {{command}}`"}
{"instruction": "What is printf command", "input": "", "output": "# printf\n> Format and print text. More information:\n> https://www.gnu.org/software/coreutils/printf.\n  * Print a text message:\n`printf \"{{%s\\n}}\" \"{{Hello world}}\"`\n  * Print an integer in bold blue:\n`printf \"{{\\e[1;34m%.3d\\e[0m\\n}}\" {{42}}`\n  * Print a float number with the Unicode Euro sign:\n`printf \"{{\\u20AC %.2f\\n}}\" {{123.4}}`\n  * Print a text message composed with environment variables:\n`printf \"{{var1: %s\\tvar2: %s\\n}}\" \"{{$VAR1}}\" \"{{$VAR2}}\"`\n  * Store a formatted message in a variable (does not work on zsh):\n`printf -v {{myvar}} {{\"This is %s = %d\\n\" \"a year\" 2016}}`"}
{"instruction": "What is c99 command", "input": "", "output": "# c99\n> Compiles C programs according to the ISO C standard. More information:\n> https://manned.org/c99.\n  * Compile source file(s) and create an executable:\n`c99 {{file.c}}`\n  * Compile source file(s) and create an executable with a custom name:\n`c99 -o {{executable_name}} {{file.c}}`\n  * Compile source file(s) and create object file(s):\n`c99 -c {{file.c}}`\n  * Compile source file(s), link with object file(s), and create an executable:\n`c99 {{file.c}} {{file.o}}`"}
{"instruction": "What is runuser command", "input": "", "output": "# runuser\n> Run commands as a specific user and group without asking for password (needs\n> root privileges). More information: https://manned.org/runuser.\n  * Run command as a different user:\n`runuser {{user}} -c '{{command}}'`\n  * Run command as a different user and group:\n`runuser {{user}} -g {{group}} -c '{{command}}'`\n  * Start a login shell as a specific user:\n`runuser {{user}} -l`\n  * Specify a shell for running instead of the default shell (also works for login):\n`runuser {{user}} -s {{/bin/sh}}`\n  * Preserve the entire environment of root (only if `--login` is not specified):\n`runuser {{user}} --preserve-environment -c '{{command}}'`"}
{"instruction": "What is man command", "input": "", "output": "# man\n> Format and display manual pages. More information:\n> https://www.man7.org/linux/man-pages/man1/man.1.html.\n  * Display the man page for a command:\n`man {{command}}`\n  * Display the man page for a command from section 7:\n`man {{7}} {{command}}`\n  * List all available sections for a command:\n`man -f {{command}}`\n  * Display the path searched for manpages:\n`man --path`\n  * Display the location of a manpage rather than the manpage itself:\n`man -w {{command}}`\n  * Display the man page using a specific locale:\n`man {{command}} --locale={{locale}}`\n  * Search for manpages containing a search string:\n`man -k \"{{search_string}}\"`"}
{"instruction": "What is git-cherry command", "input": "", "output": "# git cherry\n> Find commits that have yet to be applied upstream. More information:\n> https://git-scm.com/docs/git-cherry.\n  * Show commits (and their messages) with equivalent commits upstream:\n`git cherry -v`\n  * Specify a different upstream and topic branch:\n`git cherry {{origin}} {{topic}}`\n  * Limit commits to those within a given limit:\n`git cherry {{origin}} {{topic}} {{base}}`"}
{"instruction": "What is fold command", "input": "", "output": "# fold\n> Wrap each line in an input file to fit a specified width and print it to\n> `stdout`. More information: https://manned.org/fold.1p.\n  * Wrap each line to default width (80 characters):\n`fold {{path/to/file}}`\n  * Wrap each line to width \"30\":\n`fold -w30 {{path/to/file}}`\n  * Wrap each line to width \"5\" and break the line at spaces (puts each space separated word in a new line, words with length > 5 are wrapped):\n`fold -w5 -s {{path/to/file}}`"}
{"instruction": "What is dirname command", "input": "", "output": "# dirname\n> Calculates the parent directory of a given file or directory path. More\n> information: https://www.gnu.org/software/coreutils/dirname.\n  * Calculate the parent directory of a given path:\n`dirname {{path/to/file_or_directory}}`\n  * Calculate the parent directory of multiple paths:\n`dirname {{path/to/file_a}} {{path/to/directory_b}}`\n  * Delimit output with a NUL character instead of a newline (useful when combining with `xargs`):\n`dirname --zero {{path/to/directory_a}} {{path/to/file_b}}`"}
{"instruction": "What is tsort command", "input": "", "output": "# tsort\n> Perform a topological sort. A common use is to show the dependency order of\n> nodes in a directed acyclic graph. More information:\n> https://www.gnu.org/software/coreutils/tsort.\n  * Perform a topological sort consistent with a partial sort per line of input separated by blanks:\n`tsort {{path/to/file}}`\n  * Perform a topological sort consistent on strings:\n`echo -e \"{{UI Backend\\nBackend Database\\nDocs UI}}\" | tsort`"}
{"instruction": "What is base32 command", "input": "", "output": "# base32\n> Encode or decode file or `stdin` to/from Base32, to `stdout`. More\n> information: https://www.gnu.org/software/coreutils/base32.\n  * Encode a file:\n`base32 {{path/to/file}}`\n  * Decode a file:\n`base32 --decode {{path/to/file}}`\n  * Encode from `stdin`:\n`{{somecommand}} | base32`\n  * Decode from `stdin`:\n`{{somecommand}} | base32 --decode`"}
{"instruction": "What is git-commit-tree command", "input": "", "output": "# git commit-tree\n> Low level utility to create commit objects. See also: `git commit`. More\n> information: https://git-scm.com/docs/git-commit-tree.\n  * Create a commit object with the specified message:\n`git commit-tree {{tree}} -m \"{{message}}\"`\n  * Create a commit object reading the message from a file (use `-` for `stdin`):\n`git commit-tree {{tree}} -F {{path/to/file}}`\n  * Create a GPG-signed commit object:\n`git commit-tree {{tree}} -m \"{{message}}\" --gpg-sign`\n  * Create a commit object with the specified parent commit object:\n`git commit-tree {{tree}} -m \"{{message}}\" -p {{parent_commit_sha}}`"}
{"instruction": "What is reset command", "input": "", "output": "# reset\n> Reinitializes the current terminal. Clears the entire terminal screen. More\n> information: https://manned.org/reset.\n  * Reinitialize the current terminal:\n`reset`\n  * Display the terminal type instead:\n`reset -q`"}
{"instruction": "What is git-init command", "input": "", "output": "# git init\n> Initializes a new local Git repository. More information: https://git-\n> scm.com/docs/git-init.\n  * Initialize a new local repository:\n`git init`\n  * Initialize a repository with the specified name for the initial branch:\n`git init --initial-branch={{branch_name}}`\n  * Initialize a repository using SHA256 for object hashes (requires Git version 2.29+):\n`git init --object-format={{sha256}}`\n  * Initialize a barebones repository, suitable for use as a remote over ssh:\n`git init --bare`"}
{"instruction": "What is csplit command", "input": "", "output": "# csplit\n> Split a file into pieces. This generates files named \"xx00\", \"xx01\", and so\n> on. More information: https://www.gnu.org/software/coreutils/csplit.\n  * Split a file at lines 5 and 23:\n`csplit {{path/to/file}} {{5}} {{23}}`\n  * Split a file every 5 lines (this will fail if the total number of lines is not divisible by 5):\n`csplit {{path/to/file}} {{5}} {*}`\n  * Split a file every 5 lines, ignoring exact-division error:\n`csplit -k {{path/to/file}} {{5}} {*}`\n  * Split a file at line 5 and use a custom prefix for the output files:\n`csplit {{path/to/file}} {{5}} -f {{prefix}}`\n  * Split a file at a line matching a regular expression:\n`csplit {{path/to/file}} /{{regular_expression}}/`"}
{"instruction": "What is make command", "input": "", "output": "# make\n> Task runner for targets described in Makefile. Mostly used to control the\n> compilation of an executable from source code. More information:\n> https://www.gnu.org/software/make/manual/make.html.\n  * Call the first target specified in the Makefile (usually named \"all\"):\n`make`\n  * Call a specific target:\n`make {{target}}`\n  * Call a specific target, executing 4 jobs at a time in parallel:\n`make -j{{4}} {{target}}`\n  * Use a specific Makefile:\n`make --file {{path/to/file}}`\n  * Execute make from another directory:\n`make --directory {{path/to/directory}}`\n  * Force making of a target, even if source files are unchanged:\n`make --always-make {{target}}`\n  * Override a variable defined in the Makefile:\n`make {{target}} {{variable}}={{new_value}}`\n  * Override variables defined in the Makefile by the environment:\n`make --environment-overrides {{target}}`"}
{"instruction": "What is sed command", "input": "", "output": "# sed\n> Edit text in a scriptable manner. See also: `awk`, `ed`. More information:\n> https://keith.github.io/xcode-man-pages/sed.1.html.\n  * Replace all `apple` (basic regex) occurrences with `mango` (basic regex) in all input lines and print the result to `stdout`:\n`{{command}} | sed 's/apple/mango/g'`\n  * Execute a specific script [f]ile and print the result to `stdout`:\n`{{command}} | sed -f {{path/to/script_file.sed}}`\n  * Replace all `apple` (extended regex) occurrences with `APPLE` (extended regex) in all input lines and print the result to `stdout`:\n`{{command}} | sed -E 's/(apple)/\\U\\1/g'`\n  * Print just a first line to `stdout`:\n`{{command}} | sed -n '1p'`\n  * Replace all `apple` (basic regex) occurrences with `mango` (basic regex) in a `file` and save a backup of the original to `file.bak`:\n`sed -i bak 's/apple/mango/g' {{path/to/file}}`"}
{"instruction": "What is dash command", "input": "", "output": "# dash\n> Debian Almquist Shell, a modern, POSIX-compliant implementation of `sh` (not\n> Bash-compatible). More information: https://manned.org/dash.\n  * Start an interactive shell session:\n`dash`\n  * Execute specific [c]ommands:\n`dash -c \"{{echo 'dash is executed'}}\"`\n  * Execute a specific script:\n`dash {{path/to/script.sh}}`\n  * Check a specific script for syntax errors:\n`dash -n {{path/to/script.sh}}`\n  * Execute a specific script while printing each command before executing it:\n`dash -x {{path/to/script.sh}}`\n  * Execute a specific script and stop at the first [e]rror:\n`dash -e {{path/to/script.sh}}`\n  * Execute specific commands from `stdin`:\n`{{echo \"echo 'dash is executed'\"}} | dash`"}
{"instruction": "What is ex command", "input": "", "output": "# ex\n> Command-line text editor. See also: `vim`. More information:\n> https://www.vim.org.\n  * Open a file:\n`ex {{path/to/file}}`\n  * Save and Quit:\n`wq<Enter>`\n  * Undo the last operation:\n`undo<Enter>`\n  * Search for a pattern in the file:\n`/{{search_pattern}}<Enter>`\n  * Perform a regular expression substitution in the whole file:\n`%s/{{regular_expression}}/{{replacement}}/g<Enter>`\n  * Insert text:\n`i<Enter>{{text}}<C-c>`\n  * Switch to Vim:\n`visual<Enter>`"}
{"instruction": "What is time command", "input": "", "output": "# time\n> Measure how long a command took to run. Note: `time` can either exist as a\n> shell builtin, a standalone program or both. More information:\n> https://manned.org/time.\n  * Run the `command` and print the time measurements to `stdout`:\n`time {{command}}`"}
{"instruction": "What is printf command", "input": "", "output": "# printf\n> Format and print text. More information:\n> https://www.gnu.org/software/coreutils/printf.\n  * Print a text message:\n`printf \"{{%s\\n}}\" \"{{Hello world}}\"`\n  * Print an integer in bold blue:\n`printf \"{{\\e[1;34m%.3d\\e[0m\\n}}\" {{42}}`\n  * Print a float number with the Unicode Euro sign:\n`printf \"{{\\u20AC %.2f\\n}}\" {{123.4}}`\n  * Print a text message composed with environment variables:\n`printf \"{{var1: %s\\tvar2: %s\\n}}\" \"{{$VAR1}}\" \"{{$VAR2}}\"`\n  * Store a formatted message in a variable (does not work on zsh):\n`printf -v {{myvar}} {{\"This is %s = %d\\n\" \"a year\" 2016}}`"}
{"instruction": "What is pwd command", "input": "", "output": "# pwd\n> Print name of current/working directory. More information:\n> https://www.gnu.org/software/coreutils/pwd.\n  * Print the current directory:\n`pwd`\n  * Print the current directory, and resolve all symlinks (i.e. show the \"physical\" path):\n`pwd -P`"}
{"instruction": "What is loadkeys command", "input": "", "output": "# loadkeys\n> Load the kernel keymap for the console. More information:\n> https://manned.org/loadkeys.\n  * Load a default keymap:\n`loadkeys --default`\n  * Load default keymap when an unusual keymap is loaded and `-` sign cannot be found:\n`loadkeys defmap`\n  * Create a kernel source table:\n`loadkeys --mktable`\n  * Create a binary keymap:\n`loadkeys --bkeymap`\n  * Search and parse keymap without action:\n`loadkeys --parse`\n  * Load the keymap suppressing all output:\n`loadkeys --quiet`\n  * Load a keymap from the specified file for the console:\n`loadkeys --console {{/dev/ttyN}} {{/path/to/file}}`\n  * Use standard names for keymaps of different locales:\n`loadkeys --console {{/dev/ttyN}} {{uk}}`"}
{"instruction": "What is env command", "input": "", "output": "# env\n> Show the environment or run a program in a modified environment. More\n> information: https://www.gnu.org/software/coreutils/env.\n  * Show the environment:\n`env`\n  * Run a program. Often used in scripts after the shebang (#!) for looking up the path to the program:\n`env {{program}}`\n  * Clear the environment and run a program:\n`env -i {{program}}`\n  * Remove variable from the environment and run a program:\n`env -u {{variable}} {{program}}`\n  * Set a variable and run a program:\n`env {{variable}}={{value}} {{program}}`\n  * Set multiple variables and run a program:\n`env {{variable1}}={{value}} {{variable2}}={{value}} {{variable3}}={{value}}\n{{program}}`"}
{"instruction": "What is look command", "input": "", "output": "# look\n> Look for lines in sorted file. More information: https://manned.org/look.\n  * Look for lines which begins with the given prefix:\n`look {{prefix}} {{path/to/file}}`\n  * Look for lines ignoring case:\n`look --ignore-case {{prefix}} {{path/to/file}}`"}
{"instruction": "What is fgrep command", "input": "", "output": "# fgrep\n> Matches fixed strings in files. Equivalent to `grep -F`. More information:\n> https://www.gnu.org/software/grep/manual/grep.html.\n  * Search for an exact string in a file:\n`fgrep {{search_string}} {{path/to/file}}`\n  * Search only lines that match entirely in files:\n`fgrep -x {{path/to/file1}} {{path/to/file2}}`\n  * Count the number of lines that match the given string in a file:\n`fgrep -c {{search_string}} {{path/to/file}}`\n  * Show the line number in the file along with the line matched:\n`fgrep -n {{search_string}} {{path/to/file}}`\n  * Display all lines except those that contain the search string:\n`fgrep -v {{search_string}} {{path/to/file}}`\n  * Display filenames whose content matches the search string at least once:\n`fgrep -l {{search_string}} {{path/to/file1}} {{path/to/file2}}`"}
{"instruction": "What is df command", "input": "", "output": "# df\n> Gives an overview of the filesystem disk space usage. More information:\n> https://www.gnu.org/software/coreutils/df.\n  * Display all filesystems and their disk usage:\n`df`\n  * Display all filesystems and their disk usage in human-readable form:\n`df -h`\n  * Display the filesystem and its disk usage containing the given file or directory:\n`df {{path/to/file_or_directory}}`\n  * Display statistics on the number of free inodes:\n`df -i`\n  * Display filesystems but exclude the specified types:\n`df -x {{squashfs}} -x {{tmpfs}}`"}
{"instruction": "What is sha512sum command", "input": "", "output": "# sha512sum\n> Calculate SHA512 cryptographic checksums. More information:\n> https://www.gnu.org/software/coreutils/manual/html_node/sha2-utilities.html.\n  * Calculate the SHA512 checksum for one or more files:\n`sha512sum {{path/to/file1 path/to/file2 ...}}`\n  * Calculate and save the list of SHA512 checksums to a file:\n`sha512sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha512}}`\n  * Calculate a SHA512 checksum from `stdin`:\n`{{command}} | sha512sum`\n  * Read a file of SHA512 sums and filenames and verify all files have matching checksums:\n`sha512sum --check {{path/to/file.sha512}}`\n  * Only show a message for missing files or when verification fails:\n`sha512sum --check --quiet {{path/to/file.sha512}}`\n  * Only show a message when verification fails, ignoring missing files:\n`sha512sum --ignore-missing --check --quiet {{path/to/file.sha512}}`"}
{"instruction": "What is dpkg-deb command", "input": "", "output": "# dpkg-deb\n> Pack, unpack and provide information about Debian archives. More\n> information: https://manpages.debian.org/latest/dpkg/dpkg-deb.html.\n  * Display information about a package:\n`dpkg-deb --info {{path/to/file.deb}}`\n  * Display the package's name and version on one line:\n`dpkg-deb --show {{path/to/file.deb}}`\n  * List the package's contents:\n`dpkg-deb --contents {{path/to/file.deb}}`\n  * Extract package's contents into a directory:\n`dpkg-deb --extract {{path/to/file.deb}} {{path/to/directory}}`\n  * Create a package from a specified directory:\n`dpkg-deb --build {{path/to/directory}}`"}
{"instruction": "What is updatedb command", "input": "", "output": "# updatedb\n> Create or update the database used by `locate`. It is usually run daily by\n> cron. More information: https://manned.org/updatedb.\n  * Refresh database content:\n`sudo updatedb`\n  * Display file names as soon as they are found:\n`sudo updatedb --verbose`"}
{"instruction": "What is sort command", "input": "", "output": "# sort\n> Sort lines of text files. More information:\n> https://www.gnu.org/software/coreutils/sort.\n  * Sort a file in ascending order:\n`sort {{path/to/file}}`\n  * Sort a file in descending order:\n`sort --reverse {{path/to/file}}`\n  * Sort a file in case-insensitive way:\n`sort --ignore-case {{path/to/file}}`\n  * Sort a file using numeric rather than alphabetic order:\n`sort --numeric-sort {{path/to/file}}`\n  * Sort `/etc/passwd` by the 3rd field of each line numerically, using \":\" as a field separator:\n`sort --field-separator={{:}} --key={{3n}} {{/etc/passwd}}`\n  * Sort a file preserving only unique lines:\n`sort --unique {{path/to/file}}`\n  * Sort a file, printing the output to the specified output file (can be used to sort a file in-place):\n`sort --output={{path/to/file}} {{path/to/file}}`\n  * Sort numbers with exponents:\n`sort --general-numeric-sort {{path/to/file}}`"}
{"instruction": "What is lex command", "input": "", "output": "# lex\n> Lexical analyzer generator. Given the specification for a lexical analyzer,\n> generates C code implementing it. More information:\n> https://keith.github.io/xcode-man-pages/lex.1.html.\n  * Generate an analyzer from a Lex file:\n`lex {{analyzer.l}}`\n  * Specify the output file:\n`lex {{analyzer.l}} --outfile {{analyzer.c}}`\n  * Compile a C file generated by Lex:\n`cc {{path/to/lex.yy.c}} --output {{executable}}`"}
{"instruction": "What is ulimit command", "input": "", "output": "# ulimit\n> Get and set user limits. More information: https://manned.org/ulimit.\n  * Get the properties of all the user limits:\n`ulimit -a`\n  * Get hard limit for the number of simultaneously opened files:\n`ulimit -H -n`\n  * Get soft limit for the number of simultaneously opened files:\n`ulimit -S -n`\n  * Set max per-user process limit:\n`ulimit -u 30`"}
{"instruction": "What is chfn command", "input": "", "output": "# chfn\n> Update `finger` info for a user. More information: https://manned.org/chfn.\n  * Update a user's \"Name\" field in the output of `finger`:\n`chfn -f {{new_display_name}} {{username}}`\n  * Update a user's \"Office Room Number\" field for the output of `finger`:\n`chfn -o {{new_office_room_number}} {{username}}`\n  * Update a user's \"Office Phone Number\" field for the output of `finger`:\n`chfn -p {{new_office_telephone_number}} {{username}}`\n  * Update a user's \"Home Phone Number\" field for the output of `finger`:\n`chfn -h {{new_home_telephone_number}} {{username}}`"}
{"instruction": "What is nice command", "input": "", "output": "# nice\n> Execute a program with a custom scheduling priority (niceness). Niceness\n> values range from -20 (the highest priority) to 19 (the lowest). More\n> information: https://www.gnu.org/software/coreutils/nice.\n  * Launch a program with altered priority:\n`nice -n {{niceness_value}} {{command}}`"}
{"instruction": "What is tail command", "input": "", "output": "# tail\n> Display the last part of a file. See also: `head`. More information:\n> https://manned.org/man/freebsd-13.0/tail.1.\n  * Show last 'count' lines in file:\n`tail -n {{8}} {{path/to/file}}`\n  * Print a file from a specific line number:\n`tail -n +{{8}} {{path/to/file}}`\n  * Print a specific count of bytes from the end of a given file:\n`tail -c {{8}} {{path/to/file}}`\n  * Print the last lines of a given file and keep reading file until `Ctrl + C`:\n`tail -f {{path/to/file}}`\n  * Keep reading file until `Ctrl + C`, even if the file is inaccessible:\n`tail -F {{path/to/file}}`\n  * Show last 'count' lines in 'file' and refresh every 'seconds' seconds:\n`tail -n {{8}} -s {{10}} -f {{path/to/file}}`"}
{"instruction": "What is ctags command", "input": "", "output": "# ctags\n> Generates an index (or tag) file of language objects found in source files\n> for many popular programming languages. More information: https://ctags.io/.\n  * Generate tags for a single file, and output them to a file named \"tags\" in the current directory, overwriting the file if it exists:\n`ctags {{path/to/file}}`\n  * Generate tags for all files in the current directory, and output them to a specific file, overwriting the file if it exists:\n`ctags -f {{path/to/file}} *`\n  * Generate tags for all files in the current directory and all subdirectories:\n`ctags --recurse`\n  * Generate tags for a single file, and output them with start line number and end line number in JSON format:\n`ctags --fields=+ne --output-format=json {{path/to/file}}`"}
{"instruction": "What is mkdir command", "input": "", "output": "# mkdir\n> Create directories and set their permissions. More information:\n> https://www.gnu.org/software/coreutils/mkdir.\n  * Create specific directories:\n`mkdir {{path/to/directory1 path/to/directory2 ...}}`\n  * Create specific directories and their [p]arents if needed:\n`mkdir -p {{path/to/directory1 path/to/directory2 ...}}`\n  * Create directories with specific permissions:\n`mkdir -m {{rwxrw-r--}} {{path/to/directory1 path/to/directory2 ...}}`"}
{"instruction": "What is test command", "input": "", "output": "# test\n> Check file types and compare values. Returns 0 if the condition evaluates to\n> true, 1 if it evaluates to false. More information:\n> https://www.gnu.org/software/coreutils/test.\n  * Test if a given variable is equal to a given string:\n`test \"{{$MY_VAR}}\" == \"{{/bin/zsh}}\"`\n  * Test if a given variable is empty:\n`test -z \"{{$GIT_BRANCH}}\"`\n  * Test if a file exists:\n`test -f \"{{path/to/file_or_directory}}\"`\n  * Test if a directory does not exist:\n`test ! -d \"{{path/to/directory}}\"`\n  * If A is true, then do B, or C in the case of an error (notice that C may run even if A fails):\n`test {{condition}} && {{echo \"true\"}} || {{echo \"false\"}}`"}
{"instruction": "What is uptime command", "input": "", "output": "# uptime\n> Tell how long the system has been running and other information. More\n> information: https://ss64.com/osx/uptime.html.\n  * Print current time, uptime, number of logged-in users and other information:\n`uptime`"}
{"instruction": "What is sha384sum command", "input": "", "output": "# sha384sum\n> Calculate SHA384 cryptographic checksums. More information:\n> https://www.gnu.org/software/coreutils/manual/html_node/sha2-utilities.html.\n  * Calculate the SHA384 checksum for one or more files:\n`sha384sum {{path/to/file1 path/to/file2 ...}}`\n  * Calculate and save the list of SHA384 checksums to a file:\n`sha384sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha384}}`\n  * Calculate a SHA384 checksum from `stdin`:\n`{{command}} | sha384sum`\n  * Read a file of SHA384 sums and filenames and verify all files have matching checksums:\n`sha384sum --check {{path/to/file.sha384}}`\n  * Only show a message for missing files or when verification fails:\n`sha384sum --check --quiet {{path/to/file.sha384}}`\n  * Only show a message when verification fails, ignoring missing files:\n`sha384sum --ignore-missing --check --quiet {{path/to/file.sha384}}`"}
{"instruction": "What is file command", "input": "", "output": "# file\n> Determine file type. More information: https://manned.org/file.\n  * Give a description of the type of the specified file. Works fine for files with no file extension:\n`file {{path/to/file}}`\n  * Look inside a zipped file and determine the file type(s) inside:\n`file -z {{foo.zip}}`\n  * Allow file to work with special or device files:\n`file -s {{path/to/file}}`\n  * Don't stop at first file type match; keep going until the end of the file:\n`file -k {{path/to/file}}`\n  * Determine the MIME encoding type of a file:\n`file -i {{path/to/file}}`"}
{"instruction": "What is rm command", "input": "", "output": "# rm\n> Remove files or directories. See also: `rmdir`. More information:\n> https://www.gnu.org/software/coreutils/rm.\n  * Remove specific files:\n`rm {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files ignoring nonexistent ones:\n`rm -f {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files [i]nteractively prompting before each removal:\n`rm -i {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files printing info about each removal:\n`rm -v {{path/to/file1 path/to/file2 ...}}`\n  * Remove specific files and directories [r]ecursively:\n`rm -r {{path/to/file_or_directory1 path/to/file_or_directory2 ...}}`"}
{"instruction": "What is git-update-ref command", "input": "", "output": "# git update-ref\n> Git command for creating, updating, and deleting Git refs. More information:\n> https://git-scm.com/docs/git-update-ref.\n  * Delete a ref, useful for soft resetting the first commit:\n`git update-ref -d {{HEAD}}`\n  * Update ref with a message:\n`git update-ref -m {{message}} {{HEAD}} {{4e95e05}}`"}
{"instruction": "What is localectl command", "input": "", "output": "# localectl\n> Control the system locale and keyboard layout settings. More information:\n> https://www.freedesktop.org/software/systemd/man/localectl.html.\n  * Show the current settings of the system locale and keyboard mapping:\n`localectl`\n  * List available locales:\n`localectl list-locales`\n  * Set a system locale variable:\n`localectl set-locale {{LANG}}={{en_US.UTF-8}}`\n  * List available keymaps:\n`localectl list-keymaps`\n  * Set the system keyboard mapping for the console and X11:\n`localectl set-keymap {{us}}`"}
{"instruction": "What is cat command", "input": "", "output": "# cat\n> Print and concatenate files. More information:\n> https://keith.github.io/xcode-man-pages/cat.1.html.\n  * Print the contents of a file to `stdout`:\n`cat {{path/to/file}}`\n  * Concatenate several files into an output file:\n`cat {{path/to/file1 path/to/file2 ...}} > {{path/to/output_file}}`\n  * Append several files to an output file:\n`cat {{path/to/file1 path/to/file2 ...}} >> {{path/to/output_file}}`\n  * Copy the contents of a file into an output file without buffering:\n`cat -u {{/dev/tty12}} > {{/dev/tty13}}`\n  * Write `stdin` to a file:\n`cat - > {{path/to/file}}`\n  * Number all output lines:\n`cat -n {{path/to/file}}`\n  * Display non-printable and whitespace characters (with `M-` prefix if non-ASCII):\n`cat -v -t -e {{path/to/file}}`"}
{"instruction": "What is fc command", "input": "", "output": "# fc\n> Open the most recent command and edit it. More information:\n> https://manned.org/fc.\n  * Open in the default system editor:\n`fc`\n  * Specify an editor to open with:\n`fc -e {{'emacs'}}`\n  * List recent commands from history:\n`fc -l`\n  * List recent commands in reverse order:\n`fc -l -r`\n  * List commands in a given interval:\n`fc '{{416}}' '{{420}}'`"}
{"instruction": "What is sum command", "input": "", "output": "# sum\n> Compute checksums and the number of blocks for a file. A predecessor to the\n> more modern `cksum`. More information:\n> https://www.gnu.org/software/coreutils/sum.\n  * Compute a checksum with BSD-compatible algorithm and 1024-byte blocks:\n`sum {{path/to/file}}`\n  * Compute a checksum with System V-compatible algorithm and 512-byte blocks:\n`sum --sysv {{path/to/file}}`"}
{"instruction": "What is sha256sum command", "input": "", "output": "# sha256sum\n> Calculate SHA256 cryptographic checksums. More information:\n> https://www.gnu.org/software/coreutils/manual/html_node/sha2-utilities.html.\n  * Calculate the SHA256 checksum for one or more files:\n`sha256sum {{path/to/file1 path/to/file2 ...}}`\n  * Calculate and save the list of SHA256 checksums to a file:\n`sha256sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.sha256}}`\n  * Calculate a SHA256 checksum from `stdin`:\n`{{command}} | sha256sum`\n  * Read a file of SHA256 sums and filenames and verify all files have matching checksums:\n`sha256sum --check {{path/to/file.sha256}}`\n  * Only show a message for missing files or when verification fails:\n`sha256sum --check --quiet {{path/to/file.sha256}}`\n  * Only show a message when verification fails, ignoring missing files:\n`sha256sum --ignore-missing --check --quiet {{path/to/file.sha256}}`"}
{"instruction": "What is runcon command", "input": "", "output": "# runcon\n> Run a program in a different SELinux security context. With neither context\n> nor command, print the current security context. More information:\n> https://www.gnu.org/software/coreutils/runcon.\n  * Determine the current domain:\n`runcon`\n  * Specify the domain to run a command in:\n`runcon -t {{domain}}_t {{command}}`\n  * Specify the context role to run a command with:\n`runcon -r {{role}}_r {{command}}`\n  * Specify the full context to run a command with:\n`runcon {{user}}_u:{{role}}_r:{{domain}}_t {{command}}`"}
{"instruction": "What is curl command", "input": "", "output": "# curl\n> Transfers data from or to a server. Supports most protocols, including HTTP,\n> FTP, and POP3. More information: https://curl.se/docs/manpage.html.\n  * Download the contents of a URL to a file:\n`curl {{http://example.com}} --output {{path/to/file}}`\n  * Download a file, saving the output under the filename indicated by the URL:\n`curl --remote-name {{http://example.com/filename}}`\n  * Download a file, following location redirects, and automatically continuing (resuming) a previous file transfer and return an error on server error:\n`curl --fail --remote-name --location --continue-at -\n{{http://example.com/filename}}`\n  * Send form-encoded data (POST request of type `application/x-www-form-urlencoded`). Use `--data @file_name` or `--data @'-'` to read from STDIN:\n`curl --data {{'name=bob'}} {{http://example.com/form}}`\n  * Send a request with an extra header, using a custom HTTP method:\n`curl --header {{'X-My-Header: 123'}} --request {{PUT}}\n{{http://example.com}}`\n  * Send data in JSON format, specifying the appropriate content-type header:\n`curl --data {{'{\"name\":\"bob\"}'}} --header {{'Content-Type:\napplication/json'}} {{http://example.com/users/1234}}`\n  * Pass a username and password for server authentication:\n`curl --user myusername:mypassword {{http://example.com}}`\n  * Pass client certificate and key for a resource, skipping certificate validation:\n`curl --cert {{client.pem}} --key {{key.pem}} --insecure\n{{https://example.com}}`"}
{"instruction": "What is git-verify-commit command", "input": "", "output": "# git verify-commit\n> Check for GPG verification of commits. If no commits are verified, nothing\n> will be printed, regardless of options specified. More information:\n> https://git-scm.com/docs/git-verify-commit.\n  * Check commits for a GPG signature:\n`git verify-commit {{commit_hash1 optional_commit_hash2 ...}}`\n  * Check commits for a GPG signature and show details of each commit:\n`git verify-commit {{commit_hash1 optional_commit_hash2 ...}} --verbose`\n  * Check commits for a GPG signature and print the raw details:\n`git verify-commit {{commit_hash1 optional_commit_hash2 ...}} --raw`"}
{"instruction": "What is rmdir command", "input": "", "output": "# rmdir\n> Remove directories without files. See also: `rm`. More information:\n> https://www.gnu.org/software/coreutils/rmdir.\n  * Remove specific directories:\n`rmdir {{path/to/directory1 path/to/directory2 ...}}`\n  * Remove specific nested directories recursively:\n`rmdir -p {{path/to/directory1 path/to/directory2 ...}}`"}
{"instruction": "What is getfacl command", "input": "", "output": "# getfacl\n> Get file access control lists. More information: https://manned.org/getfacl.\n  * Display the file access control list:\n`getfacl {{path/to/file_or_directory}}`\n  * Display the file access control list with numeric user and group IDs:\n`getfacl -n {{path/to/file_or_directory}}`\n  * Display the file access control list with tabular output format:\n`getfacl -t {{path/to/file_or_directory}}`"}
{"instruction": "What is nsenter command", "input": "", "output": "# nsenter\n> Run a new command in a running process' namespace. Particularly useful for\n> docker images or chroot jails. More information: https://manned.org/nsenter.\n  * Run a specific command using the same namespaces as an existing process:\n`nsenter --target {{pid}} --all {{command}} {{command_arguments}}`\n  * Run a specific command in an existing process's network namespace:\n`nsenter --target {{pid}} --net {{command}} {{command_arguments}}`\n  * Run a specific command in an existing process's PID namespace:\n`nsenter --target {{pid}} --pid {{command}} {{command_arguments}}`\n  * Run a specific command in an existing process's IPC namespace:\n`nsenter --target {{pid}} --ipc {{command}} {{command_arguments}}`\n  * Run a specific command in an existing process's UTS, time, and IPC namespaces:\n`nsenter --target {{pid}} --uts --time --ipc -- {{command}}\n{{command_arguments}}`\n  * Run a specific command in an existing process's namespace by referencing procfs:\n`nsenter --pid=/proc/{{pid}}/pid/net -- {{command}} {{command_arguments}}`"}
{"instruction": "What is rsync command", "input": "", "output": "# rsync\n> Transfer files either to or from a remote host (but not between two remote\n> hosts), by default using SSH. To specify a remote path, use\n> `host:path/to/file_or_directory`. More information:\n> https://download.samba.org/pub/rsync/rsync.1.\n  * Transfer a file:\n`rsync {{path/to/source}} {{path/to/destination}}`\n  * Use archive mode (recursively copy directories, copy symlinks without resolving and preserve permissions, ownership and modification times):\n`rsync --archive {{path/to/source}} {{path/to/destination}}`\n  * Compress the data as it is sent to the destination, display verbose and human-readable progress, and keep partially transferred files if interrupted:\n`rsync --compress --verbose --human-readable --partial --progress\n{{path/to/source}} {{path/to/destination}}`\n  * Recursively copy directories:\n`rsync --recursive {{path/to/source}} {{path/to/destination}}`\n  * Transfer directory contents, but not the directory itself:\n`rsync --recursive {{path/to/source}}/ {{path/to/destination}}`\n  * Recursively copy directories, use archive mode, resolve symlinks and skip files that are newer on the destination:\n`rsync --recursive --archive --update --copy-links {{path/to/source}}\n{{path/to/destination}}`\n  * Transfer a directory to a remote host running `rsyncd` and delete files on the destination that do not exist on the source:\n`rsync --recursive --delete rsync://{{host}}:{{path/to/source}}\n{{path/to/destination}}`\n  * Transfer a file over SSH using a different port than the default (22) and show global progress:\n`rsync --rsh 'ssh -p {{port}}' --info=progress2 {{host}}:{{path/to/source}}\n{{path/to/destination}}`"}
{"instruction": "What is unexpand command", "input": "", "output": "# unexpand\n> Convert spaces to tabs. More information:\n> https://www.gnu.org/software/coreutils/unexpand.\n  * Convert blanks in each file to tabs, writing to `stdout`:\n`unexpand {{path/to/file}}`\n  * Convert blanks to tabs, reading from `stdout`:\n`unexpand`\n  * Convert all blanks, instead of just initial blanks:\n`unexpand -a {{path/to/file}}`\n  * Convert only leading sequences of blanks (overrides -a):\n`unexpand --first-only {{path/to/file}}`\n  * Have tabs a certain number of characters apart, not 8 (enables -a):\n`unexpand -t {{number}} {{path/to/file}}`"}
{"instruction": "What is scp command", "input": "", "output": "# scp\n> Secure copy. Copy files between hosts using Secure Copy Protocol over SSH.\n> More information: https://man.openbsd.org/scp.\n  * Copy a local file to a remote host:\n`scp {{path/to/local_file}} {{remote_host}}:{{path/to/remote_file}}`\n  * Use a specific port when connecting to the remote host:\n`scp -P {{port}} {{path/to/local_file}}\n{{remote_host}}:{{path/to/remote_file}}`\n  * Copy a file from a remote host to a local directory:\n`scp {{remote_host}}:{{path/to/remote_file}} {{path/to/local_directory}}`\n  * Recursively copy the contents of a directory from a remote host to a local directory:\n`scp -r {{remote_host}}:{{path/to/remote_directory}}\n{{path/to/local_directory}}`\n  * Copy a file between two remote hosts transferring through the local host:\n`scp -3 {{host1}}:{{path/to/remote_file}}\n{{host2}}:{{path/to/remote_directory}}`\n  * Use a specific username when connecting to the remote host:\n`scp {{path/to/local_file}}\n{{remote_username}}@{{remote_host}}:{{path/to/remote_directory}}`\n  * Use a specific ssh private key for authentication with the remote host:\n`scp -i {{~/.ssh/private_key}} {{local_file}}\n{{remote_host}}:{{/path/remote_file}}`"}
{"instruction": "What is timedatectl command", "input": "", "output": "# timedatectl\n> Control the system time and date. More information:\n> https://manned.org/timedatectl.\n  * Check the current system clock time:\n`timedatectl`\n  * Set the local time of the system clock directly:\n`timedatectl set-time \"{{yyyy-MM-dd hh:mm:ss}}\"`\n  * List available timezones:\n`timedatectl list-timezones`\n  * Set the system timezone:\n`timedatectl set-timezone {{timezone}}`\n  * Enable Network Time Protocol (NTP) synchronization:\n`timedatectl set-ntp on`\n  * Change the hardware clock time standard to localtime:\n`timedatectl set-local-rtc 1`"}
{"instruction": "What is screen command", "input": "", "output": "# screen\n> Hold a session open on a remote server. Manage multiple windows with a\n> single SSH connection. See also `tmux` and `zellij`. More information:\n> https://manned.org/screen.\n  * Start a new screen session:\n`screen`\n  * Start a new named screen session:\n`screen -S {{session_name}}`\n  * Start a new daemon and log the output to `screenlog.x`:\n`screen -dmLS {{session_name}} {{command}}`\n  * Show open screen sessions:\n`screen -ls`\n  * Reattach to an open screen:\n`screen -r {{session_name}}`\n  * Detach from inside a screen:\n`Ctrl + A, D`\n  * Kill the current screen session:\n`Ctrl + A, K`\n  * Kill a detached screen:\n`screen -X -S {{session_name}} quit`"}
{"instruction": "What is write command", "input": "", "output": "# write\n> Write a message on the terminal of a specified logged in user (ctrl-C to\n> stop writing messages). Use the `who` command to find out all terminal_ids\n> of all active users active on the system. See also `mesg`. More information:\n> https://manned.org/write.\n  * Send a message to a given user on a given terminal id:\n`write {{username}} {{terminal_id}}`\n  * Send message to \"testuser\" on terminal `/dev/tty/5`:\n`write {{testuser}} {{tty/5}}`\n  * Send message to \"johndoe\" on pseudo terminal `/dev/pts/5`:\n`write {{johndoe}} {{pts/5}}`"}
{"instruction": "What is as command", "input": "", "output": "# as\n> Portable GNU assembler. Primarily intended to assemble output from `gcc` to\n> be used by `ld`. More information: https://www.unix.com/man-page/osx/1/as/.\n  * Assemble a file, writing the output to `a.out`:\n`as {{path/to/file.s}}`\n  * Assemble the output to a given file:\n`as {{path/to/file.s}} -o {{path/to/output_file.o}}`\n  * Generate output faster by skipping whitespace and comment preprocessing. (Should only be used for trusted compilers):\n`as -f {{path/to/file.s}}`\n  * Include a given path to the list of directories to search for files specified in `.include` directives:\n`as -I {{path/to/directory}} {{path/to/file.s}}`"}
{"instruction": "What is systemd-cat command", "input": "", "output": "# systemd-cat\n> Connect a pipeline or program's output streams with the systemd journal.\n> More information: https://www.freedesktop.org/software/systemd/man/systemd-\n> cat.html.\n  * Write the output of the specified command to the journal (both output streams are captured):\n`systemd-cat {{command}}`\n  * Write the output of a pipeline to the journal (`stderr` stays connected to the terminal):\n`{{command}} | systemd-cat`"}
{"instruction": "What is git-rev-parse command", "input": "", "output": "# git rev-parse\n> Display metadata related to specific revisions. More information:\n> https://git-scm.com/docs/git-rev-parse.\n  * Get the commit hash of a branch:\n`git rev-parse {{branch_name}}`\n  * Get the current branch name:\n`git rev-parse --abbrev-ref {{HEAD}}`\n  * Get the absolute path to the root directory:\n`git rev-parse --show-toplevel`"}
{"instruction": "What is patch command", "input": "", "output": "# patch\n> Patch a file (or files) with a diff file. Note that diff files should be\n> generated by the `diff` command. More information: https://manned.org/patch.\n  * Apply a patch using a diff file (filenames must be included in the diff file):\n`patch < {{patch.diff}}`\n  * Apply a patch to a specific file:\n`patch {{path/to/file}} < {{patch.diff}}`\n  * Patch a file writing the result to a different file:\n`patch {{path/to/input_file}} -o {{path/to/output_file}} < {{patch.diff}}`\n  * Apply a patch to the current directory:\n`patch -p1 < {{patch.diff}}`\n  * Apply the reverse of a patch:\n`patch -R < {{patch.diff}}`"}
{"instruction": "What is size command", "input": "", "output": "# size\n> Displays the sizes of sections inside binary files. More information:\n> https://sourceware.org/binutils/docs/binutils/size.html.\n  * Display the size of sections in a given object or executable file:\n`size {{path/to/file}}`\n  * Display the size of sections in a given object or executable file in [o]ctal:\n`size {{-o|--radix=8}} {{path/to/file}}`\n  * Display the size of sections in a given object or executable file in [d]ecimal:\n`size {{-d|--radix=10}} {{path/to/file}}`\n  * Display the size of sections in a given object or executable file in he[x]adecimal:\n`size {{-x|--radix=16}} {{path/to/file}}`"}
{"instruction": "What is column command", "input": "", "output": "# column\n> Format `stdin` or a file into multiple columns. Columns are filled before\n> rows; the default separator is a whitespace. More information:\n> https://manned.org/column.\n  * Format the output of a command for a 30 characters wide display:\n`printf \"header1 header2\\nbar foo\\n\" | column --output-width {{30}}`\n  * Split columns automatically and auto-align them in a tabular format:\n`printf \"header1 header2\\nbar foo\\n\" | column --table`\n  * Specify the column delimiter character for the `--table` option (e.g. \",\" for CSV) (defaults to whitespace):\n`printf \"header1,header2\\nbar,foo\\n\" | column --table --separator {{,}}`\n  * Fill rows before filling columns:\n`printf \"header1\\nbar\\nfoobar\\n\" | column --output-width {{30}} --fillrows`"}
{"instruction": "What is seq command", "input": "", "output": "# seq\n> Output a sequence of numbers to `stdout`. More information:\n> https://www.gnu.org/software/coreutils/seq.\n  * Sequence from 1 to 10:\n`seq 10`\n  * Every 3rd number from 5 to 20:\n`seq 5 3 20`\n  * Separate the output with a space instead of a newline:\n`seq -s \" \" 5 3 20`\n  * Format output width to a minimum of 4 digits padding with zeros as necessary:\n`seq -f \"%04g\" 5 3 20`"}
{"instruction": "What is fmt command", "input": "", "output": "# fmt\n> Reformat a text file by joining its paragraphs and limiting the line width\n> to given number of characters (75 by default). More information:\n> https://www.gnu.org/software/coreutils/fmt.\n  * Reformat a file:\n`fmt {{path/to/file}}`\n  * Reformat a file producing output lines of (at most) `n` characters:\n`fmt -w {{n}} {{path/to/file}}`\n  * Reformat a file without joining lines shorter than the given width together:\n`fmt -s {{path/to/file}}`\n  * Reformat a file with uniform spacing (1 space between words and 2 spaces between paragraphs):\n`fmt -u {{path/to/file}}`"}
{"instruction": "What is groups command", "input": "", "output": "# groups\n> Print group memberships for a user. See also: `groupadd`, `groupdel`,\n> `groupmod`. More information: https://www.gnu.org/software/coreutils/groups.\n  * Print group memberships for the current user:\n`groups`\n  * Print group memberships for a list of users:\n`groups {{username1 username2 ...}}`"}
{"instruction": "What is nm command", "input": "", "output": "# nm\n> List symbol names in object files. More information: https://manned.org/nm.\n  * List global (extern) functions in a file (prefixed with T):\n`nm -g {{path/to/file.o}}`\n  * List only undefined symbols in a file:\n`nm -u {{path/to/file.o}}`\n  * List all symbols, even debugging symbols:\n`nm -a {{path/to/file.o}}`\n  * Demangle C++ symbols (make them readable):\n`nm --demangle {{path/to/file.o}}`"}
{"instruction": "What is git-stage command", "input": "", "output": "# git stage\n> Add file contents to the staging area. Synonym of `git add`. More\n> information: https://git-scm.com/docs/git-stage.\n  * Add a file to the index:\n`git stage {{path/to/file}}`\n  * Add all files (tracked and untracked):\n`git stage -A`\n  * Only add already tracked files:\n`git stage -u`\n  * Also add ignored files:\n`git stage -f`\n  * Interactively stage parts of files:\n`git stage -p`\n  * Interactively stage parts of a given file:\n`git stage -p {{path/to/file}}`\n  * Interactively stage a file:\n`git stage -i`"}
{"instruction": "What is dd command", "input": "", "output": "# dd\n> Convert and copy a file. More information: https://keith.github.io/xcode-\n> man-pages/dd.1.html.\n  * Make a bootable USB drive from an isohybrid file (such like `archlinux-xxx.iso`) and show the progress:\n`dd if={{path/to/file.iso}} of={{/dev/usb_device}} status=progress`\n  * Clone a drive to another drive with 4 MB block, ignore error and show the progress:\n`dd if={{/dev/source_device}} of={{/dev/dest_device}} bs={{4m}}\nconv={{noerror}} status=progress`\n  * Generate a file of 100 random bytes by using kernel random driver:\n`dd if=/dev/urandom of={{path/to/random_file}} bs={{100}} count={{1}}`\n  * Benchmark the write performance of a disk:\n`dd if=/dev/zero of={{path/to/1GB_file}} bs={{1024}} count={{1000000}}`\n  * Generate a system backup into an IMG file and show the progress:\n`dd if=/dev/{{drive_device}} of={{path/to/file.img}} status=progress`\n  * Restore a drive from an IMG file and show the progress:\n`dd if={{path/to/file.img}} of={{/dev/drive_device}} status=progress`\n  * Check the progress of an ongoing dd operation (run this command from another shell):\n`kill -USR1 $(pgrep ^dd)`"}
{"instruction": "What is prlimit command", "input": "", "output": "# prlimit\n> Get or set process resource soft and hard limits. Given a process ID and one\n> or more resources, prlimit tries to retrieve and/or modify the limits. More\n> information: https://manned.org/prlimit.\n  * Display limit values for all current resources for the running parent process:\n`prlimit`\n  * Display limit values for all current resources of a specified process:\n`prlimit --pid {{pid number}}`\n  * Run a command with a custom number of open files limit:\n`prlimit --nofile={{10}} {{command}}`"}
{"instruction": "What is uniq command", "input": "", "output": "# uniq\n> Output the unique lines from the given input or file. Since it does not\n> detect repeated lines unless they are adjacent, we need to sort them first.\n> More information: https://www.gnu.org/software/coreutils/uniq.\n  * Display each line once:\n`sort {{path/to/file}} | uniq`\n  * Display only unique lines:\n`sort {{path/to/file}} | uniq -u`\n  * Display only duplicate lines:\n`sort {{path/to/file}} | uniq -d`\n  * Display number of occurrences of each line along with that line:\n`sort {{path/to/file}} | uniq -c`\n  * Display number of occurrences of each line, sorted by the most frequent:\n`sort {{path/to/file}} | uniq -c | sort -nr`"}
{"instruction": "What is git-remote command", "input": "", "output": "# git remote\n> Manage set of tracked repositories (\"remotes\"). More information:\n> https://git-scm.com/docs/git-remote.\n  * Show a list of existing remotes, their names and URL:\n`git remote -v`\n  * Show information about a remote:\n`git remote show {{remote_name}}`\n  * Add a remote:\n`git remote add {{remote_name}} {{remote_url}}`\n  * Change the URL of a remote (use `--add` to keep the existing URL):\n`git remote set-url {{remote_name}} {{new_url}}`\n  * Show the URL of a remote:\n`git remote get-url {{remote_name}}`\n  * Remove a remote:\n`git remote remove {{remote_name}}`\n  * Rename a remote:\n`git remote rename {{old_name}} {{new_name}}`"}
{"instruction": "What is systemd-path command", "input": "", "output": "# systemd-path\n> List and query system and user paths. More information:\n> https://www.freedesktop.org/software/systemd/man/systemd-path.html.\n  * Display a list of known paths and their current values:\n`systemd-path`\n  * Query the specified path and display its value:\n`systemd-path \"{{path_name}}\"`\n  * Suffix printed paths with `suffix_string`:\n`systemd-path --suffix {{suffix_string}}`\n  * Print a short version string and then exit:\n`systemd-path --version`"}
{"instruction": "What is whatis command", "input": "", "output": "# whatis\n> Tool that searches a set of database files containing short descriptions of\n> system commands for keywords. More information:\n> http://www.linfo.org/whatis.html.\n  * Search for information about keyword:\n`whatis {{keyword}}`\n  * Search for information about multiple keywords:\n`whatis {{keyword1}} {{keyword2}}`"}
{"instruction": "What is git-grep command", "input": "", "output": "# git-grep\n> Find strings inside files anywhere in a repository's history. Accepts a lot\n> of the same flags as regular `grep`. More information: https://git-\n> scm.com/docs/git-grep.\n  * Search for a string in tracked files:\n`git grep {{search_string}}`\n  * Search for a string in files matching a pattern in tracked files:\n`git grep {{search_string}} -- {{file_glob_pattern}}`\n  * Search for a string in tracked files, including submodules:\n`git grep --recurse-submodules {{search_string}}`\n  * Search for a string at a specific point in history:\n`git grep {{search_string}} {{HEAD~2}}`\n  * Search for a string across all branches:\n`git grep {{search_string}} $(git rev-list --all)`"}
{"instruction": "What is touch command", "input": "", "output": "# touch\n> Create files and set access/modification times. More information:\n> https://manned.org/man/freebsd-13.1/touch.\n  * Create specific files:\n`touch {{path/to/file1 path/to/file2 ...}}`\n  * Set the file [a]ccess or [m]odification times to the current one and don't [c]reate file if it doesn't exist:\n`touch -c -{{a|m}} {{path/to/file1 path/to/file2 ...}}`\n  * Set the file [t]ime to a specific value and don't [c]reate file if it doesn't exist:\n`touch -c -t {{YYYYMMDDHHMM.SS}} {{path/to/file1 path/to/file2 ...}}`\n  * Set the file time of a specific file to the time of anothe[r] file and don't [c]reate file if it doesn't exist:\n`touch -c -r {{~/.emacs}} {{path/to/file1 path/to/file2 ...}}`"}
{"instruction": "What is vdir command", "input": "", "output": "# vdir\n> List directory contents. Drop-in replacement for `ls -l`. More information:\n> https://www.gnu.org/software/coreutils/vdir.\n  * List files and directories in the current directory, one per line, with details:\n`vdir`\n  * List with sizes displayed in human-readable units (KB, MB, GB):\n`vdir -h`\n  * List including hidden files (starting with a dot):\n`vdir -a`\n  * List files and directories sorting entries by size (largest first):\n`vdir -S`\n  * List files and directories sorting entries by modification time (newest first):\n`vdir -t`\n  * List grouping directories first:\n`vdir --group-directories-first`\n  * Recursively list all files and directories in a specific directory:\n`vdir --recursive {{path/to/directory}}`"}
{"instruction": "What is pmap command", "input": "", "output": "# pmap\n> Report memory map of a process or processes. More information:\n> https://manned.org/pmap.\n  * Print memory map for a specific process id (PID):\n`pmap {{pid}}`\n  * Show the extended format:\n`pmap --extended {{pid}}`\n  * Show the device format:\n`pmap --device {{pid}}`\n  * Limit results to a memory address range specified by `low` and `high`:\n`pmap --range {{low}},{{high}}`\n  * Print memory maps for multiple processes:\n`pmap {{pid1 pid2 ...}}`"}
{"instruction": "What is killall command", "input": "", "output": "# killall\n> Send kill signal to all instances of a process by name (must be exact name).\n> All signals except SIGKILL and SIGSTOP can be intercepted by the process,\n> allowing a clean exit. More information: https://manned.org/killall.\n  * Terminate a process using the default SIGTERM (terminate) signal:\n`killall {{process_name}}`\n  * [l]ist available signal names (to be used without the 'SIG' prefix):\n`killall -l`\n  * Interactively ask for confirmation before termination:\n`killall -i {{process_name}}`\n  * Terminate a process using the SIGINT (interrupt) signal, which is the same signal sent by pressing `Ctrl + C`:\n`killall -INT {{process_name}}`\n  * Force kill a process:\n`killall -KILL {{process_name}}`"}
{"instruction": "What is who command", "input": "", "output": "# who\n> Display who is logged in and related data (processes, boot time). More\n> information: https://www.gnu.org/software/coreutils/who.\n  * Display the username, line, and time of all currently logged-in sessions:\n`who`\n  * Display information only for the current terminal session:\n`who am i`\n  * Display all available information:\n`who -a`\n  * Display all available information with table headers:\n`who -a -H`"}
{"instruction": "What is mesg command", "input": "", "output": "# mesg\n> Check or set a terminal's ability to receive messages from other users,\n> usually from the write command. See also `write`. More information:\n> https://manned.org/mesg.\n  * Check terminal's openness to write messages:\n`mesg`\n  * Disable receiving messages from the write command:\n`mesg n`\n  * Enable receiving messages from the write command:\n`mesg y`"}
{"instruction": "What is gcov command", "input": "", "output": "# gcov\n> Code coverage analysis and profiling tool that discovers untested parts of a\n> program. Also displays a copy of source code annotated with execution\n> frequencies of code segments. More information:\n> https://gcc.gnu.org/onlinedocs/gcc/Invoking-Gcov.html.\n  * Generate a coverage report named `file.cpp.gcov`:\n`gcov {{path/to/file.cpp}}`\n  * Write individual execution counts for every basic block:\n`gcov --all-blocks {{path/to/file.cpp}}`\n  * Write branch frequencies to the output file and print summary information to `stdout` as a percentage:\n`gcov --branch-probabilities {{path/to/file.cpp}}`\n  * Write branch frequencies as the number of branches taken, rather than the percentage:\n`gcov --branch-counts {{path/to/file.cpp}}`\n  * Do not create a `gcov` output file:\n`gcov --no-output {{path/to/file.cpp}}`\n  * Write file level as well as function level summaries:\n`gcov --function-summaries {{path/to/file.cpp}}`"}
{"instruction": "What is ltrace command", "input": "", "output": "# ltrace\n> Display dynamic library calls of a process. More information:\n> https://manned.org/ltrace.\n  * Print (trace) library calls of a program binary:\n`ltrace ./{{program}}`\n  * Count library calls. Print a handy summary at the bottom:\n`ltrace -c {{path/to/program}}`\n  * Trace calls to malloc and free, omit those done by libc:\n`ltrace -e malloc+free-@libc.so* {{path/to/program}}`\n  * Write to file instead of terminal:\n`ltrace -o {{file}} {{path/to/program}}`"}
{"instruction": "What is awk command", "input": "", "output": "# awk\n> A versatile programming language for working on files. More information:\n> https://github.com/onetrueawk/awk.\n  * Print the fifth column (a.k.a. field) in a space-separated file:\n`awk '{print $5}' {{path/to/file}}`\n  * Print the second column of the lines containing \"foo\" in a space-separated file:\n`awk '/{{foo}}/ {print $2}' {{path/to/file}}`\n  * Print the last column of each line in a file, using a comma (instead of space) as a field separator:\n`awk -F ',' '{print $NF}' {{path/to/file}}`\n  * Sum the values in the first column of a file and print the total:\n`awk '{s+=$1} END {print s}' {{path/to/file}}`\n  * Print every third line starting from the first line:\n`awk 'NR%3==1' {{path/to/file}}`\n  * Print different values based on conditions:\n`awk '{if ($1 == \"foo\") print \"Exact match foo\"; else if ($1 ~ \"bar\") print\n\"Partial match bar\"; else print \"Baz\"}' {{path/to/file}}`\n  * Print all lines where the 10th column value equals the specified value:\n`awk '($10 == value)'`\n  * Print all the lines which the 10th column value is between a min and a max:\n`awk '($10 >= min_value && $10 <= max_value)'`"}
{"instruction": "What is git-cherry-pick command", "input": "", "output": "# git cherry-pick\n> Apply the changes introduced by existing commits to the current branch. To\n> apply changes to another branch, first use `git checkout` to switch to the\n> desired branch. More information: https://git-scm.com/docs/git-cherry-pick.\n  * Apply a commit to the current branch:\n`git cherry-pick {{commit}}`\n  * Apply a range of commits to the current branch (see also `git rebase --onto`):\n`git cherry-pick {{start_commit}}~..{{end_commit}}`\n  * Apply multiple (non-sequential) commits to the current branch:\n`git cherry-pick {{commit_1}} {{commit_2}}`\n  * Add the changes of a commit to the working directory, without creating a commit:\n`git cherry-pick --no-commit {{commit}}`"}
{"instruction": "What is login command", "input": "", "output": "# login\n> Initiates a session for a user. More information: https://manned.org/login.\n  * Log in as a user:\n`login {{user}}`\n  * Log in as user without authentication if user is preauthenticated:\n`login -f {{user}}`\n  * Log in as user and preserve environment:\n`login -p {{user}}`\n  * Log in as a user on a remote host:\n`login -h {{host}} {{user}}`"}
{"instruction": "What is git-branch command", "input": "", "output": "# git branch\n> Main Git command for working with branches. More information: https://git-\n> scm.com/docs/git-branch.\n  * List all branches (local and remote; the current branch is highlighted by `*`):\n`git branch --all`\n  * List which branches include a specific Git commit in their history:\n`git branch --all --contains {{commit_hash}}`\n  * Show the name of the current branch:\n`git branch --show-current`\n  * Create new branch based on the current commit:\n`git branch {{branch_name}}`\n  * Create new branch based on a specific commit:\n`git branch {{branch_name}} {{commit_hash}}`\n  * Rename a branch (must not have it checked out to do this):\n`git branch -m {{old_branch_name}} {{new_branch_name}}`\n  * Delete a local branch (must not have it checked out to do this):\n`git branch -d {{branch_name}}`\n  * Delete a remote branch:\n`git push {{remote_name}} --delete {{remote_branch_name}}`"}
{"instruction": "What is base64 command", "input": "", "output": "# base64\n> Encode and decode using Base64 representation. More information:\n> https://www.unix.com/man-page/osx/1/base64/.\n  * Encode a file:\n`base64 --input={{plain_file}}`\n  * Decode a file:\n`base64 --decode --input={{base64_file}}`\n  * Encode from `stdin`:\n`echo -n \"{{plain_text}}\" | base64`\n  * Decode from `stdin`:\n`echo -n {{base64_text}} | base64 --decode`"}
{"instruction": "What is ipcs command", "input": "", "output": "# ipcs\n> Display information about resources used in IPC (Inter-process\n> Communication). More information: https://manned.org/ipcs.\n  * Specific information about the Message Queue which has the ID 32768:\n`ipcs -qi 32768`\n  * General information about all the IPC:\n`ipcs -a`"}
{"instruction": "What is type command", "input": "", "output": "# type\n> Display the type of command the shell will execute. More information:\n> https://manned.org/type.\n  * Display the type of a command:\n`type {{command}}`\n  * Display all locations containing the specified executable:\n`type -a {{command}}`\n  * Display the name of the disk file that would be executed:\n`type -p {{command}}`"}
{"instruction": "What is ul command", "input": "", "output": "# ul\n> Performs the underlining of a text. Each character in a given string must be\n> underlined separately. More information: https://manned.org/ul.\n  * Display the contents of the file with underlines where applicable:\n`ul {{file.txt}}`\n  * Display the contents of the file with underlines made of dashes `-`:\n`ul -i {{file.txt}}`"}
{"instruction": "What is ldd command", "input": "", "output": "# ldd\n> Display shared library dependencies of a binary. Do not use on an untrusted\n> binary, use objdump for that instead. More information:\n> https://manned.org/ldd.\n  * Display shared library dependencies of a binary:\n`ldd {{path/to/binary}}`\n  * Display all information about dependencies:\n`ldd --verbose {{path/to/binary}}`\n  * Display unused direct dependencies:\n`ldd --unused {{path/to/binary}}`\n  * Report missing data objects and perform data relocations:\n`ldd --data-relocs {{path/to/binary}}`\n  * Report missing data objects and functions, and perform relocations for both:\n`ldd --function-relocs {{path/to/binary}}`"}
{"instruction": "What is git-gc command", "input": "", "output": "# git gc\n> Optimise the local repository by cleaning unnecessary files. More\n> information: https://git-scm.com/docs/git-gc.\n  * Optimise the repository:\n`git gc`\n  * Aggressively optimise, takes more time:\n`git gc --aggressive`\n  * Do not prune loose objects (prunes by default):\n`git gc --no-prune`\n  * Suppress all output:\n`git gc --quiet`\n  * View full usage:\n`git gc --help`"}
{"instruction": "What is git-diff command", "input": "", "output": "# git diff\n> Show changes to tracked files. More information: https://git-\n> scm.com/docs/git-diff.\n  * Show unstaged, uncommitted changes:\n`git diff`\n  * Show all uncommitted changes (including staged ones):\n`git diff HEAD`\n  * Show only staged (added, but not yet committed) changes:\n`git diff --staged`\n  * Show changes from all commits since a given date/time (a date expression, e.g. \"1 week 2 days\" or an ISO date):\n`git diff 'HEAD@{3 months|weeks|days|hours|seconds ago}'`\n  * Show only names of changed files since a given commit:\n`git diff --name-only {{commit}}`\n  * Output a summary of file creations, renames and mode changes since a given commit:\n`git diff --summary {{commit}}`\n  * Compare a single file between two branches or commits:\n`git diff {{branch_1}}..{{branch_2}} [--] {{path/to/file}}`\n  * Compare different files from the current branch to other branch:\n`git diff {{branch}}:{{path/to/file2}} {{path/to/file}}`"}
{"instruction": "What is unexpand command", "input": "", "output": "# unexpand\n> Convert spaces to tabs. More information:\n> https://www.gnu.org/software/coreutils/unexpand.\n  * Convert blanks in each file to tabs, writing to `stdout`:\n`unexpand {{path/to/file}}`\n  * Convert blanks to tabs, reading from `stdout`:\n`unexpand`\n  * Convert all blanks, instead of just initial blanks:\n`unexpand -a {{path/to/file}}`\n  * Convert only leading sequences of blanks (overrides -a):\n`unexpand --first-only {{path/to/file}}`\n  * Have tabs a certain number of characters apart, not 8 (enables -a):\n`unexpand -t {{number}} {{path/to/file}}`"}
{"instruction": "What is unlink command", "input": "", "output": "# unlink\n> Remove a link to a file from the filesystem. The file contents is lost if\n> the link is the last one to the file. More information:\n> https://www.gnu.org/software/coreutils/unlink.\n  * Remove the specified file if it is the last link:\n`unlink {{path/to/file}}`"}
{"instruction": "What is ls command", "input": "", "output": "# ls\n> List directory contents. More information:\n> https://www.gnu.org/software/coreutils/ls.\n  * List files one per line:\n`ls -1`\n  * List all files, including hidden files:\n`ls -a`\n  * List all files, with trailing `/` added to directory names:\n`ls -F`\n  * Long format list (permissions, ownership, size, and modification date) of all files:\n`ls -la`\n  * Long format list with size displayed using human-readable units (KiB, MiB, GiB):\n`ls -lh`\n  * Long format list sorted by size (descending):\n`ls -lS`\n  * Long format list of all files, sorted by modification date (oldest first):\n`ls -ltr`\n  * Only list directories:\n`ls -d */`"}
{"instruction": "What is renice command", "input": "", "output": "# renice\n> Alters the scheduling priority/niceness of one or more running processes.\n> Niceness values range from -20 (most favorable to the process) to 19 (least\n> favorable to the process). More information: https://manned.org/renice.\n  * Change priority of a running process:\n`renice -n {{niceness_value}} -p {{pid}}`\n  * Change priority of all processes owned by a user:\n`renice -n {{niceness_value}} -u {{user}}`\n  * Change priority of all processes that belong to a process group:\n`renice -n {{niceness_value}} --pgrp {{process_group}}`"}
{"instruction": "What is groups command", "input": "", "output": "# groups\n> Print group memberships for a user. See also: `groupadd`, `groupdel`,\n> `groupmod`. More information: https://www.gnu.org/software/coreutils/groups.\n  * Print group memberships for the current user:\n`groups`\n  * Print group memberships for a list of users:\n`groups {{username1 username2 ...}}`"}
{"instruction": "What is comm command", "input": "", "output": "# comm\n> Select or reject lines common to two files. Both files must be sorted. More\n> information: https://www.gnu.org/software/coreutils/comm.\n  * Produce three tab-separated columns: lines only in first file, lines only in second file and common lines:\n`comm {{file1}} {{file2}}`\n  * Print only lines common to both files:\n`comm -12 {{file1}} {{file2}}`\n  * Print only lines common to both files, reading one file from `stdin`:\n`cat {{file1}} | comm -12 - {{file2}}`\n  * Get lines only found in first file, saving the result to a third file:\n`comm -23 {{file1}} {{file2}} > {{file1_only}}`\n  * Print lines only found in second file, when the files aren't sorted:\n`comm -13 <(sort {{file1}}) <(sort {{file2}})`"}
{"instruction": "What is iostat command", "input": "", "output": "# iostat\n> Report statistics for devices and partitions. More information:\n> https://manned.org/iostat.\n  * Display a report of CPU and disk statistics since system startup:\n`iostat`\n  * Display a report of CPU and disk statistics with units converted to megabytes:\n`iostat -m`\n  * Display CPU statistics:\n`iostat -c`\n  * Display disk statistics with disk names (including LVM):\n`iostat -N`\n  * Display extended disk statistics with disk names for device \"sda\":\n`iostat -xN {{sda}}`\n  * Display incremental reports of CPU and disk statistics every 2 seconds:\n`iostat {{2}}`"}
{"instruction": "What is pathchk command", "input": "", "output": "# pathchk\n> Check the validity and portability of one or more pathnames. More\n> information: https://www.gnu.org/software/coreutils/pathchk.\n  * Check pathnames for validity in the current system:\n`pathchk {{path1 path2 …}}`\n  * Check pathnames for validity on a wider range of POSIX compliant systems:\n`pathchk -p {{path1 path2 …}}`\n  * Check pathnames for validity on all POSIX compliant systems:\n`pathchk --portability {{path1 path2 …}}`\n  * Only check for empty pathnames or leading dashes (-):\n`pathchk -P {{path1 path2 …}}`"}
{"instruction": "What is git-tag command", "input": "", "output": "# git tag\n> Create, list, delete or verify tags. A tag is a static reference to a\n> specific commit. More information: https://git-scm.com/docs/git-tag.\n  * List all tags:\n`git tag`\n  * Create a tag with the given name pointing to the current commit:\n`git tag {{tag_name}}`\n  * Create a tag with the given name pointing to a given commit:\n`git tag {{tag_name}} {{commit}}`\n  * Create an annotated tag with the given message:\n`git tag {{tag_name}} -m {{tag_message}}`\n  * Delete the tag with the given name:\n`git tag -d {{tag_name}}`\n  * Get updated tags from upstream:\n`git fetch --tags`\n  * List all tags whose ancestors include a given commit:\n`git tag --contains {{commit}}`"}
{"instruction": "What is last command", "input": "", "output": "# last\n> View the last logged in users. More information: https://manned.org/last.\n  * View last logins, their duration and other information as read from `/var/log/wtmp`:\n`last`\n  * Specify how many of the last logins to show:\n`last -n {{login_count}}`\n  * Print the full date and time for entries and then display the hostname column last to prevent truncation:\n`last -F -a`\n  * View all logins by a specific user and show the IP address instead of the hostname:\n`last {{username}} -i`\n  * View all recorded reboots (i.e., the last logins of the pseudo user \"reboot\"):\n`last reboot`\n  * View all recorded shutdowns (i.e., the last logins of the pseudo user \"shutdown\"):\n`last shutdown`"}
{"instruction": "What is git-fetch command", "input": "", "output": "# git fetch\n> Download objects and refs from a remote repository. More information:\n> https://git-scm.com/docs/git-fetch.\n  * Fetch the latest changes from the default remote upstream repository (if set):\n`git fetch`\n  * Fetch new branches from a specific remote upstream repository:\n`git fetch {{remote_name}}`\n  * Fetch the latest changes from all remote upstream repositories:\n`git fetch --all`\n  * Also fetch tags from the remote upstream repository:\n`git fetch --tags`\n  * Delete local references to remote branches that have been deleted upstream:\n`git fetch --prune`"}
{"instruction": "What is xargs command", "input": "", "output": "# xargs\n> Execute a command with piped arguments coming from another command, a file,\n> etc. The input is treated as a single block of text and split into separate\n> pieces on spaces, tabs, newlines and end-of-file. More information:\n> https://pubs.opengroup.org/onlinepubs/9699919799/utilities/xargs.html.\n  * Run a command using the input data as arguments:\n`{{arguments_source}} | xargs {{command}}`\n  * Run multiple chained commands on the input data:\n`{{arguments_source}} | xargs sh -c \"{{command1}} && {{command2}} |\n{{command3}}\"`\n  * Delete all files with a `.backup` extension (`-print0` uses a null character to split file names, and `-0` uses it as delimiter):\n`find . -name {{'*.backup'}} -print0 | xargs -0 rm -v`\n  * Execute the command once for each input line, replacing any occurrences of the placeholder (here marked as `_`) with the input line:\n`{{arguments_source}} | xargs -I _ {{command}} _ {{optional_extra_arguments}}`\n  * Parallel runs of up to `max-procs` processes at a time; the default is 1. If `max-procs` is 0, xargs will run as many processes as possible at a time:\n`{{arguments_source}} | xargs -P {{max-procs}} {{command}}`"}
{"instruction": "What is jobs command", "input": "", "output": "# jobs\n> Display status of jobs in the current session. More information:\n> https://manned.org/jobs.\n  * Show status of all jobs:\n`jobs`\n  * Show status of a particular job:\n`jobs %{{job_id}}`\n  * Show status and process IDs of all jobs:\n`jobs -l`\n  * Show process IDs of all jobs:\n`jobs -p`"}
{"instruction": "What is objdump command", "input": "", "output": "# objdump\n> View information about object files. More information:\n> https://manned.org/objdump.\n  * Display the file header information:\n`objdump -f {{binary}}`\n  * Display the disassembled output of executable sections:\n`objdump -d {{binary}}`\n  * Display the disassembled executable sections in intel syntax:\n`objdump -M intel -d {{binary}}`\n  * Display a complete binary hex dump of all sections:\n`objdump -s {{binary}}`"}
{"instruction": "What is git-worktree command", "input": "", "output": "# git worktree\n> Manage multiple working trees attached to the same repository. More\n> information: https://git-scm.com/docs/git-worktree.\n  * Create a new directory with the specified branch checked out into it:\n`git worktree add {{path/to/directory}} {{branch}}`\n  * Create a new directory with a new branch checked out into it:\n`git worktree add {{path/to/directory}} -b {{new_branch}}`\n  * List all the working directories attached to this repository:\n`git worktree list`\n  * Remove a worktree (after deleting worktree directory):\n`git worktree prune`"}
{"instruction": "What is tee command", "input": "", "output": "# tee\n> Read from `stdin` and write to `stdout` and files (or commands). More\n> information: https://www.gnu.org/software/coreutils/tee.\n  * Copy `stdin` to each file, and also to `stdout`:\n`echo \"example\" | tee {{path/to/file}}`\n  * Append to the given files, do not overwrite:\n`echo \"example\" | tee -a {{path/to/file}}`\n  * Print `stdin` to the terminal, and also pipe it into another program for further processing:\n`echo \"example\" | tee {{/dev/tty}} | {{xargs printf \"[%s]\"}}`\n  * Create a directory called \"example\", count the number of characters in \"example\" and write \"example\" to the terminal:\n`echo \"example\" | tee >(xargs mkdir) >(wc -c)`"}
{"instruction": "What is git-cvsexportcommit command", "input": "", "output": "# git cvsexportcommit\n> Export a single `Git` commit to a CVS checkout. More information:\n> https://git-scm.com/docs/git-cvsexportcommit.\n  * Merge a specific patch into CVS:\n`git cvsexportcommit -v -c -w {{path/to/project_cvs_checkout}}\n{{commit_sha1}}`"}
{"instruction": "What is sdiff command", "input": "", "output": "# sdiff\n> Compare the differences between and optionally merge 2 files. More\n> information: https://manned.org/sdiff.\n  * Compare 2 files:\n`sdiff {{path/to/file1}} {{path/to/file2}}`\n  * Compare 2 files, ignoring all tabs and whitespace:\n`sdiff -W {{path/to/file1}} {{path/to/file2}}`\n  * Compare 2 files, ignoring whitespace at the end of lines:\n`sdiff -Z {{path/to/file1}} {{path/to/file2}}`\n  * Compare 2 files in a case-insensitive manner:\n`sdiff -i {{path/to/file1}} {{path/to/file2}}`\n  * Compare and then merge, writing the output to a new file:\n`sdiff -o {{path/to/merged_file}} {{path/to/file1}} {{path/to/file2}}`"}
{"instruction": "What is dir command", "input": "", "output": "# dir\n> List directory contents using one line per file, special characters are\n> represented by backslash escape sequences. Works as `ls -C --escape`. More\n> information: https://manned.org/dir.\n  * List all files, including hidden files:\n`dir -all`\n  * List files including their author (`-l` is required):\n`dir -l --author`\n  * List files excluding those that match a specified blob pattern:\n`dir --hide={{pattern}}`\n  * List subdirectories recursively:\n`dir --recursive`\n  * Display help:\n`dir --help`"}
{"instruction": "What is cd command", "input": "", "output": "# cd\n> Change the current working directory. More information:\n> https://manned.org/cd.\n  * Go to the specified directory:\n`cd {{path/to/directory}}`\n  * Go up to the parent of the current directory:\n`cd ..`\n  * Go to the home directory of the current user:\n`cd`\n  * Go to the home directory of the specified user:\n`cd ~{{username}}`\n  * Go to the previously chosen directory:\n`cd -`\n  * Go to the root directory:\n`cd /`"}
{"instruction": "What is git-revert command", "input": "", "output": "# git revert\n> Create new commits which reverse the effect of earlier ones. More\n> information: https://git-scm.com/docs/git-revert.\n  * Revert the most recent commit:\n`git revert {{HEAD}}`\n  * Revert the 5th last commit:\n`git revert HEAD~{{4}}`\n  * Revert a specific commit:\n`git revert {{0c01a9}}`\n  * Revert multiple commits:\n`git revert {{branch_name~5..branch_name~2}}`\n  * Don't create new commits, just change the working tree:\n`git revert -n {{0c01a9..9a1743}}`"}
{"instruction": "What is pathchk command", "input": "", "output": "# pathchk\n> Check the validity and portability of one or more pathnames. More\n> information: https://www.gnu.org/software/coreutils/pathchk.\n  * Check pathnames for validity in the current system:\n`pathchk {{path1 path2 …}}`\n  * Check pathnames for validity on a wider range of POSIX compliant systems:\n`pathchk -p {{path1 path2 …}}`\n  * Check pathnames for validity on all POSIX compliant systems:\n`pathchk --portability {{path1 path2 …}}`\n  * Only check for empty pathnames or leading dashes (-):\n`pathchk -P {{path1 path2 …}}`"}
{"instruction": "What is man command", "input": "", "output": "# man\n> Format and display manual pages. More information:\n> https://www.man7.org/linux/man-pages/man1/man.1.html.\n  * Display the man page for a command:\n`man {{command}}`\n  * Display the man page for a command from section 7:\n`man {{7}} {{command}}`\n  * List all available sections for a command:\n`man -f {{command}}`\n  * Display the path searched for manpages:\n`man --path`\n  * Display the location of a manpage rather than the manpage itself:\n`man -w {{command}}`\n  * Display the man page using a specific locale:\n`man {{command}} --locale={{locale}}`\n  * Search for manpages containing a search string:\n`man -k \"{{search_string}}\"`"}
{"instruction": "What is ps command", "input": "", "output": "# ps\n> Information about running processes. More information:\n> https://www.unix.com/man-page/osx/1/ps/.\n  * List all running processes:\n`ps aux`\n  * List all running processes including the full command string:\n`ps auxww`\n  * Search for a process that matches a string:\n`ps aux | grep {{string}}`\n  * Get the parent PID of a process:\n`ps -o ppid= -p {{pid}}`\n  * Sort processes by memory usage:\n`ps -m`\n  * Sort processes by CPU usage:\n`ps -r`"}
{"instruction": "What is git-ls-tree command", "input": "", "output": "# git ls-tree\n> List the contents of a tree object. More information: https://git-\n> scm.com/docs/git-ls-tree.\n  * List the contents of the tree on a branch:\n`git ls-tree {{branch_name}}`\n  * List the contents of the tree on a commit, recursing into subtrees:\n`git ls-tree -r {{commit_hash}}`\n  * List only the filenames of the tree on a commit:\n`git ls-tree --name-only {{commit_hash}}`"}
{"instruction": "What is ssh command", "input": "", "output": "# ssh\n> Secure Shell is a protocol used to securely log onto remote systems. It can\n> be used for logging or executing commands on a remote server. More\n> information: https://man.openbsd.org/ssh.\n  * Connect to a remote server:\n`ssh {{username}}@{{remote_host}}`\n  * Connect to a remote server with a specific identity (private key):\n`ssh -i {{path/to/key_file}} {{username}}@{{remote_host}}`\n  * Connect to a remote server using a specific port:\n`ssh {{username}}@{{remote_host}} -p {{2222}}`\n  * Run a command on a remote server with a [t]ty allocation allowing interaction with the remote command:\n`ssh {{username}}@{{remote_host}} -t {{command}} {{command_arguments}}`\n  * SSH tunneling: Dynamic port forwarding (SOCKS proxy on `localhost:1080`):\n`ssh -D {{1080}} {{username}}@{{remote_host}}`\n  * SSH tunneling: Forward a specific port (`localhost:9999` to `example.org:80`) along with disabling pseudo-[T]ty allocation and executio[N] of remote commands:\n`ssh -L {{9999}}:{{example.org}}:{{80}} -N -T {{username}}@{{remote_host}}`\n  * SSH jumping: Connect through a jumphost to a remote server (Multiple jump hops may be specified separated by comma characters):\n`ssh -J {{username}}@{{jump_host}} {{username}}@{{remote_host}}`\n  * Agent forwarding: Forward the authentication information to the remote machine (see `man ssh_config` for available options):\n`ssh -A {{username}}@{{remote_host}}`"}
{"instruction": "What is set command", "input": "", "output": "# set\n> Display, set or unset values of shell attributes and positional parameters.\n> More information: https://manned.org/set.\n  * Display the names and values of shell variables:\n`set`\n  * Mark variables that are modified or created for export:\n`set -a`\n  * Notify of job termination immediately:\n`set -b`\n  * Set various options, e.g. enable `vi` style line editing:\n`set -o {{vi}}`\n  * Set the shell to exit as soon as the first error is encountered (mostly used in scripts):\n`set -e`"}
{"instruction": "What is cut command", "input": "", "output": "# cut\n> Cut out fields from `stdin` or files. More information:\n> https://manned.org/man/freebsd-13.0/cut.1.\n  * Print a specific character/field range of each line:\n`{{command}} | cut -{{c|f}} {{1|1,10|1-10|1-|-10}}`\n  * Print a range of each line with a specific delimiter:\n`{{command}} | cut -d \"{{,}}\" -{{c}} {{1}}`\n  * Print a range of each line of a specific file:\n`cut -{{c}} {{1}} {{path/to/file}}`"}
{"instruction": "What is chfn command", "input": "", "output": "# chfn\n> Update `finger` info for a user. More information: https://manned.org/chfn.\n  * Update a user's \"Name\" field in the output of `finger`:\n`chfn -f {{new_display_name}} {{username}}`\n  * Update a user's \"Office Room Number\" field for the output of `finger`:\n`chfn -o {{new_office_room_number}} {{username}}`\n  * Update a user's \"Office Phone Number\" field for the output of `finger`:\n`chfn -p {{new_office_telephone_number}} {{username}}`\n  * Update a user's \"Home Phone Number\" field for the output of `finger`:\n`chfn -h {{new_home_telephone_number}} {{username}}`"}
{"instruction": "What is taskset command", "input": "", "output": "# taskset\n> Get or set a process' CPU affinity or start a new process with a defined CPU\n> affinity. More information: https://manned.org/taskset.\n  * Get a running process' CPU affinity by PID:\n`taskset --pid --cpu-list {{pid}}`\n  * Set a running process' CPU affinity by PID:\n`taskset --pid --cpu-list {{cpu_id}} {{pid}}`\n  * Start a new process with affinity for a single CPU:\n`taskset --cpu-list {{cpu_id}} {{command}}`\n  * Start a new process with affinity for multiple non-sequential CPUs:\n`taskset --cpu-list {{cpu_id_1}},{{cpu_id_2}},{{cpu_id_3}}`\n  * Start a new process with affinity for CPUs 1 through 4:\n`taskset --cpu-list {{cpu_id_1}}-{{cpu_id_4}}`"}
{"instruction": "What is script command", "input": "", "output": "# script\n> Make a typescript file of a terminal session. More information:\n> https://manned.org/script.\n  * Start recording in file named \"typescript\":\n`script`\n  * Stop recording:\n`exit`\n  * Start recording in a given file:\n`script {{logfile.log}}`\n  * Append to an existing file:\n`script -a {{logfile.log}}`\n  * Execute quietly without start and done messages:\n`script -q {{logfile.log}}`"}
{"instruction": "What is chown command", "input": "", "output": "# chown\n> Change user and group ownership of files and directories. More information:\n> https://www.gnu.org/software/coreutils/chown.\n  * Change the owner user of a file/directory:\n`chown {{user}} {{path/to/file_or_directory}}`\n  * Change the owner user and group of a file/directory:\n`chown {{user}}:{{group}} {{path/to/file_or_directory}}`\n  * Recursively change the owner of a directory and its contents:\n`chown -R {{user}} {{path/to/directory}}`\n  * Change the owner of a symbolic link:\n`chown -h {{user}} {{path/to/symlink}}`\n  * Change the owner of a file/directory to match a reference file:\n`chown --reference={{path/to/reference_file}} {{path/to/file_or_directory}}`"}
{"instruction": "What is g++ command", "input": "", "output": "# g++\n> Compiles C++ source files. Part of GCC (GNU Compiler Collection). More\n> information: https://gcc.gnu.org.\n  * Compile a source code file into an executable binary:\n`g++ {{path/to/source.cpp}} -o {{path/to/output_executable}}`\n  * Display common warnings:\n`g++ {{path/to/source.cpp}} -Wall -o {{path/to/output_executable}}`\n  * Choose a language standard to compile for (C++98/C++11/C++14/C++17):\n`g++ {{path/to/source.cpp}} -std={{c++98|c++11|c++14|c++17}} -o\n{{path/to/output_executable}}`\n  * Include libraries located at a different path than the source file:\n`g++ {{path/to/source.cpp}} -o {{path/to/output_executable}}\n-I{{path/to/header}} -L{{path/to/library}} -l{{library_name}}`\n  * Compile and link multiple source code files into an executable binary:\n`g++ -c {{path/to/source_1.cpp path/to/source_2.cpp ...}} && g++ -o\n{{path/to/output_executable}} {{path/to/source_1.o path/to/source_2.o ...}}`\n  * Display version:\n`g++ --version`"}
{"instruction": "What is cp command", "input": "", "output": "# cp\n> Copy files and directories. More information:\n> https://www.gnu.org/software/coreutils/cp.\n  * Copy a file to another location:\n`cp {{path/to/source_file.ext}} {{path/to/target_file.ext}}`\n  * Copy a file into another directory, keeping the filename:\n`cp {{path/to/source_file.ext}} {{path/to/target_parent_directory}}`\n  * Recursively copy a directory's contents to another location (if the destination exists, the directory is copied inside it):\n`cp -R {{path/to/source_directory}} {{path/to/target_directory}}`\n  * Copy a directory recursively, in verbose mode (shows files as they are copied):\n`cp -vR {{path/to/source_directory}} {{path/to/target_directory}}`\n  * Copy multiple files at once to a directory:\n`cp -t {{path/to/destination_directory}} {{path/to/file1 path/to/file2 ...}}`\n  * Copy text files to another location, in interactive mode (prompts user before overwriting):\n`cp -i {{*.txt}} {{path/to/target_directory}}`\n  * Follow symbolic links before copying:\n`cp -L {{link}} {{path/to/target_directory}}`\n  * Use the first argument as the destination directory (useful for `xargs ... | cp -t <DEST_DIR>`):\n`cp -t {{path/to/target_directory}} {{path/to/file_or_directory1\npath/to/file_or_directory2 ...}}`"}
{"instruction": "What is sar command", "input": "", "output": "# sar\n> Monitor performance of various Linux subsystems. More information:\n> https://manned.org/sar.\n  * Report I/O and transfer rate issued to physical devices, one per second (press CTRL+C to quit):\n`sar -b {{1}}`\n  * Report a total of 10 network device statistics, one per 2 seconds:\n`sar -n DEV {{2}} {{10}}`\n  * Report CPU utilization, one per 2 seconds:\n`sar -u ALL {{2}}`\n  * Report a total of 20 memory utilization statistics, one per second:\n`sar -r ALL {{1}} {{20}}`\n  * Report the run queue length and load averages, one per second:\n`sar -q {{1}}`\n  * Report paging statistics, one per 5 seconds:\n`sar -B {{5}}`"}
{"instruction": "What is rename command", "input": "", "output": "# rename\n> Rename a file or group of files with a regular expression. More information:\n> https://www.manpagez.com/man/2/rename/.\n  * Replace `from` with `to` in the filenames of the specified files:\n`rename 's/{{from}}/{{to}}/' {{*.txt}}`"}
{"instruction": "What is strip command", "input": "", "output": "# strip\n> Discard symbols from executables or object files. More information:\n> https://manned.org/strip.\n  * Replace the input file with its stripped version:\n`strip {{path/to/file}}`\n  * Strip symbols from a file, saving the output to a specific file:\n`strip {{path/to/input_file}} -o {{path/to/output_file}}`\n  * Strip debug symbols only:\n`strip --strip-debug {{path/to/file.o}}`"}
{"instruction": "What is head command", "input": "", "output": "# head\n> Output the first part of files. More information:\n> https://keith.github.io/xcode-man-pages/head.1.html.\n  * Output the first few lines of a file:\n`head --lines {{8}} {{path/to/file}}`\n  * Output the first few bytes of a file:\n`head --bytes {{8}} {{path/to/file}}`\n  * Output everything but the last few lines of a file:\n`head --lines -{{8}} {{path/to/file}}`\n  * Output everything but the last few bytes of a file:\n`head --bytes -{{8}} {{path/to/file}}`"}
{"instruction": "What is wall command", "input": "", "output": "# wall\n> Write a message on the terminals of users currently logged in. More\n> information: https://manned.org/wall.\n  * Send a message:\n`wall {{message}}`\n  * Send a message to users that belong to a specific group:\n`wall --group {{group_name}} {{message}}`\n  * Send a message from a file:\n`wall {{file}}`\n  * Send a message with timeout (default 300):\n`wall --timeout {{seconds}} {{file}}`"}
{"instruction": "What is stat command", "input": "", "output": "# stat\n> Display file status. More information: https://ss64.com/osx/stat.html.\n  * Show file properties such as size, permissions, creation and access dates among others:\n`stat {{path/to/file}}`\n  * Same as above but verbose (more similar to Linux's `stat`):\n`stat -x {{path/to/file}}`\n  * Show only octal file permissions:\n`stat -f %Mp%Lp {{path/to/file}}`\n  * Show owner and group of the file:\n`stat -f \"%Su %Sg\" {{path/to/file}}`\n  * Show the size of the file in bytes:\n`stat -f \"%z %N\" {{path/to/file}}`"}
{"instruction": "What is ar command", "input": "", "output": "# ar\n> Create, modify, and extract from Unix archives. Typically used for static\n> libraries (`.a`) and Debian packages (`.deb`). See also: `tar`. More\n> information: https://manned.org/ar.\n  * E[x]tract all members from an archive:\n`ar x {{path/to/file.a}}`\n  * Lis[t] contents in a specific archive:\n`ar t {{path/to/file.ar}}`\n  * [r]eplace or add specific files to an archive:\n`ar r {{path/to/file.deb}} {{path/to/debian-binary path/to/control.tar.gz\npath/to/data.tar.xz ...}}`\n  * In[s]ert an object file index (equivalent to using `ranlib`):\n`ar s {{path/to/file.a}}`\n  * Create an archive with specific files and an accompanying object file index:\n`ar rs {{path/to/file.a}} {{path/to/file1.o path/to/file2.o ...}}`"}
{"instruction": "What is git command", "input": "", "output": "# git\n> Distributed version control system. Some subcommands such as `commit`,\n> `add`, `branch`, `checkout`, `push`, etc. have their own usage\n> documentation, accessible via `tldr git subcommand`. More information:\n> https://git-scm.com/.\n  * Check the Git version:\n`git --version`\n  * Show general help:\n`git --help`\n  * Show help on a Git subcommand (like `clone`, `add`, `push`, `log`, etc.):\n`git help {{subcommand}}`\n  * Execute a Git subcommand:\n`git {{subcommand}}`\n  * Execute a Git subcommand on a custom repository root path:\n`git -C {{path/to/repo}} {{subcommand}}`\n  * Execute a Git subcommand with a given configuration set:\n`git -c '{{config.key}}={{value}}' {{subcommand}}`"}
{"instruction": "What is printenv command", "input": "", "output": "# printenv\n> Print values of all or specific environment variables. More information:\n> https://www.gnu.org/software/coreutils/printenv.\n  * Display key-value pairs of all environment variables:\n`printenv`\n  * Display the value of a specific variable:\n`printenv {{HOME}}`\n  * Display the value of a variable and end with NUL instead of newline:\n`printenv --null {{HOME}}`"}
{"instruction": "What is chsh command", "input": "", "output": "# chsh\n> Change user's login shell. More information: https://manned.org/chsh.\n  * Set a specific login shell for the current user interactively:\n`chsh`\n  * Set a specific login [s]hell for the current user:\n`chsh -s {{path/to/shell}}`\n  * Set a login [s]hell for a specific user:\n`chsh -s {{path/to/shell}} {{username}}`\n  * [l]ist available shells:\n`chsh -l`"}
{"instruction": "What is pax command", "input": "", "output": "# pax\n> Archiving and copying utility. More information: https://manned.org/pax.1p.\n  * List the contents of an archive:\n`pax -f {{archive.tar}}`\n  * List the contents of a gzipped archive:\n`pax -zf {{archive.tar.gz}}`\n  * Create an archive from files:\n`pax -wf {{target.tar}} {{path/to/file1}} {{path/to/file2}} {{path/to/file3}}`\n  * Create an archive from files, using output redirection:\n`pax -w {{path/to/file1}} {{path/to/file2}} {{path/to/file3}} >\n{{target.tar}}`\n  * Extract an archive into the current directory:\n`pax -rf {{source.tar}}`\n  * Copy to a directory, while keeping the original metadata; `target/` must exist:\n`pax -rw {{path/to/file1}} {{path/to/directory1}} {{path/to/directory2}}\n{{target/}}`"}
{"instruction": "What is git-replace command", "input": "", "output": "# git replace\n> Create, list, and delete refs to replace objects. More information:\n> https://git-scm.com/docs/git-replace.\n  * Replace any commit with a different one, leaving other commits unchanged:\n`git replace {{object}} {{replacement}}`\n  * Delete existing replace refs for the given objects:\n`git replace --delete {{object}}`\n  * Edit an object’s content interactively:\n`git replace --edit {{object}}`"}
{"instruction": "What is yes command", "input": "", "output": "# yes\n> Output something repeatedly. This command is commonly used to answer yes to\n> every prompt by install commands (such as apt-get). More information:\n> https://www.gnu.org/software/coreutils/yes.\n  * Repeatedly output \"message\":\n`yes {{message}}`\n  * Repeatedly output \"y\":\n`yes`\n  * Accept everything prompted by the `apt-get` command:\n`yes | sudo apt-get install {{program}}`"}
{"instruction": "What is mkdir command", "input": "", "output": "# mkdir\n> Create directories and set their permissions. More information:\n> https://www.gnu.org/software/coreutils/mkdir.\n  * Create specific directories:\n`mkdir {{path/to/directory1 path/to/directory2 ...}}`\n  * Create specific directories and their [p]arents if needed:\n`mkdir -p {{path/to/directory1 path/to/directory2 ...}}`\n  * Create directories with specific permissions:\n`mkdir -m {{rwxrw-r--}} {{path/to/directory1 path/to/directory2 ...}}`"}
{"instruction": "What is ipcrm command", "input": "", "output": "# ipcrm\n> Delete IPC (Inter-process Communication) resources. More information:\n> https://manned.org/ipcrm.\n  * Delete a shared memory segment by ID:\n`ipcrm --shmem-id {{shmem_id}}`\n  * Delete a shared memory segment by key:\n`ipcrm --shmem-key {{shmem_key}}`\n  * Delete an IPC queue by ID:\n`ipcrm --queue-id {{ipc_queue_id}}`\n  * Delete an IPC queue by key:\n`ipcrm --queue-key {{ipc_queue_key}}`\n  * Delete a semaphore by ID:\n`ipcrm --semaphore-id {{semaphore_id}}`\n  * Delete a semaphore by key:\n`ipcrm --semaphore-key {{semaphore_key}}`\n  * Delete all IPC resources:\n`ipcrm --all`"}
{"instruction": "What is chmod command", "input": "", "output": "# chmod\n> Change the access permissions of a file or directory. More information:\n> https://www.gnu.org/software/coreutils/chmod.\n  * Give the [u]ser who owns a file the right to e[x]ecute it:\n`chmod u+x {{path/to/file}}`\n  * Give the [u]ser rights to [r]ead and [w]rite to a file/directory:\n`chmod u+rw {{path/to/file_or_directory}}`\n  * Remove e[x]ecutable rights from the [g]roup:\n`chmod g-x {{path/to/file}}`\n  * Give [a]ll users rights to [r]ead and e[x]ecute:\n`chmod a+rx {{path/to/file}}`\n  * Give [o]thers (not in the file owner's group) the same rights as the [g]roup:\n`chmod o=g {{path/to/file}}`\n  * Remove all rights from [o]thers:\n`chmod o= {{path/to/file}}`\n  * Change permissions recursively giving [g]roup and [o]thers the ability to [w]rite:\n`chmod -R g+w,o+w {{path/to/directory}}`\n  * Recursively give [a]ll users [r]ead permissions to files and e[X]ecute permissions to sub-directories within a directory:\n`chmod -R a+rX {{path/to/directory}}`"}
{"instruction": "What is git-help command", "input": "", "output": "# git help\n> Display help information about Git. More information: https://git-\n> scm.com/docs/git-help.\n  * Display help about a specific Git subcommand:\n`git help {{subcommand}}`\n  * Display help about a specific Git subcommand in a web browser:\n`git help --web {{subcommand}}`\n  * Display a list of all available Git subcommands:\n`git help --all`\n  * List the available guides:\n`git help --guide`\n  * List all possible configuration variables:\n`git help --config`"}
{"instruction": "What is sort command", "input": "", "output": "# sort\n> Sort lines of text files. More information:\n> https://www.gnu.org/software/coreutils/sort.\n  * Sort a file in ascending order:\n`sort {{path/to/file}}`\n  * Sort a file in descending order:\n`sort --reverse {{path/to/file}}`\n  * Sort a file in case-insensitive way:\n`sort --ignore-case {{path/to/file}}`\n  * Sort a file using numeric rather than alphabetic order:\n`sort --numeric-sort {{path/to/file}}`\n  * Sort `/etc/passwd` by the 3rd field of each line numerically, using \":\" as a field separator:\n`sort --field-separator={{:}} --key={{3n}} {{/etc/passwd}}`\n  * Sort a file preserving only unique lines:\n`sort --unique {{path/to/file}}`\n  * Sort a file, printing the output to the specified output file (can be used to sort a file in-place):\n`sort --output={{path/to/file}} {{path/to/file}}`\n  * Sort numbers with exponents:\n`sort --general-numeric-sort {{path/to/file}}`"}
{"instruction": "What is md5sum command", "input": "", "output": "# md5sum\n> Calculate MD5 cryptographic checksums. More information:\n> https://www.gnu.org/software/coreutils/md5sum.\n  * Calculate the MD5 checksum for one or more files:\n`md5sum {{path/to/file1 path/to/file2 ...}}`\n  * Calculate and save the list of MD5 checksums to a file:\n`md5sum {{path/to/file1 path/to/file2 ...}} > {{path/to/file.md5}}`\n  * Calculate an MD5 checksum from `stdin`:\n`{{command}} | md5sum`\n  * Read a file of MD5 sums and filenames and verify all files have matching checksums:\n`md5sum --check {{path/to/file.md5}}`\n  * Only show a message for missing files or when verification fails:\n`md5sum --check --quiet {{path/to/file.md5}}`\n  * Only show a message when verification fails, ignoring missing files:\n`md5sum --ignore-missing --check --quiet {{path/to/file.md5}}`"}
{"instruction": "What is kill command", "input": "", "output": "# kill\n> Sends a signal to a process, usually related to stopping the process. All\n> signals except for SIGKILL and SIGSTOP can be intercepted by the process to\n> perform a clean exit. More information: https://manned.org/kill.\n  * Terminate a program using the default SIGTERM (terminate) signal:\n`kill {{process_id}}`\n  * List available signal names (to be used without the `SIG` prefix):\n`kill -l`\n  * Terminate a background job:\n`kill %{{job_id}}`\n  * Terminate a program using the SIGHUP (hang up) signal. Many daemons will reload instead of terminating:\n`kill -{{1|HUP}} {{process_id}}`\n  * Terminate a program using the SIGINT (interrupt) signal. This is typically initiated by the user pressing `Ctrl + C`:\n`kill -{{2|INT}} {{process_id}}`\n  * Signal the operating system to immediately terminate a program (which gets no chance to capture the signal):\n`kill -{{9|KILL}} {{process_id}}`\n  * Signal the operating system to pause a program until a SIGCONT (\"continue\") signal is received:\n`kill -{{17|STOP}} {{process_id}}`\n  * Send a `SIGUSR1` signal to all processes with the given GID (group id):\n`kill -{{SIGUSR1}} -{{group_id}}`"}
{"instruction": "What is groff command", "input": "", "output": "# groff\n> GNU replacement for the `troff` and `nroff` typesetting utilities. More\n> information: https://www.gnu.org/software/groff.\n  * Format output for a PostScript printer, saving the output to a file:\n`groff {{path/to/input.roff}} > {{path/to/output.ps}}`\n  * Render a man page using the ASCII output device, and display it using a pager:\n`groff -man -T ascii {{path/to/manpage.1}} | less --RAW-CONTROL-CHARS`\n  * Render a man page into an HTML file:\n`groff -man -T html {{path/to/manpage.1}} > {{path/to/manpage.html}}`\n  * Typeset a roff file containing [t]ables and [p]ictures, using the [me] macro set, to PDF, saving the output:\n`groff {{-t}} {{-p}} -{{me}} -T {{pdf}} {{path/to/input.me}} >\n{{path/to/output.pdf}}`\n  * Run a `groff` command with preprocessor and macro options guessed by the `grog` utility:\n`eval \"$(grog -T utf8 {{path/to/input.me}})\"`"}
{"instruction": "What is git-checkout-index command", "input": "", "output": "# git checkout-index\n> Copy files from the index to the working tree. More information:\n> https://git-scm.com/docs/git-checkout-index.\n  * Restore any files deleted since the last commit:\n`git checkout-index --all`\n  * Restore any files deleted or changed since the last commit:\n`git checkout-index --all --force`\n  * Restore any files changed since the last commit, ignoring any files that were deleted:\n`git checkout-index --all --force --no-create`\n  * Export a copy of the entire tree at the last commit to the specified directory (the trailing slash is important):\n`git checkout-index --all --force --prefix={{path/to/export_directory/}}`"}
{"instruction": "What is trace-cmd command", "input": "", "output": "# trace-cmd\n> Utility to interact with the Ftrace Linux kernel internal tracer. This\n> utility only runs as root. More information: https://manned.org/trace-cmd.\n  * Display the status of tracing system:\n`trace-cmd stat`\n  * List available tracers:\n`trace-cmd list -t`\n  * Start tracing with a specific plugin:\n`trace-cmd start -p\n{{timerlat|osnoise|hwlat|blk|mmiotrace|function_graph|wakeup_dl|wakeup_rt|wakeup|function|nop}}`\n  * View the trace output:\n`trace-cmd show`\n  * Stop the tracing but retain the buffers:\n`trace-cmd stop`\n  * Clear the trace buffers:\n`trace-cmd clear`\n  * Clear the trace buffers and stop tracing:\n`trace-cmd reset`"}
{"instruction": "What is umask command", "input": "", "output": "# umask\n> Manage the read/write/execute permissions that are masked out (i.e.\n> restricted) for newly created files by the user. More information:\n> https://manned.org/umask.\n  * Display the current mask in octal notation:\n`umask`\n  * Display the current mask in symbolic (human-readable) mode:\n`umask -S`\n  * Change the mask symbolically to allow read permission for all users (the rest of the mask bits are unchanged):\n`umask {{a+r}}`\n  * Set the mask (using octal) to restrict no permissions for the file's owner, and restrict all permissions for everyone else:\n`umask {{077}}`"}
{"instruction": "What is touch command", "input": "", "output": "# touch\n> Create files and set access/modification times. More information:\n> https://manned.org/man/freebsd-13.1/touch.\n  * Create specific files:\n`touch {{path/to/file1 path/to/file2 ...}}`\n  * Set the file [a]ccess or [m]odification times to the current one and don't [c]reate file if it doesn't exist:\n`touch -c -{{a|m}} {{path/to/file1 path/to/file2 ...}}`\n  * Set the file [t]ime to a specific value and don't [c]reate file if it doesn't exist:\n`touch -c -t {{YYYYMMDDHHMM.SS}} {{path/to/file1 path/to/file2 ...}}`\n  * Set the file time of a specific file to the time of anothe[r] file and don't [c]reate file if it doesn't exist:\n`touch -c -r {{~/.emacs}} {{path/to/file1 path/to/file2 ...}}`"}
{"instruction": "What is echo command", "input": "", "output": "# echo\n> Print given arguments. More information:\n> https://www.gnu.org/software/coreutils/echo.\n  * Print a text message. Note: quotes are optional:\n`echo \"{{Hello World}}\"`\n  * Print a message with environment variables:\n`echo \"{{My path is $PATH}}\"`\n  * Print a message without the trailing newline:\n`echo -n \"{{Hello World}}\"`\n  * Append a message to the file:\n`echo \"{{Hello World}}\" >> {{file.txt}}`\n  * Enable interpretation of backslash escapes (special characters):\n`echo -e \"{{Column 1\\tColumn 2}}\"`\n  * Print the exit status of the last executed command (Note: In Windows Command Prompt and PowerShell the equivalent commands are `echo %errorlevel%` and `$lastexitcode` respectively):\n`echo $?`"}
{"instruction": "What is systemctl command", "input": "", "output": "# systemctl\n> Control the systemd system and service manager. More information:\n> https://www.freedesktop.org/software/systemd/man/systemctl.html.\n  * Show all running services:\n`systemctl status`\n  * List failed units:\n`systemctl --failed`\n  * Start/Stop/Restart/Reload a service:\n`systemctl {{start|stop|restart|reload}} {{unit}}`\n  * Show the status of a unit:\n`systemctl status {{unit}}`\n  * Enable/Disable a unit to be started on bootup:\n`systemctl {{enable|disable}} {{unit}}`\n  * Mask/Unmask a unit to prevent enablement and manual activation:\n`systemctl {{mask|unmask}} {{unit}}`\n  * Reload systemd, scanning for new or changed units:\n`systemctl daemon-reload`\n  * Check if a unit is enabled:\n`systemctl is-enabled {{unit}}`"}
{"instruction": "What is patch command", "input": "", "output": "# patch\n> Patch a file (or files) with a diff file. Note that diff files should be\n> generated by the `diff` command. More information: https://manned.org/patch.\n  * Apply a patch using a diff file (filenames must be included in the diff file):\n`patch < {{patch.diff}}`\n  * Apply a patch to a specific file:\n`patch {{path/to/file}} < {{patch.diff}}`\n  * Patch a file writing the result to a different file:\n`patch {{path/to/input_file}} -o {{path/to/output_file}} < {{patch.diff}}`\n  * Apply a patch to the current directory:\n`patch -p1 < {{patch.diff}}`\n  * Apply the reverse of a patch:\n`patch -R < {{patch.diff}}`"}
{"instruction": "What is find command", "input": "", "output": "# find\n> Find files or directories under the given directory tree, recursively. More\n> information: https://manned.org/find.\n  * Find files by extension:\n`find {{root_path}} -name '{{*.ext}}'`\n  * Find files matching multiple path/name patterns:\n`find {{root_path}} -path '{{**/path/**/*.ext}}' -or -name '{{*pattern*}}'`\n  * Find directories matching a given name, in case-insensitive mode:\n`find {{root_path}} -type d -iname '{{*lib*}}'`\n  * Find files matching a given pattern, excluding specific paths:\n`find {{root_path}} -name '{{*.py}}' -not -path '{{*/site-packages/*}}'`\n  * Find files matching a given size range, limiting the recursive depth to \"1\":\n`find {{root_path}} -maxdepth 1 -size {{+500k}} -size {{-10M}}`\n  * Run a command for each file (use `{}` within the command to access the filename):\n`find {{root_path}} -name '{{*.ext}}' -exec {{wc -l {} }}\\;`\n  * Find files modified in the last 7 days:\n`find {{root_path}} -daystart -mtime -{{7}}`\n  * Find empty (0 byte) files and delete them:\n`find {{root_path}} -type {{f}} -empty -delete`"}
{"instruction": "What is expect command", "input": "", "output": "# expect\n> Script executor that interacts with other programs that require user input.\n> More information: https://manned.org/expect.\n  * Execute an expect script from a file:\n`expect {{path/to/file}}`\n  * Execute a specified expect script:\n`expect -c \"{{commands}}\"`\n  * Enter an interactive REPL (use `exit` or Ctrl + D to exit):\n`expect -i`"}
{"instruction": "What is du command", "input": "", "output": "# du\n> Disk usage: estimate and summarize file and directory space usage. More\n> information: https://ss64.com/osx/du.html.\n  * List the sizes of a directory and any subdirectories, in the given unit (KiB/MiB/GiB):\n`du -{{k|m|g}} {{path/to/directory}}`\n  * List the sizes of a directory and any subdirectories, in human-readable form (i.e. auto-selecting the appropriate unit for each size):\n`du -h {{path/to/directory}}`\n  * Show the size of a single directory, in human-readable units:\n`du -sh {{path/to/directory}}`\n  * List the human-readable sizes of a directory and of all the files and directories within it:\n`du -ah {{path/to/directory}}`\n  * List the human-readable sizes of a directory and any subdirectories, up to N levels deep:\n`du -h -d {{2}} {{path/to/directory}}`\n  * List the human-readable size of all `.jpg` files in subdirectories of the current directory, and show a cumulative total at the end:\n`du -ch {{*/*.jpg}}`"}
{"instruction": "What is fold command", "input": "", "output": "# fold\n> Wrap each line in an input file to fit a specified width and print it to\n> `stdout`. More information: https://manned.org/fold.1p.\n  * Wrap each line to default width (80 characters):\n`fold {{path/to/file}}`\n  * Wrap each line to width \"30\":\n`fold -w30 {{path/to/file}}`\n  * Wrap each line to width \"5\" and break the line at spaces (puts each space separated word in a new line, words with length > 5 are wrapped):\n`fold -w5 -s {{path/to/file}}`"}
{"instruction": "What is nohup command", "input": "", "output": "# nohup\n> Allows for a process to live when the terminal gets killed. More\n> information: https://www.gnu.org/software/coreutils/nohup.\n  * Run a process that can live beyond the terminal:\n`nohup {{command}} {{argument1 argument2 ...}}`\n  * Launch `nohup` in background mode:\n`nohup {{command}} {{argument1 argument2 ...}} &`\n  * Run a shell script that can live beyond the terminal:\n`nohup {{path/to/script.sh}} &`\n  * Run a process and write the output to a specific file:\n`nohup {{command}} {{argument1 argument2 ...}} > {{path/to/output_file}} &`"}
{"instruction": "What is git-rm command", "input": "", "output": "# git rm\n> Remove files from repository index and local filesystem. More information:\n> https://git-scm.com/docs/git-rm.\n  * Remove file from repository index and filesystem:\n`git rm {{path/to/file}}`\n  * Remove directory:\n`git rm -r {{path/to/directory}}`\n  * Remove file from repository index but keep it untouched locally:\n`git rm --cached {{path/to/file}}`"}
{"instruction": "What is getconf command", "input": "", "output": "# getconf\n> Get configuration values from your Linux system. More information:\n> https://manned.org/getconf.1.\n  * List [a]ll configuration values available:\n`getconf -a`\n  * List the configuration values for a specific directory:\n`getconf -a {{path/to/directory}}`\n  * Check if your linux system is a 32-bit or 64-bit:\n`getconf LONG_BIT`\n  * Check how many processes the current user can run at once:\n`getconf CHILD_MAX`\n  * List every configuration value and then find patterns with the grep command (i.e every value with MAX in it):\n`getconf -a | grep MAX`"}
{"instruction": "What is wget command", "input": "", "output": "# wget\n> Download files from the Web. Supports HTTP, HTTPS, and FTP. More\n> information: https://www.gnu.org/software/wget.\n  * Download the contents of a URL to a file (named \"foo\" in this case):\n`wget {{https://example.com/foo}}`\n  * Download the contents of a URL to a file (named \"bar\" in this case):\n`wget --output-document {{bar}} {{https://example.com/foo}}`\n  * Download a single web page and all its resources with 3-second intervals between requests (scripts, stylesheets, images, etc.):\n`wget --page-requisites --convert-links --wait=3\n{{https://example.com/somepage.html}}`\n  * Download all listed files within a directory and its sub-directories (does not download embedded page elements):\n`wget --mirror --no-parent {{https://example.com/somepath/}}`\n  * Limit the download speed and the number of connection retries:\n`wget --limit-rate={{300k}} --tries={{100}} {{https://example.com/somepath/}}`\n  * Download a file from an HTTP server using Basic Auth (also works for FTP):\n`wget --user={{username}} --password={{password}} {{https://example.com}}`\n  * Continue an incomplete download:\n`wget --continue {{https://example.com}}`\n  * Download all URLs stored in a text file to a specific directory:\n`wget --directory-prefix {{path/to/directory}} --input-file {{URLs.txt}}`"}
{"instruction": "What is systemd-mount command", "input": "", "output": "# systemd-mount\n> Establish and destroy transient mount or auto-mount points. More\n> information: https://www.freedesktop.org/software/systemd/man/systemd-\n> mount.html.\n  * Mount a file system (image or block device) at `/run/media/system/LABEL` where LABEL is the filesystem label or the device name if there is no label:\n`systemd-mount {{path/to/file_or_device}}`\n  * Mount a file system (image or block device) at a specific location:\n`systemd-mount {{path/to/file_or_device}} {{path/to/mount_point}}`\n  * Show a list of all local, known block devices with file systems that may be mounted:\n`systemd-mount --list`\n  * Create an automount point that mounts the actual file system at the time of first access:\n`systemd-mount --automount=yes {{path/to/file_or_device}}`\n  * Unmount one or more devices:\n`systemd-mount --umount {{path/to/mount_point_or_device1}}\n{{path/to/mount_point_or_device2}}`\n  * Mount a file system (image or block device) with a specific file system type:\n`systemd-mount --type={{file_system_type}} {{path/to/file_or_device}}\n{{path/to/mount_point}}`\n  * Mount a file system (image or block device) with additional mount options:\n`systemd-mount --options={{mount_options}} {{path/to/file_or_device}}\n{{path/to/mount_point}}`"}
{"instruction": "What is date command", "input": "", "output": "# date\n> Set or display the system date. More information:\n> https://ss64.com/osx/date.html.\n  * Display the current date using the default locale's format:\n`date +%c`\n  * Display the current date in UTC and ISO 8601 format:\n`date -u +%Y-%m-%dT%H:%M:%SZ`\n  * Display the current date as a Unix timestamp (seconds since the Unix epoch):\n`date +%s`\n  * Display a specific date (represented as a Unix timestamp) using the default format:\n`date -r 1473305798`"}
{"instruction": "What is mcookie command", "input": "", "output": "# mcookie\n> Generates random 128-bit hexadecimal numbers. More information:\n> https://manned.org/mcookie.\n  * Generate a random number:\n`mcookie`\n  * Generate a random number, using the contents of a file as a seed for the randomness:\n`mcookie --file {{path/to/file}}`\n  * Generate a random number, using a specific number of bytes from a file as a seed for the randomness:\n`mcookie --file {{path/to/file}} --max-size {{number_of_bytes}}`\n  * Print the details of the randomness used, such as the origin and seed for each source:\n`mcookie --verbose`"}
{"instruction": "What is scriptreplay command", "input": "", "output": "# scriptreplay\n> Replay a typescript created by the `script` command to `stdout`. More\n> information: https://manned.org/scriptreplay.\n  * Replay a typescript at the speed it was recorded:\n`scriptreplay {{path/to/timing_file}} {{path/to/typescript}}`\n  * Replay a typescript at double the original speed:\n`scriptreplay {{path/to/timingfile}} {{path/to/typescript}} 2`\n  * Replay a typescript at half the original speed:\n`scriptreplay {{path/to/timingfile}} {{path/to/typescript}} 0.5`"}
{"instruction": "What is git-repack command", "input": "", "output": "# git repack\n> Pack unpacked objects in a Git repository. More information: https://git-\n> scm.com/docs/git-repack.\n  * Pack unpacked objects in the current directory:\n`git repack`\n  * Also remove redundant objects after packing:\n`git repack -d`"}
{"instruction": "What is rev command", "input": "", "output": "# rev\n> Reverse a line of text. More information: https://manned.org/rev.\n  * Reverse the text string \"hello\":\n`echo \"hello\" | rev`\n  * Reverse an entire file and print to `stdout`:\n`rev {{path/to/file}}`"}
{"instruction": "What is logname command", "input": "", "output": "# logname\n> Shows the user's login name. More information:\n> https://www.gnu.org/software/coreutils/logname.\n  * Display the currently logged in user's name:\n`logname`"}
{"instruction": "What is true command", "input": "", "output": "# true\n> Returns a successful exit status code of 0. Use this with the || operator to\n> make a command always exit with 0. More information:\n> https://www.gnu.org/software/coreutils/true.\n  * Return a successful exit code:\n`true`"}
{"instruction": "What is sed command", "input": "", "output": "# sed\n> Edit text in a scriptable manner. See also: `awk`, `ed`. More information:\n> https://keith.github.io/xcode-man-pages/sed.1.html.\n  * Replace all `apple` (basic regex) occurrences with `mango` (basic regex) in all input lines and print the result to `stdout`:\n`{{command}} | sed 's/apple/mango/g'`\n  * Execute a specific script [f]ile and print the result to `stdout`:\n`{{command}} | sed -f {{path/to/script_file.sed}}`\n  * Replace all `apple` (extended regex) occurrences with `APPLE` (extended regex) in all input lines and print the result to `stdout`:\n`{{command}} | sed -E 's/(apple)/\\U\\1/g'`\n  * Print just a first line to `stdout`:\n`{{command}} | sed -n '1p'`\n  * Replace all `apple` (basic regex) occurrences with `mango` (basic regex) in a `file` and save a backup of the original to `file.bak`:\n`sed -i bak 's/apple/mango/g' {{path/to/file}}`"}
{"instruction": "What is lsattr command", "input": "", "output": "# lsattr\n> List file attributes on a Linux filesystem. More information:\n> https://manned.org/lsattr.\n  * Display the attributes of the files in the current directory:\n`lsattr`\n  * List the attributes of files in a particular path:\n`lsattr {{path}}`\n  * List file attributes recursively in the current and subsequent directories:\n`lsattr -R`\n  * Show attributes of all the files in the current directory, including hidden ones:\n`lsattr -a`\n  * Display attributes of directories in the current directory:\n`lsattr -d`"}
{"instruction": "What is delta command", "input": "", "output": "# delta\n> A viewer for Git and diff output. More information:\n> https://github.com/dandavison/delta.\n  * Compare files or directories:\n`delta {{path/to/old_file_or_directory}} {{path/to/new_file_or_directory}}`\n  * Compare files or directories, showing the line numbers:\n`delta --line-numbers {{path/to/old_file_or_directory}}\n{{path/to/new_file_or_directory}}`\n  * Compare files or directories, showing the differences side by side:\n`delta --side-by-side {{path/to/old_file_or_directory}}\n{{path/to/new_file_or_directory}}`\n  * Compare files or directories, ignoring any Git configuration settings:\n`delta --no-gitconfig {{path/to/old_file_or_directory}}\n{{path/to/new_file_or_directory}}`\n  * Compare, rendering commit hashes, file names, and line numbers as hyperlinks, according to the hyperlink spec for terminal emulators:\n`delta --hyperlinks {{path/to/old_file_or_directory}}\n{{path/to/new_file_or_directory}}`\n  * Display the current settings:\n`delta --show-config`\n  * Display supported languages and associated file extensions:\n`delta --list-languages`"}
{"instruction": "What is git-submodule command", "input": "", "output": "# git submodule\n> Inspects, updates and manages submodules. More information: https://git-\n> scm.com/docs/git-submodule.\n  * Install a repository's specified submodules:\n`git submodule update --init --recursive`\n  * Add a Git repository as a submodule:\n`git submodule add {{repository_url}}`\n  * Add a Git repository as a submodule at the specified directory:\n`git submodule add {{repository_url}} {{path/to/directory}}`\n  * Update every submodule to its latest commit:\n`git submodule foreach git pull`"}
{"instruction": "What is git-send-email command", "input": "", "output": "# git send-email\n> Send a collection of patches as emails. Patches can be specified as files,\n> directions, or a revision list. More information: https://git-\n> scm.com/docs/git-send-email.\n  * Send the last commit in the current branch:\n`git send-email -1`\n  * Send a given commit:\n`git send-email -1 {{commit}}`\n  * Send multiple (e.g. 10) commits in the current branch:\n`git send-email {{-10}}`\n  * Send an introductory email message for the patch series:\n`git send-email -{{number_of_commits}} --compose`\n  * Review and edit the email message for each patch you're about to send:\n`git send-email -{{number_of_commits}} --annotate`"}
{"instruction": "What is git-checkout command", "input": "", "output": "# git checkout\n> Checkout a branch or paths to the working tree. More information:\n> https://git-scm.com/docs/git-checkout.\n  * Create and switch to a new branch:\n`git checkout -b {{branch_name}}`\n  * Create and switch to a new branch based on a specific reference (branch, remote/branch, tag are examples of valid references):\n`git checkout -b {{branch_name}} {{reference}}`\n  * Switch to an existing local branch:\n`git checkout {{branch_name}}`\n  * Switch to the previously checked out branch:\n`git checkout -`\n  * Switch to an existing remote branch:\n`git checkout --track {{remote_name}}/{{branch_name}}`\n  * Discard all unstaged changes in the current directory (see `git reset` for more undo-like commands):\n`git checkout .`\n  * Discard unstaged changes to a given file:\n`git checkout {{path/to/file}}`\n  * Replace a file in the current directory with the version of it committed in a given branch:\n`git checkout {{branch_name}} -- {{path/to/file}}`"}
{"instruction": "What is git-show-ref command", "input": "", "output": "# git show-ref\n> Git command for listing references. More information: https://git-\n> scm.com/docs/git-show-ref.\n  * Show all refs in the repository:\n`git show-ref`\n  * Show only heads references:\n`git show-ref --heads`\n  * Show only tags references:\n`git show-ref --tags`\n  * Verify that a given reference exists:\n`git show-ref --verify {{path/to/ref}}`"}
{"instruction": "What is tbl command", "input": "", "output": "# tbl\n> Table preprocessor for the groff (GNU Troff) document formatting system. See\n> also `groff` and `troff`. More information: https://manned.org/tbl.\n  * Process input with tables, saving the output for future typesetting with groff to PostScript:\n`tbl {{path/to/input_file}} > {{path/to/output.roff}}`\n  * Typeset input with tables to PDF using the [me] macro package:\n`tbl -T {{pdf}} {{path/to/input.tbl}} | groff -{{me}} -T {{pdf}} >\n{{path/to/output.pdf}}`"}
{"instruction": "What is fg command", "input": "", "output": "# fg\n> Run jobs in foreground. More information: https://manned.org/fg.\n  * Bring most recently suspended or running background job to foreground:\n`fg`\n  * Bring a specific job to foreground:\n`fg %{{job_id}}`"}
{"instruction": "What is kill command", "input": "", "output": "# kill\n> Sends a signal to a process, usually related to stopping the process. All\n> signals except for SIGKILL and SIGSTOP can be intercepted by the process to\n> perform a clean exit. More information: https://manned.org/kill.\n  * Terminate a program using the default SIGTERM (terminate) signal:\n`kill {{process_id}}`\n  * List available signal names (to be used without the `SIG` prefix):\n`kill -l`\n  * Terminate a background job:\n`kill %{{job_id}}`\n  * Terminate a program using the SIGHUP (hang up) signal. Many daemons will reload instead of terminating:\n`kill -{{1|HUP}} {{process_id}}`\n  * Terminate a program using the SIGINT (interrupt) signal. This is typically initiated by the user pressing `Ctrl + C`:\n`kill -{{2|INT}} {{process_id}}`\n  * Signal the operating system to immediately terminate a program (which gets no chance to capture the signal):\n`kill -{{9|KILL}} {{process_id}}`\n  * Signal the operating system to pause a program until a SIGCONT (\"continue\") signal is received:\n`kill -{{17|STOP}} {{process_id}}`\n  * Send a `SIGUSR1` signal to all processes with the given GID (group id):\n`kill -{{SIGUSR1}} -{{group_id}}`"}
{"instruction": "What is git-credential command", "input": "", "output": "# git credential\n> Retrieve and store user credentials. More information: https://git-\n> scm.com/docs/git-credential.\n  * Display credential information, retrieving the username and password from configuration files:\n`echo \"{{url=http://example.com}}\" | git credential fill`\n  * Send credential information to all configured credential helpers to store for later use:\n`echo \"{{url=http://example.com}}\" | git credential approve`\n  * Erase the specified credential information from all the configured credential helpers:\n`echo \"{{url=http://example.com}}\" | git credential reject`"}
{"instruction": "What is git-stripspace command", "input": "", "output": "# git stripspace\n> Read text (e.g. commit messages, notes, tags, and branch descriptions) from\n> `stdin` and clean it into the manner used by Git. More information:\n> https://git-scm.com/docs/git-stripspace.\n  * Trim whitespace from a file:\n`cat {{path/to/file}} | git stripspace`\n  * Trim whitespace and Git comments from a file:\n`cat {{path/to/file}} | git stripspace --strip-comments`\n  * Convert all lines in a file into Git comments:\n`git stripspace --comment-lines < {{path/to/file}}`"}
{"instruction": "What is hostname command", "input": "", "output": "# hostname\n> Show or set the system's host name. More information:\n> https://manned.org/hostname.\n  * Show current host name:\n`hostname`\n  * Show the network address of the host name:\n`hostname -i`\n  * Show all network addresses of the host:\n`hostname -I`\n  * Show the FQDN (Fully Qualified Domain Name):\n`hostname --fqdn`\n  * Set current host name:\n`hostname {{new_hostname}}`"}
{"instruction": "What is fuser command", "input": "", "output": "# fuser\n> Display process IDs currently using files or sockets. More information:\n> https://manned.org/fuser.\n  * Find which processes are accessing a file or directory:\n`fuser {{path/to/file_or_directory}}`\n  * Show more fields (`USER`, `PID`, `ACCESS` and `COMMAND`):\n`fuser --verbose {{path/to/file_or_directory}}`\n  * Identify processes using a TCP socket:\n`fuser --namespace tcp {{port}}`\n  * Kill all processes accessing a file or directory (sends the `SIGKILL` signal):\n`fuser --kill {{path/to/file_or_directory}}`\n  * Find which processes are accessing the filesystem containing a specific file or directory:\n`fuser --mount {{path/to/file_or_directory}}`\n  * Kill all processes with a TCP connection on a specific port:\n`fuser --kill {{port}}/tcp`"}
{"instruction": "What is git-mergetool command", "input": "", "output": "# git mergetool\n> Run merge conflict resolution tools to resolve merge conflicts. More\n> information: https://git-scm.com/docs/git-mergetool.\n  * Launch the default merge tool to resolve conflicts:\n`git mergetool`\n  * List valid merge tools:\n`git mergetool --tool-help`\n  * Launch the merge tool identified by a name:\n`git mergetool --tool {{tool_name}}`\n  * Don't prompt before each invocation of the merge tool:\n`git mergetool --no-prompt`\n  * Explicitly use the GUI merge tool (see the `merge.guitool` config variable):\n`git mergetool --gui`\n  * Explicitly use the regular merge tool (see the `merge.tool` config variable):\n`git mergetool --no-gui`"}
{"instruction": "What is su command", "input": "", "output": "# su\n> Switch shell to another user. More information: https://manned.org/su.\n  * Switch to superuser (requires the root password):\n`su`\n  * Switch to a given user (requires the user's password):\n`su {{username}}`\n  * Switch to a given user and simulate a full login shell:\n`su - {{username}}`\n  * Execute a command as another user:\n`su - {{username}} -c \"{{command}}\"`"}
{"instruction": "What is git-request-pull command", "input": "", "output": "# git request-pull\n> Generate a request asking the upstream project to pull changes into its\n> tree. More information: https://git-scm.com/docs/git-request-pull.\n  * Produce a request summarizing the changes between the v1.1 release and a specified branch:\n`git request-pull {{v1.1}} {{https://example.com/project}} {{branch_name}}`\n  * Produce a request summarizing the changes between the v0.1 release on the `foo` branch and the local `bar` branch:\n`git request-pull {{v0.1}} {{https://example.com/project}} {{foo:bar}}`"}
{"instruction": "What is perf command", "input": "", "output": "# perf\n> Framework for Linux performance counter measurements. More information:\n> https://perf.wiki.kernel.org.\n  * Display basic performance counter stats for a command:\n`perf stat {{gcc hello.c}}`\n  * Display system-wide real-time performance counter profile:\n`sudo perf top`\n  * Run a command and record its profile into `perf.data`:\n`sudo perf record {{command}}`\n  * Record the profile of an existing process into `perf.data`:\n`sudo perf record -p {{pid}}`\n  * Read `perf.data` (created by `perf record`) and display the profile:\n`sudo perf report`"}
{"instruction": "What is chrt command", "input": "", "output": "# chrt\n> Manipulate the real-time attributes of a process. More information:\n> https://man7.org/linux/man-pages/man1/chrt.1.html.\n  * Display attributes of a process:\n`chrt --pid {{PID}}`\n  * Display attributes of all threads of a process:\n`chrt --all-tasks --pid {{PID}}`\n  * Display the min/max priority values that can be used with `chrt`:\n`chrt --max`\n  * Set the scheduling policy for a process:\n`chrt --pid {{PID}} --{{deadline|idle|batch|rr|fifo|other}}`"}
{"instruction": "What is git-describe command", "input": "", "output": "# git describe\n> Give an object a human-readable name based on an available ref. More\n> information: https://git-scm.com/docs/git-describe.\n  * Create a unique name for the current commit (the name contains the most recent annotated tag, the number of additional commits, and the abbreviated commit hash):\n`git describe`\n  * Create a name with 4 digits for the abbreviated commit hash:\n`git describe --abbrev={{4}}`\n  * Generate a name with the tag reference path:\n`git describe --all`\n  * Describe a Git tag:\n`git describe {{v1.0.0}}`\n  * Create a name for the last commit of a given branch:\n`git describe {{branch_name}}`"}
{"instruction": "What is tail command", "input": "", "output": "# tail\n> Display the last part of a file. See also: `head`. More information:\n> https://manned.org/man/freebsd-13.0/tail.1.\n  * Show last 'count' lines in file:\n`tail -n {{8}} {{path/to/file}}`\n  * Print a file from a specific line number:\n`tail -n +{{8}} {{path/to/file}}`\n  * Print a specific count of bytes from the end of a given file:\n`tail -c {{8}} {{path/to/file}}`\n  * Print the last lines of a given file and keep reading file until `Ctrl + C`:\n`tail -f {{path/to/file}}`\n  * Keep reading file until `Ctrl + C`, even if the file is inaccessible:\n`tail -F {{path/to/file}}`\n  * Show last 'count' lines in 'file' and refresh every 'seconds' seconds:\n`tail -n {{8}} -s {{10}} -f {{path/to/file}}`"}
{"instruction": "What is truncate command", "input": "", "output": "# truncate\n> Shrink or extend the size of a file to the specified size. More information:\n> https://www.gnu.org/software/coreutils/truncate.\n  * Set a size of 10 GB to an existing file, or create a new file with the specified size:\n`truncate --size {{10G}} {{filename}}`\n  * Extend the file size by 50 MiB, fill with holes (which reads as zero bytes):\n`truncate --size +{{50M}} {{filename}}`\n  * Shrink the file by 2 GiB, by removing data from the end of file:\n`truncate --size -{{2G}} {{filename}}`\n  * Empty the file's content:\n`truncate --size 0 {{filename}}`\n  * Empty the file's content, but do not create the file if it does not exist:\n`truncate --no-create --size 0 {{filename}}`"}
{"instruction": "What is git-check-attr command", "input": "", "output": "# git check-attr\n> For every pathname, list if each attribute is unspecified, set, or unset as\n> a gitattribute on that pathname. More information: https://git-\n> scm.com/docs/git-check-attr.\n  * Check the values of all attributes on a file:\n`git check-attr --all {{path/to/file}}`\n  * Check the value of a specific attribute on a file:\n`git check-attr {{attribute}} {{path/to/file}}`\n  * Check the value of a specific attribute on files:\n`git check-attr --all {{path/to/file1}} {{path/to/file2}}`\n  * Check the value of a specific attribute on one or more files:\n`git check-attr {{attribute}} {{path/to/file1}} {{path/to/file2}}`"}
{"instruction": "What is tr command", "input": "", "output": "# tr\n> Translate characters: run replacements based on single characters and\n> character sets. More information: https://www.gnu.org/software/coreutils/tr.\n  * Replace all occurrences of a character in a file, and print the result:\n`tr {{find_character}} {{replace_character}} < {{path/to/file}}`\n  * Replace all occurrences of a character from another command's output:\n`echo {{text}} | tr {{find_character}} {{replace_character}}`\n  * Map each character of the first set to the corresponding character of the second set:\n`tr '{{abcd}}' '{{jkmn}}' < {{path/to/file}}`\n  * Delete all occurrences of the specified set of characters from the input:\n`tr -d '{{input_characters}}' < {{path/to/file}}`\n  * Compress a series of identical characters to a single character:\n`tr -s '{{input_characters}}' < {{path/to/file}}`\n  * Translate the contents of a file to upper-case:\n`tr \"[:lower:]\" \"[:upper:]\" < {{path/to/file}}`\n  * Strip out non-printable characters from a file:\n`tr -cd \"[:print:]\" < {{path/to/file}}`"}
{"instruction": "What is cp command", "input": "", "output": "# cp\n> Copy files and directories. More information:\n> https://www.gnu.org/software/coreutils/cp.\n  * Copy a file to another location:\n`cp {{path/to/source_file.ext}} {{path/to/target_file.ext}}`\n  * Copy a file into another directory, keeping the filename:\n`cp {{path/to/source_file.ext}} {{path/to/target_parent_directory}}`\n  * Recursively copy a directory's contents to another location (if the destination exists, the directory is copied inside it):\n`cp -R {{path/to/source_directory}} {{path/to/target_directory}}`\n  * Copy a directory recursively, in verbose mode (shows files as they are copied):\n`cp -vR {{path/to/source_directory}} {{path/to/target_directory}}`\n  * Copy multiple files at once to a directory:\n`cp -t {{path/to/destination_directory}} {{path/to/file1 path/to/file2 ...}}`\n  * Copy text files to another location, in interactive mode (prompts user before overwriting):\n`cp -i {{*.txt}} {{path/to/target_directory}}`\n  * Follow symbolic links before copying:\n`cp -L {{link}} {{path/to/target_directory}}`\n  * Use the first argument as the destination directory (useful for `xargs ... | cp -t <DEST_DIR>`):\n`cp -t {{path/to/target_directory}} {{path/to/file_or_directory1\npath/to/file_or_directory2 ...}}`"}
{"instruction": "What is git-push command", "input": "", "output": "# git push\n> Push commits to a remote repository. More information: https://git-\n> scm.com/docs/git-push.\n  * Send local changes in the current branch to its default remote counterpart:\n`git push`\n  * Send changes from a specific local branch to its remote counterpart:\n`git push {{remote_name}} {{local_branch}}`\n  * Send changes from a specific local branch to its remote counterpart, and set the remote one as the default push/pull target of the local one:\n`git push -u {{remote_name}} {{local_branch}}`\n  * Send changes from a specific local branch to a specific remote branch:\n`git push {{remote_name}} {{local_branch}}:{{remote_branch}}`\n  * Send changes on all local branches to their counterparts in a given remote repository:\n`git push --all {{remote_name}}`\n  * Delete a branch in a remote repository:\n`git push {{remote_name}} --delete {{remote_branch}}`\n  * Remove remote branches that don't have a local counterpart:\n`git push --prune {{remote_name}}`\n  * Publish tags that aren't yet in the remote repository:\n`git push --tags`"}
{"instruction": "What is lpstat command", "input": "", "output": "# lpstat\n> Display status information about the current classes, jobs, and printers.\n> More information: https://ss64.com/osx/lpstat.html.\n  * Show a long listing of printers, classes, and jobs:\n`lpstat -l`\n  * Force encryption when connecting to the CUPS server:\n`lpstat -E`\n  * Show the ranking of print jobs:\n`lpstat -R`\n  * Show whether or not the CUPS server is running:\n`lpstat -r`\n  * Show all status information:\n`lpstat -t`"}
{"instruction": "What is find command", "input": "", "output": "# find\n> Find files or directories under the given directory tree, recursively. More\n> information: https://manned.org/find.\n  * Find files by extension:\n`find {{root_path}} -name '{{*.ext}}'`\n  * Find files matching multiple path/name patterns:\n`find {{root_path}} -path '{{**/path/**/*.ext}}' -or -name '{{*pattern*}}'`\n  * Find directories matching a given name, in case-insensitive mode:\n`find {{root_path}} -type d -iname '{{*lib*}}'`\n  * Find files matching a given pattern, excluding specific paths:\n`find {{root_path}} -name '{{*.py}}' -not -path '{{*/site-packages/*}}'`\n  * Find files matching a given size range, limiting the recursive depth to \"1\":\n`find {{root_path}} -maxdepth 1 -size {{+500k}} -size {{-10M}}`\n  * Run a command for each file (use `{}` within the command to access the filename):\n`find {{root_path}} -name '{{*.ext}}' -exec {{wc -l {} }}\\;`\n  * Find files modified in the last 7 days:\n`find {{root_path}} -daystart -mtime -{{7}}`\n  * Find empty (0 byte) files and delete them:\n`find {{root_path}} -type {{f}} -empty -delete`"}
{"instruction": "What is flock command", "input": "", "output": "# flock\n> Manage locks from shell scripts. It can be used to ensure that only one\n> process of a command is running. More information: https://manned.org/flock.\n  * Run a command with a file lock as soon as the lock is not required by others:\n`flock {{path/to/lock.lock}} --command \"{{command}}\"`\n  * Run a command with a file lock, and exit if the lock doesn't exist:\n`flock {{path/to/lock.lock}} --nonblock --command \"{{command}}\"`\n  * Run a command with a file lock, and exit with a specific error code if the lock doesn't exist:\n`flock {{path/to/lock.lock}} --nonblock --conflict-exit-code {{error_code}} -c\n\"{{command}}\"`"}
{"instruction": "What is ssh-add command", "input": "", "output": "# ssh-add\n> Manage loaded ssh keys in the ssh-agent. Ensure that ssh-agent is up and\n> running for the keys to be loaded in it. More information:\n> https://man.openbsd.org/ssh-add.\n  * Add the default ssh keys in `~/.ssh` to the ssh-agent:\n`ssh-add`\n  * Add a specific key to the ssh-agent:\n`ssh-add {{path/to/private_key}}`\n  * List fingerprints of currently loaded keys:\n`ssh-add -l`\n  * Delete a key from the ssh-agent:\n`ssh-add -d {{path/to/private_key}}`\n  * Delete all currently loaded keys from the ssh-agent:\n`ssh-add -D`\n  * Add a key to the ssh-agent and the keychain:\n`ssh-add -K {{path/to/private_key}}`"}
{"instruction": "What is git-show-branch command", "input": "", "output": "# git show-branch\n> Show branches and their commits. More information: https://git-\n> scm.com/docs/git-show-branch.\n  * Show a summary of the latest commit on a branch:\n`git show-branch {{branch_name|ref|commit}}`\n  * Compare commits in the history of multiple commits or branches:\n`git show-branch {{branch_name|ref|commit}}`\n  * Compare all remote tracking branches:\n`git show-branch --remotes`\n  * Compare both local and remote tracking branches:\n`git show-branch --all`\n  * List the latest commits in all branches:\n`git show-branch --all --list`\n  * Compare a given branch with the current branch:\n`git show-branch --current {{commit|branch_name|ref}}`\n  * Display the commit name instead of the relative name:\n`git show-branch --sha1-name --current {{current|branch_name|ref}}`\n  * Keep going a given number of commits past the common ancestor:\n`git show-branch --more {{5}} {{commit|branch_name|ref}}\n{{commit|branch_name|ref}} {{...}}`"}
{"instruction": "What is gawk command", "input": "", "output": "# gawk\n> This command is an alias of GNU `awk`.\n  * View documentation for the original command:\n`tldr -p linux awk`"}
{"instruction": "What is trap command", "input": "", "output": "# trap\n> Automatically execute commands after receiving signals by processes or the\n> operating system. Can be used to perform cleanups for interruptions by the\n> user or other actions. More information: https://manned.org/trap.\n  * List available signals to set traps for:\n`trap -l`\n  * List active traps for the current shell:\n`trap -p`\n  * Set a trap to execute commands when one or more signals are detected:\n`trap 'echo \"Caught signal {{SIGHUP}}\"' {{SIGHUP}}`\n  * Remove active traps:\n`trap - {{SIGHUP}} {{SIGINT}}`"}
{"instruction": "What is git-whatchanged command", "input": "", "output": "# git whatchanged\n> Show what has changed with recent commits or files. See also `git log`. More\n> information: https://git-scm.com/docs/git-whatchanged.\n  * Display logs and changes for recent commits:\n`git whatchanged`\n  * Display logs and changes for recent commits within the specified time frame:\n`git whatchanged --since=\"{{2 hours ago}}\"`\n  * Display logs and changes for recent commits for specific files or directories:\n`git whatchanged {{path/to/file_or_directory}}`"}
{"instruction": "What is troff command", "input": "", "output": "# troff\n> Typesetting processor for the groff (GNU Troff) document formatting system.\n> See also `groff`. More information: https://manned.org/troff.\n  * Format output for a PostScript printer, saving the output to a file:\n`troff {{path/to/input.roff}} | grops > {{path/to/output.ps}}`\n  * Format output for a PostScript printer using the [me] macro package, saving the output to a file:\n`troff -{{me}} {{path/to/input.roff}} | grops > {{path/to/output.ps}}`\n  * Format output as [a]SCII text using the [man] macro package:\n`troff -T {{ascii}} -{{man}} {{path/to/input.roff}} | grotty`\n  * Format output as a [pdf] file, saving the output to a file:\n`troff -T {{pdf}} {{path/to/input.roff}} | gropdf > {{path/to/output.pdf}}`"}
{"instruction": "What is ar command", "input": "", "output": "# ar\n> Create, modify, and extract from Unix archives. Typically used for static\n> libraries (`.a`) and Debian packages (`.deb`). See also: `tar`. More\n> information: https://manned.org/ar.\n  * E[x]tract all members from an archive:\n`ar x {{path/to/file.a}}`\n  * Lis[t] contents in a specific archive:\n`ar t {{path/to/file.ar}}`\n  * [r]eplace or add specific files to an archive:\n`ar r {{path/to/file.deb}} {{path/to/debian-binary path/to/control.tar.gz\npath/to/data.tar.xz ...}}`\n  * In[s]ert an object file index (equivalent to using `ranlib`):\n`ar s {{path/to/file.a}}`\n  * Create an archive with specific files and an accompanying object file index:\n`ar rs {{path/to/file.a}} {{path/to/file1.o path/to/file2.o ...}}`"}
{"instruction": "What is hostnamectl command", "input": "", "output": "# hostnamectl\n> Get or set the hostname of the computer. More information:\n> https://manned.org/hostnamectl.\n  * Get the hostname of the computer:\n`hostnamectl`\n  * Set the hostname of the computer:\n`sudo hostnamectl set-hostname \"{{hostname}}\"`\n  * Set a pretty hostname for the computer:\n`sudo hostnamectl set-hostname --static \"{{hostname.example.com}}\" && sudo\nhostnamectl set-hostname --pretty \"{{hostname}}\"`\n  * Reset hostname to its default value:\n`sudo hostnamectl set-hostname --pretty \"\"`"}
{"instruction": "What is split command", "input": "", "output": "# split\n> Split a file into pieces. More information: https://ss64.com/osx/split.html.\n  * Split a file, each split having 10 lines (except the last split):\n`split -l {{10}} {{filename}}`\n  * Split a file by a regular expression. The matching line will be the first line of the next output file:\n`split -p {{cat|^[dh]og}} {{filename}}`\n  * Split a file with 512 bytes in each split (except the last split; use 512k for kilobytes and 512m for megabytes):\n`split -b {{512}} {{filename}}`\n  * Split a file into 5 files. File is split such that each split has same size (except the last split):\n`split -n {{5}} {{filename}}`"}
{"instruction": "What is sftp command", "input": "", "output": "# sftp\n> Secure File Transfer Program. Interactive program to copy files between\n> hosts over SSH. For non-interactive file transfers, see `scp` or `rsync`.\n> More information: https://manned.org/sftp.\n  * Connect to a remote server and enter an interactive command mode:\n`sftp {{remote_user}}@{{remote_host}}`\n  * Connect using an alternate port:\n`sftp -P {{remote_port}} {{remote_user}}@{{remote_host}}`\n  * Connect using a predefined host (in `~/.ssh/config`):\n`sftp {{host}}`\n  * Transfer remote file to the local system:\n`get {{/path/remote_file}}`\n  * Transfer local file to the remote system:\n`put {{/path/local_file}}`\n  * Transfer remote directory to the local system recursively (works with `put` too):\n`get -R {{/path/remote_directory}}`\n  * Get list of files on local machine:\n`lls`\n  * Get list of files on remote machine:\n`ls`"}
{"instruction": "What is renice command", "input": "", "output": "# renice\n> Alters the scheduling priority/niceness of one or more running processes.\n> Niceness values range from -20 (most favorable to the process) to 19 (least\n> favorable to the process). More information: https://manned.org/renice.\n  * Change priority of a running process:\n`renice -n {{niceness_value}} -p {{pid}}`\n  * Change priority of all processes owned by a user:\n`renice -n {{niceness_value}} -u {{user}}`\n  * Change priority of all processes that belong to a process group:\n`renice -n {{niceness_value}} --pgrp {{process_group}}`"}
{"instruction": "What is envsubst command", "input": "", "output": "# envsubst\n> Substitutes environment variables with their value in shell format strings.\n> Variables to be replaced should be in either `${var}` or `$var` format. More\n> information: https://www.gnu.org/software/gettext/manual/html_node/envsubst-\n> Invocation.html.\n  * Replace environment variables in `stdin` and output to `stdout`:\n`echo '{{$HOME}}' | envsubst`\n  * Replace environment variables in an input file and output to `stdout`:\n`envsubst < {{path/to/input_file}}`\n  * Replace environment variables in an input file and output to a file:\n`envsubst < {{path/to/input_file}} > {{path/to/output_file}}`\n  * Replace environment variables in an input file from a space-separated list:\n`envsubst '{{$USER $SHELL $HOME}}' < {{path/to/input_file}}`"}
{"instruction": "What is comm command", "input": "", "output": "# comm\n> Select or reject lines common to two files. Both files must be sorted. More\n> information: https://www.gnu.org/software/coreutils/comm.\n  * Produce three tab-separated columns: lines only in first file, lines only in second file and common lines:\n`comm {{file1}} {{file2}}`\n  * Print only lines common to both files:\n`comm -12 {{file1}} {{file2}}`\n  * Print only lines common to both files, reading one file from `stdin`:\n`cat {{file1}} | comm -12 - {{file2}}`\n  * Get lines only found in first file, saving the result to a third file:\n`comm -23 {{file1}} {{file2}} > {{file1_only}}`\n  * Print lines only found in second file, when the files aren't sorted:\n`comm -13 <(sort {{file1}}) <(sort {{file2}})`"}
{"instruction": "What is gdb command", "input": "", "output": "# gdb\n> The GNU Debugger. More information: https://www.gnu.org/software/gdb.\n  * Debug an executable:\n`gdb {{executable}}`\n  * Attach a process to gdb:\n`gdb -p {{procID}}`\n  * Debug with a core file:\n`gdb -c {{core}} {{executable}}`\n  * Execute given GDB commands upon start:\n`gdb -ex \"{{commands}}\" {{executable}}`\n  * Start `gdb` and pass arguments to the executable:\n`gdb --args {{executable}} {{argument1}} {{argument2}}`"}
{"instruction": "What is git-prune command", "input": "", "output": "# git prune\n> Git command for pruning all unreachable objects from the object database.\n> This command is often not used directly but as an internal command that is\n> used by Git gc. More information: https://git-scm.com/docs/git-prune.\n  * Report what would be removed by Git prune without removing it:\n`git prune --dry-run`\n  * Prune unreachable objects and display what has been pruned to `stdout`:\n`git prune --verbose`\n  * Prune unreachable objects while showing progress:\n`git prune --progress`"}
{"instruction": "What is oomctl command", "input": "", "output": "# oomctl\n> Analyze the state stored in `systemd-oomd`. More information:\n> https://www.freedesktop.org/software/systemd/man/oomctl.html.\n  * Show the current state of the cgroups and system contexts stored by `systemd-oomd`:\n`oomctl dump`"}
{"instruction": "What is git-config command", "input": "", "output": "# git config\n> Manage custom configuration options for Git repositories. These\n> configurations can be local (for the current repository) or global (for the\n> current user). More information: https://git-scm.com/docs/git-config.\n  * List only local configuration entries (stored in `.git/config` in the current repository):\n`git config --list --local`\n  * List only global configuration entries (stored in `~/.gitconfig` by default or in `$XDG_CONFIG_HOME/git/config` if such a file exists):\n`git config --list --global`\n  * List only system configuration entries (stored in `/etc/gitconfig`), and show their file location:\n`git config --list --system --show-origin`\n  * Get the value of a given configuration entry:\n`git config alias.unstage`\n  * Set the global value of a given configuration entry:\n`git config --global alias.unstage \"reset HEAD --\"`\n  * Revert a global configuration entry to its default value:\n`git config --global --unset alias.unstage`\n  * Edit the Git configuration for the current repository in the default editor:\n`git config --edit`\n  * Edit the global Git configuration in the default editor:\n`git config --global --edit`"}
{"instruction": "What is git-merge-base command", "input": "", "output": "# git merge-base\n> Find a common ancestor of two commits. More information: https://git-\n> scm.com/docs/git-merge-base.\n  * Print the best common ancestor of two commits:\n`git merge-base {{commit_1}} {{commit_2}}`\n  * Output all best common ancestors of two commits:\n`git merge-base --all {{commit_1}} {{commit_2}}`\n  * Check if a commit is an ancestor of a specific commit:\n`git merge-base --is-ancestor {{ancestor_commit}} {{commit}}`"}
{"instruction": "What is pwd command", "input": "", "output": "# pwd\n> Print name of current/working directory. More information:\n> https://www.gnu.org/software/coreutils/pwd.\n  * Print the current directory:\n`pwd`\n  * Print the current directory, and resolve all symlinks (i.e. show the \"physical\" path):\n`pwd -P`"}
{"instruction": "What is git-unpack-file command", "input": "", "output": "# git unpack-file\n> Create a temporary file with a blob's contents. More information:\n> https://git-scm.com/docs/git-unpack-file.\n  * Create a file holding the contents of the blob specified by its ID then print the name of the temporary file:\n`git unpack-file {{blob_id}}`"}
{"instruction": "What is git-fsck command", "input": "", "output": "# git fsck\n> Verify the validity and connectivity of nodes in a Git repository index.\n> Does not make any modifications. See `git gc` for cleaning up dangling\n> blobs. More information: https://git-scm.com/docs/git-fsck.\n  * Check the current repository:\n`git fsck`\n  * List all tags found:\n`git fsck --tags`\n  * List all root nodes found:\n`git fsck --root`"}
{"instruction": "What is chgrp command", "input": "", "output": "# chgrp\n> Change group ownership of files and directories. More information:\n> https://www.gnu.org/software/coreutils/chgrp.\n  * Change the owner group of a file/directory:\n`chgrp {{group}} {{path/to/file_or_directory}}`\n  * Recursively change the owner group of a directory and its contents:\n`chgrp -R {{group}} {{path/to/directory}}`\n  * Change the owner group of a symbolic link:\n`chgrp -h {{group}} {{path/to/symlink}}`\n  * Change the owner group of a file/directory to match a reference file:\n`chgrp --reference={{path/to/reference_file}} {{path/to/file_or_directory}}`"}
{"instruction": "What is free command", "input": "", "output": "# free\n> Display amount of free and used memory in the system. More information:\n> https://manned.org/free.\n  * Display system memory:\n`free`\n  * Display memory in Bytes/KB/MB/GB:\n`free -{{b|k|m|g}}`\n  * Display memory in human-readable units:\n`free -h`\n  * Refresh the output every 2 seconds:\n`free -s {{2}}`"}
{"instruction": "What is id command", "input": "", "output": "# id\n> Display current user and group identity. More information:\n> https://www.gnu.org/software/coreutils/id.\n  * Display current user's ID (UID), group ID (GID) and groups to which they belong:\n`id`\n  * Display the current user identity as a number:\n`id -u`\n  * Display the current group identity as a number:\n`id -g`\n  * Display an arbitrary user's ID (UID), group ID (GID) and groups to which they belong:\n`id {{username}}`"}
{"instruction": "What is readelf command", "input": "", "output": "# readelf\n> Displays information about ELF files. More information:\n> http://man7.org/linux/man-pages/man1/readelf.1.html.\n  * Display all information about the ELF file:\n`readelf -all {{path/to/binary}}`\n  * Display all the headers present in the ELF file:\n`readelf --headers {{path/to/binary}}`\n  * Display the entries in symbol table section of the ELF file, if it has one:\n`readelf --symbols {{path/to/binary}}`\n  * Display the information contained in the ELF header at the start of the file:\n`readelf --file-header {{path/to/binary}}`"}
{"instruction": "What is ld command", "input": "", "output": "# ld\n> Link object files together. More information:\n> https://sourceware.org/binutils/docs-2.38/ld.html.\n  * Link a specific object file with no dependencies into an executable:\n`ld {{path/to/file.o}} --output {{path/to/output_executable}}`\n  * Link two object files together:\n`ld {{path/to/file1.o}} {{path/to/file2.o}} --output\n{{path/to/output_executable}}`\n  * Dynamically link an x86_64 program to glibc (file paths change depending on the system):\n`ld --output {{path/to/output_executable}} --dynamic-linker /lib/ld-\nlinux-x86-64.so.2 /lib/crt1.o /lib/crti.o -lc {{path/to/file.o}} /lib/crtn.o`"}
{"instruction": "What is git-commit command", "input": "", "output": "# git commit\n> Commit files to the repository. More information: https://git-\n> scm.com/docs/git-commit.\n  * Commit staged files to the repository with a message:\n`git commit --message \"{{message}}\"`\n  * Commit staged files with a message read from a file:\n`git commit --file {{path/to/commit_message_file}}`\n  * Auto stage all modified and deleted files and commit with a message:\n`git commit --all --message \"{{message}}\"`\n  * Commit staged files and sign them with the specified GPG key (or the one defined in the config file if no argument is specified):\n`git commit --gpg-sign {{key_id}} --message \"{{message}}\"`\n  * Update the last commit by adding the currently staged changes, changing the commit's hash:\n`git commit --amend`\n  * Commit only specific (already staged) files:\n`git commit {{path/to/file1}} {{path/to/file2}}`\n  * Create a commit, even if there are no staged files:\n`git commit --message \"{{message}}\" --allow-empty`"}
{"instruction": "What is xargs command", "input": "", "output": "# xargs\n> Execute a command with piped arguments coming from another command, a file,\n> etc. The input is treated as a single block of text and split into separate\n> pieces on spaces, tabs, newlines and end-of-file. More information:\n> https://pubs.opengroup.org/onlinepubs/9699919799/utilities/xargs.html.\n  * Run a command using the input data as arguments:\n`{{arguments_source}} | xargs {{command}}`\n  * Run multiple chained commands on the input data:\n`{{arguments_source}} | xargs sh -c \"{{command1}} && {{command2}} |\n{{command3}}\"`\n  * Delete all files with a `.backup` extension (`-print0` uses a null character to split file names, and `-0` uses it as delimiter):\n`find . -name {{'*.backup'}} -print0 | xargs -0 rm -v`\n  * Execute the command once for each input line, replacing any occurrences of the placeholder (here marked as `_`) with the input line:\n`{{arguments_source}} | xargs -I _ {{command}} _ {{optional_extra_arguments}}`\n  * Parallel runs of up to `max-procs` processes at a time; the default is 1. If `max-procs` is 0, xargs will run as many processes as possible at a time:\n`{{arguments_source}} | xargs -P {{max-procs}} {{command}}`"}
{"instruction": "What is stty command", "input": "", "output": "# stty\n> Set options for a terminal device interface. More information:\n> https://www.gnu.org/software/coreutils/stty.\n  * Display all settings for the current terminal:\n`stty --all`\n  * Set the number of rows or columns:\n`stty {{rows|cols}} {{count}}`\n  * Get the actual transfer speed of a device:\n`stty --file {{path/to/device_file}} speed`\n  * Reset all modes to reasonable values for the current terminal:\n`stty sane`"}
{"instruction": "What is git-ls-files command", "input": "", "output": "# git ls-files\n> Show information about files in the index and the working tree. More\n> information: https://git-scm.com/docs/git-ls-files.\n  * Show deleted files:\n`git ls-files --deleted`\n  * Show modified and deleted files:\n`git ls-files --modified`\n  * Show ignored and untracked files:\n`git ls-files --others`\n  * Show untracked files, not ignored:\n`git ls-files --others --exclude-standard`"}
{"instruction": "What is shred command", "input": "", "output": "# shred\n> Overwrite files to securely delete data. More information:\n> https://www.gnu.org/software/coreutils/shred.\n  * Overwrite a file:\n`shred {{path/to/file}}`\n  * Overwrite a file, leaving zeroes instead of random data:\n`shred --zero {{path/to/file}}`\n  * Overwrite a file 25 times:\n`shred -n25 {{path/to/file}}`\n  * Overwrite a file and remove it:\n`shred --remove {{path/to/file}}`"}
{"instruction": "What is tac command", "input": "", "output": "# tac\n> Display and concatenate files with lines in reversed order. See also: `cat`.\n> More information: https://www.gnu.org/software/coreutils/tac.\n  * Concatenate specific files in reversed order:\n`tac {{path/to/file1 path/to/file2 ...}}`\n  * Display `stdin` in reversed order:\n`{{cat path/to/file}} | tac`\n  * Use a specific [s]eparator:\n`tac -s {{separator}} {{path/to/file1 path/to/file2 ...}}`\n  * Use a specific [r]egex as a [s]eparator:\n`tac -r -s {{separator}} {{path/to/file1 path/to/file2 ...}}`\n  * Use a separator [b]efore each file:\n`tac -b {{path/to/file1 path/to/file2 ...}}`"}
{"instruction": "What is write command", "input": "", "output": "# write\n> Write a message on the terminal of a specified logged in user (ctrl-C to\n> stop writing messages). Use the `who` command to find out all terminal_ids\n> of all active users active on the system. See also `mesg`. More information:\n> https://manned.org/write.\n  * Send a message to a given user on a given terminal id:\n`write {{username}} {{terminal_id}}`\n  * Send message to \"testuser\" on terminal `/dev/tty/5`:\n`write {{testuser}} {{tty/5}}`\n  * Send message to \"johndoe\" on pseudo terminal `/dev/pts/5`:\n`write {{johndoe}} {{pts/5}}`"}
{"instruction": "What is git-ls-remote command", "input": "", "output": "# git ls-remote\n> Git command for listing references in a remote repository based on name or\n> URL. If no name or URL are given, then the configured upstream branch will\n> be used, or remote origin if the former is not configured. More information:\n> https://git-scm.com/docs/git-ls-remote.\n  * Show all references in the default remote repository:\n`git ls-remote`\n  * Show only heads references in the default remote repository:\n`git ls-remote --heads`\n  * Show only tags references in the default remote repository:\n`git ls-remote --tags`\n  * Show all references from a remote repository based on name or URL:\n`git ls-remote {{repository_url}}`\n  * Show references from a remote repository filtered by a pattern:\n`git ls-remote {{repository_name}} \"{{pattern}}\"`"}
{"instruction": "What is git-merge command", "input": "", "output": "# git merge\n> Merge branches. More information: https://git-scm.com/docs/git-merge.\n  * Merge a branch into your current branch:\n`git merge {{branch_name}}`\n  * Edit the merge message:\n`git merge --edit {{branch_name}}`\n  * Merge a branch and create a merge commit:\n`git merge --no-ff {{branch_name}}`\n  * Abort a merge in case of conflicts:\n`git merge --abort`\n  * Merge using a specific strategy:\n`git merge --strategy {{strategy}} --strategy-option {{strategy_option}}\n{{branch_name}}`"}
{"instruction": "What is chown command", "input": "", "output": "# chown\n> Change user and group ownership of files and directories. More information:\n> https://www.gnu.org/software/coreutils/chown.\n  * Change the owner user of a file/directory:\n`chown {{user}} {{path/to/file_or_directory}}`\n  * Change the owner user and group of a file/directory:\n`chown {{user}}:{{group}} {{path/to/file_or_directory}}`\n  * Recursively change the owner of a directory and its contents:\n`chown -R {{user}} {{path/to/directory}}`\n  * Change the owner of a symbolic link:\n`chown -h {{user}} {{path/to/symlink}}`\n  * Change the owner of a file/directory to match a reference file:\n`chown --reference={{path/to/reference_file}} {{path/to/file_or_directory}}`"}
{"instruction": "What is sshfs command", "input": "", "output": "# sshfs\n> Filesystem client based on SSH. More information:\n> https://github.com/libfuse/sshfs.\n  * Mount remote directory:\n`sshfs {{username}}@{{remote_host}}:{{remote_directory}} {{mountpoint}}`\n  * Unmount remote directory:\n`umount {{mountpoint}}`\n  * Mount remote directory from server with specific port:\n`sshfs {{username}}@{{remote_host}}:{{remote_directory}} -p {{2222}}`\n  * Use compression:\n`sshfs {{username}}@{{remote_host}}:{{remote_directory}} -C`\n  * Follow symbolic links:\n`sshfs -o follow_symlinks {{username}}@{{remote_host}}:{{remote_directory}}\n{{mountpoint}}`"}
{"instruction": "What is sleep command", "input": "", "output": "# sleep\n> Delay for a specified amount of time. More information:\n> https://pubs.opengroup.org/onlinepubs/9699919799/utilities/sleep.html.\n  * Delay in seconds:\n`sleep {{seconds}}`\n  * Execute a specific command after 20 seconds delay:\n`sleep 20 && {{command}}`"}
{"instruction": "What is manpath command", "input": "", "output": "# manpath\n> Determine the search path for manual pages. More information:\n> https://manned.org/manpath.\n  * Display the search path used to find man pages:\n`manpath`\n  * Show the entire global manpath:\n`manpath --global`"}
{"instruction": "What is mv command", "input": "", "output": "# mv\n> Move or rename files and directories. More information:\n> https://www.gnu.org/software/coreutils/mv.\n  * Rename a file or directory when the target is not an existing directory:\n`mv {{path/to/source}} {{path/to/target}}`\n  * Move a file or directory into an existing directory:\n`mv {{path/to/source}} {{path/to/existing_directory}}`\n  * Move multiple files into an existing directory, keeping the filenames unchanged:\n`mv {{path/to/source1 path/to/source2 ...}} {{path/to/existing_directory}}`\n  * Do not prompt for confirmation before overwriting existing files:\n`mv -f {{path/to/source}} {{path/to/target}}`\n  * Prompt for confirmation before overwriting existing files, regardless of file permissions:\n`mv -i {{path/to/source}} {{path/to/target}}`\n  * Do not overwrite existing files at the target:\n`mv -n {{path/to/source}} {{path/to/target}}`\n  * Move files in verbose mode, showing files after they are moved:\n`mv -v {{path/to/source}} {{path/to/target}}`"}
{"instruction": "What is whereis command", "input": "", "output": "# whereis\n> Locate the binary, source, and manual page files for a command. More\n> information: https://manned.org/whereis.\n  * Locate binary, source and man pages for ssh:\n`whereis {{ssh}}`\n  * Locate binary and man pages for ls:\n`whereis -bm {{ls}}`\n  * Locate source of gcc and man pages for Git:\n`whereis -s {{gcc}} -m {{git}}`\n  * Locate binaries for gcc in `/usr/bin/` only:\n`whereis -b -B {{/usr/bin/}} -f {{gcc}}`\n  * Locate unusual binaries (those that have more or less than one binary on the system):\n`whereis -u *`\n  * Locate binaries that have unusual manual entries (binaries that have more or less than one manual installed):\n`whereis -u -m *`"}
{"instruction": "What is git-daemon command", "input": "", "output": "# git daemon\n> A really simple server for Git repositories. More information: https://git-\n> scm.com/docs/git-daemon.\n  * Launch a Git daemon with a whitelisted set of directories:\n`git daemon --export-all {{path/to/directory1}} {{path/to/directory2}}`\n  * Launch a Git daemon with a specific base directory and allow pulling from all sub-directories that look like Git repositories:\n`git daemon --base-path={{path/to/directory}} --export-all --reuseaddr`\n  * Launch a Git daemon for the specified directory, verbosely printing log messages and allowing Git clients to write to it:\n`git daemon {{path/to/directory}} --enable=receive-pack --informative-errors\n--verbose`"}