diffutils 2.7.10 - en to he translation catalogue (180 entries)

en:   Either GFMT or LFMT may contain:
        %%  %
        %c'C'  the single character C
        %c'\OOO'  the character with octal code OOO
he:                                          :םג לולכל םילוכי LFMT וא GFMT
                                        %%  %
                             C דדוב ות  %c'C'
                 OOO ילטקוא דוק לעב ות  %c'\OOO'

en:   GFMT may contain:
        %<  lines from FILE1
        %>  lines from FILE2
        %=  lines common to FILE1 and FILE2
        %[-][WIDTH][.[PREC]]{doxX}LETTER  printf-style spec for LETTER
          LETTERs are as follows for new group, lower case for old group:
            F  first line number
            L  last line number
            N  number of lines = L-F+1
            E  F-1
            M  L+1
he:                                                       :לולכל לוכי GFMT
                         FILE1-מ תורוש  %<
                         FILE2-מ תורוש  %>
         FILE2-ו FILE1-ל תופתושמ תורוש  %=
      LETTER רובע printf ןונגסב תזורחמ  %[-][WIDTH][.[PREC]]{doxX}LETTER
           :(הנשי הצובק רובע תונטק תויתוא) תואבה תויתואה תחא איה LETTER
                      הנושאר הרוש רפסמ  F
                      הנורחא הרוש רפסמ  L
                   L-F+1 = תורושה רפסמ  N
                                   F-1  E
                                   M+1  M

en:   LFMT may contain:
        %L  contents of line
        %l  contents of line, excluding any trailing newline
        %[-][WIDTH][.[PREC]]{doxX}n  printf-style spec for input line number
he:                                                       :לולכל לוכי LFMT
                             הרוש ןכות  %L
           הרושה ףוס ות טעמל הרוש ןכות  %l
    טלק תרוש רובע printf ןונגסב תזורחמ  %[-][WIDTH][.[PREC]]{doxX}n

en:   LTYPE is `old', `new', or `unchanged'.  GTYPE is LTYPE or `changed'.
he:   .`changed' וא LTYPE ומכ GTYPE .`unchanged' וא `new' ,`old' אוה LTYPE

en:   Skip the first SKIP1 bytes of FILE1 and the first SKIP2 bytes of FILE2.
he: .ינשה ץבוקב םיתב N2 לעו ןושארה ץבוקב םיתב N1 לע גלד

en: %s %s differ: byte %s, line %s
he: %s-ו %s םיצבקה ןיב %s תיב ,%s הרושמ לחה ינוש

en: %s %s differ: byte %s, line %s is %3o %s %3o %s
he: %s-ו %s םיצבקה ןיב %s תיב ,%s הרושמ לחה %3o %s %3o %s ינוש

en: %s: diff failed:
he: %s י"ע diff תלעפהב הלקת :

en: %s: illegal option -- %c
he: %s: יקוח-יתלב ןייפאמ -- %c

en: %s: invalid option -- %c
he: %s תינכת רובע יוגש ןייפאמ -- %c

en: %s: option `%c%s' doesn't allow an argument
he: %s תינכת רובע טנמוגרא לבקמ וניא `%c%s' ןייפאמ

en: %s: option `%s' is ambiguous
he: %s תינכת רובע יעמשמ-דח וניא `%s' ןייפאמ

en: %s: option `%s' requires an argument
he: %s תינכת רובע טנמוגרא בייחמ `%s' ןייפאמ

en: %s: option `--%s' doesn't allow an argument
he: %s תינכת רובע טנמוגרא לבקמ וניא `--%s' ןייפאמ

en: %s: option `-W %s' doesn't allow an argument
he: %s תינכת רובע טנמוגרא לבקמ וניא `-W %s' ןייפאמ

en: %s: option `-W %s' is ambiguous
he: %s תינכת רובע יעמשמ-דח וניא `-W %s' ןייפאמ

en: %s: option requires an argument -- %c
he: %s: טנמוגרא בייחמ ןייפאמ -- %c

en: %s: unrecognized option `%c%s'
he: %s תינכת רובע `%c%s' ההוזמ-יתלב ןייפאמ

en: %s: unrecognized option `--%s'
he: %s תינכת רובע `--%s' ההוזמ-יתלב ןייפאמ

en: --GTYPE-group-format=GFMT  Similar, but format GTYPE input groups with GFMT.
he: GFMT תרזעב GTYPE גוסמ טלק תוצובק טמרפ ךא ,ל"נכ  --GTYPE-group-format=GFMT

en: --LTYPE-line-format=LFMT  Similar, but format LTYPE input lines with LFMT.
he: .LFMT תרזעב LTYPE גוסמ טלק תורוש טמרפ ךא ,ל"נכ  --LTYPE-group-format=LFMT

en: --binary  Read and write data in binary mode.
he:                     .יראניב ןפואב בותכו ארק      --binary

en: --diff-program=PROGRAM  Use PROGRAM to compare files.
he:                  .םיצבק תאושהל PROGRAM תינכתב שמתשה  --diff-program=PROGRAM

en: --from-file and --to-file both specified
he: --to-file ןהו --from-file ןה תנייצ

en: --from-file=FILE1  Compare FILE1 to all operands.  FILE1 can be a directory.
he: .היקית תויהל לוכי FILE1 .םיטנמוגראה ראש לכל FILE1 הוושה  --from-file=FILE1

en: --help  Output this help.
he:                            .הז הרזע ךסמ גצה      --help

en: --horizon-lines=NUM  Keep NUM lines of the common prefix and suffix.
he: .םיצבקה םויסו הליחתב תופתושמ תורוש NUM ראשה          --horizon-lines=NUM

en: --ignore-file-name-case  Ignore case when comparing file names.
he: .םיצבקה תומשב תונטקמ תולודג תויתוא לידבת לא  --ignore-file-name-case

en: --line-format=LFMT  Similar, but format all input lines with LFMT.
he:                .LFMT תרזעב תורוש טמרפ ךא ,ל"נכ  --line-format=LFMT

en: --no-ignore-file-name-case  Consider case when comparing file names.
he:    .םיצבקה תומשב תונטקמ תולודג תויתוא לידבת  --no-ignore-file-name-case

en: --normal  Output a normal diff.
he:                    .ליגר טמרופב םייוניש קפה      --normal

en: --speed-large-files  Assume large files and many scattered small changes.
he:   .םיקחורמו םינטק םייונישו םילודג םיצבק חנה      --speed-large-files

en: --strip-trailing-cr  Strip trailing carriage return on input.
he:               .טלק תרוש לכ ףוסמ CR יוות קלס      --strip-trailing-cr

en: --to-file=FILE2  Compare all operands to FILE2.  FILE2 can be a directory.
he:    .היקית תויהל לוכי FILE2 .FILE2-ל םיטנמוגראה לכ הוושה  --to-file=FILE2

en: --unidirectional-new-file  Treat absent first files as empty.
he:   .םיקיר ויה וליאכ םירסח םינושאר םיצבקב לפט      --unidirectional-new-file

en: -3  --easy-only  Output unmerged nonoverlapping changes.
he:                .גוזימ אללו םיפפוח םניאש םייוניש גצה  -3  --easy-only

en: -A  --show-all  Output all changes, bracketing conflicts.
he:                 .םיטקילפנוק ןמס ,םייונישה לכ תא גצה  -A  --show-all

en: -B  --ignore-blank-lines  Ignore changes whose lines are all blank.
he:             .תוקיר םהיתורושש םייונישמ םלעתה  -B  --ignore-blank-lines

en: -D NAME  --ifdef=NAME  Output merged file to show `#ifdef NAME' diffs.
he: `#ifdef NAME'-ב םייוניש דרפה ,בלושמ ץבוק קפה -D NAME  --ifdef=NAME

en: -D option not supported with directories
he: תויקית רובע -D ןייפאמב הכימת ןיא

en: -E  --ignore-tab-expansion  Ignore changes due to tab expansion.
he:              .םיחוורל TAB ןיב םילדבהמ םלעתה  -E  --ignore-tab-expansion

en: -E  --show-overlap  Output unmerged changes, bracketing conflicts.
he:              .םיטקילפנוק ןמס ,גוזימ אלל םייוניש גצה  -E  --show-overlap

en: -H  --speed-large-files  Assume large files and many scattered small changes.
he:   .םיקחורמו םינטק םייונישו םילודג םיצבק חנה  -H  --speed-large-files

en: -I RE  --ignore-matching-lines=RE  Ignore changes whose lines all match RE.
he: .RE תינבתל תומיאתמ םהיתורושש םייונישמ םלעתה  -I RE --ignore-matching-lines=RE

en: -L LABEL  --label=LABEL  Use LABEL instead of file name.
he:                       .ץבוקה םש םוקמב LABEL-ב שמתשה  -L LABEL  --label=LABEL

en: -N  --new-file  Treat absent files as empty.
he:           .םיקיר ויה וליאכ םירסח םיצבקב לפט  -N  --new-file

en: -S FILE  --starting-file=FILE  Start with FILE when comparing directories.
he:              .FILE ץבוקב תויקית תאוושה לחתה  -S FILE  --starting-file=FILE

en: -T  --initial-tab  Make tabs line up by prepending a tab.
he:              .הרושה ינפל TAB "ע םי-TAB רשי  -T  --initial-tab

en: -W  --ignore-all-space  Ignore all white space.
he:                 .רחא ןבל חטשו םיחוורמ םלעתה  -W  --ignore-all-space

en: -X  Output overlapping changes, bracketing them.
he:                       .םתוא ןמסו םיפפוח םייוניש גצה  -X

en: -X FILE  --exclude-from=FILE  Exclude files that match any pattern in FILE.
he: FILE-ב תוינבתל םימיאתמ םהיתומשש םיצבק לע גלד -X FILE  --exclude-from=FILE

en: -a  --text  Treat all files as text.
he:                 .טסקט יצבקבכ םיצבקה לכב לפט  -a  --text

en: -b  --ignore-space-change  Ignore changes in the amount of white space.
he:                 .םיחוור תומכב םילדבהמ םלעתה  -b  --ignore-space-change

en: -b  --print-bytes  Print differing bytes.
he:                        .םיהז םניאש םיתב גצה  -b    --print-bytes

en: -c  -C NUM  --context[=NUM]  Output NUM (default 3) lines of copied context.
    -u  -U NUM  --unified[=NUM]  Output NUM (default 3) lines of unified context.
      --label LABEL  Use LABEL instead of file name.
      -p  --show-c-function  Show which C function each change is in.
      -F RE  --show-function-line=RE  Show the most recent line matching RE.
he:   .קתעומ טסקטנוק תורוש (3 :ח"מרב) NUM הארה  -c  -C NUM  --context[=NUM]
      .דחואמ טסקטנוק תורוש (3 :ח"מרב) NUM הארה  -u  -U NUM  --unified[=NUM]
                        .םש םוקמב LABEL-ב שמתשה         --label LABEL
                .יוניש לכ לש C תייצקנופ םש הארה  -p     --show-c-function
            .RE תינבתל המיאתמש הנורחא הרוש הארה  -F RE  --show-function-line=RE

en: -d  --minimal  Try hard to find a smaller set of changes.
he:             .םייונישה תצובק תא ןיטקהל לדתשה  -d  --minimal

en: -e  --ed  Output an ed script.
he:              .ed ךרוע רובע תוארוה תמישר קפה  -e  --ed

en: -e  --ed  Output unmerged changes from OLDFILE to YOURFILE into MYFILE.
he: MYFILE ךות לא YOURFILE-ל OLDFILE-מ גוזימ אלל םייוניש -e  --ed

en: -i  --ignore-case  Consider upper- and lower-case to be the same.
he:     .תונטקו תולודג תויתוא ןיב םילדבהמ םלעתה  -i  --ignore-case

en: -i  --ignore-case  Ignore case differences in file contents.
he: .םיצבקה ןכותב תונטקמ תולודג תויתוא לידבת לא  -i  --ignore-case

en: -i  Append `w' and `q' commands to ed scripts.
he:             .ed תודוקפ םויסב `q'-ו `w' תודוקפ בותכ   -i

en: -i SKIP  --ignore-initial=SKIP  Skip the first SKIP bytes of input.
he:              .טלקה לש םינושאר םיתב N לע גלד  -i N --ignore-initial=N

en: -i SKIP1:SKIP2  --ignore-initial=SKIP1:SKIP2
he:                                              -i N1:N2
                                                 --ignore-initial=N1:N2

en: -l  --left-column  Output only the left column of common lines.
he:          .תילאמשה תא קר גצה ,תוהז תורושה םא  -l  --left-column

en: -l  --paginate  Pass the output through `pr' to paginate it.
he:                 .דומיע םשל `pr' ךרד טלפ בתנ  -l  --paginate

en: -l  --verbose  Output byte numbers and values of all differing bytes.
he: .םיהז םניאש םיתבה לכ לש דוקו ירודיס 'סמ גצה  -l    --verbose

en: -m  --merge  Output merged file instead of ed script (default -A).
he:        .(-A ח"מרב) ed תוארוה םוקמב גזוממ ץבוק בותכ  -m  --merge

en: -n  --rcs  Output an RCS format diff.
he:                     .RCS טמרופב םייוניש קפה  -n  --rcs

en: -n LIMIT  --bytes=LIMIT  Compare at most LIMIT bytes.
he:                     .םיתב N רתויה לכל הוושה  -n N  --bytes=N

en: -o FILE  --output=FILE  Operate interactively, sending output to FILE.
he:             .FILE-ל טלפ ,תיביטקארטניא הלועפ  -o FILE  --output=FILE

en: -q  --brief  Output only whether files differ.
he:                    .םינוש םיצבקה םא רומא קר  -q  --brief

en: -r  --recursive  Recursively compare any subdirectories found.
he:             .יביסרוקר ןפואב תויקית-תת הוושה  -r  --recursive

en: -s  --quiet  --silent  Output nothing; yield exit status only.
he:                .דבלב האיצי דוק קפה ;טלפ אלל  -s  --quiet  --silent

en: -s  --report-identical-files  Report when two files are the same.
he:                         .םיהז םיצבק לע חווד  -s  --report-identical-files

en: -s  --suppress-common-lines  Do not output common lines.
he:                     .תוהז תורוש ללכ גיצת לא  -s  --suppress-common-lines

en: -t  --expand-tabs  Expand tabs to spaces in output.
he:                 .טלפב םיחוורל TAB יוות ךופה  -t  --expand-tabs

en: -v  --version  Output version info.
he:                        .תינכתה תסריג תא גצה  -v  --version

en: -w  --ignore-all-space  Ignore all white space.
he:                          .םיחוורה לכמ םלעתה  -w  --ignore-all-space

en: -w NUM  --width=NUM  Output at most NUM (default 130) columns per line.
he: .הרושל (130 ח"מרב) םיוות NUM רתויה לכל גצה  -w NUM  --width=NUM

en: -x  --overlap-only  Output overlapping changes.
he:                                 .םיפפוח םייוניש גצה  -x  --overlap-only

en: -x PAT  --exclude=PAT  Exclude files that match PAT.
he:   .PAT תינבתל םימיאתמ םהיתומשש םיצבק לע גלד  -x PAT  --exclude=PAT

en: -y  --side-by-side  Output in two columns.
      -W NUM  --width=NUM  Output at most NUM (default 130) print columns.
      --left-column  Output only the left column of common lines.
      --suppress-common-lines  Do not output common lines.
he:             .וז דצל וז תודומע יתשב טלפ ךורע  -y  --side-by-side
      .םיוות (130 :ח"מרב) NUM-ל טלפ תורוש לבגה  -W NUM  --width=NUM
             .תילאמשה תא קר גצה ,תוהז תורושה םא      --left-column
                        .תוהז תורוש ללכ גיצת לא      --suppress-common-lines

en: Binary files %s and %s differ
he: הזמ הז םינוש `%s'-ו `%s' םיירניב םיצבק

en: Common subdirectories: %s and %s
he: %s-ו %s :תוהז תויקית-תת

en: Compare files line by line.
he: .הרוש הרוש םיצבק ינש הוושה

en: Compare three files line by line.
he: .תיבל תיב םיצבק השלש הוושה

en: Compare two files byte by byte.
he: .תיבל תיב םיצבק ינש הוושה

en: FILES are `FILE1 FILE2' or `DIR1 DIR2' or `DIR FILE...' or `FILE... DIR'.
he: .`FILE... DIR' וא `DIR FILE...' וא `DIR1 DIR2' וא `FILE1 FILE2' םה FILES

en: File %s is a %s while file %s is a %s
he: %s %s-ל %s %s תוושהל ןתינ אל

en: Files %s and %s are identical
he: םיהז םניה %s-ו %s םיצבקה

en: Files %s and %s differ
he: הזמ הז םינוש `%s'-ו `%s' םיצבקה

en: If --from-file or --to-file is given, there are no restrictions on FILES.
he:        .FILES לע תולבגמ ןיא יזא ,--to-file וא --from-file ןייפאמ ןותנ םא

en: If a FILE is `-' or missing, read standard input.
he:              .ינקת טלק ץורעמ ארק ,ןייוצמ וניא וא `-' וניה FILE םא

en: If a FILE is `-', read standard input.
he:                                    .ינקתה טלקה ץרעמ ארק ,`-' אוה FILE םא

en: Invalid back reference
he: םדוק יוטיב-תתל היוגש היינפה

en: Invalid character class name
he: םיות תצובק לש רכומ-יתלב םש

en: Invalid collation character
he: עודי-יתלב רודיס ות

en: Invalid content of \{\}
he: \{\} ךותב יוגש הנבמ

en: Invalid preceding regular expression
he: םייק וניא וא יוגש םדוק ירלוגר יוטיב

en: Invalid range end
he: םיות םוחת לש היוגש הרדגה

en: Invalid regular expression
he: יוגש ירלוגר יוטיב

en: Memory exhausted
he: ןורכזה רמגנ

en: No match
he: המיאתמ תזורחמ האצמנ אל

en: No newline at end of file
he: ץבוקה ףוסב השדח-הרוש ות רסח

en: No previous regular expression
he: םדוק ירלוגר יוטיב ןיא

en: Only in %s: %s
he: %s-ב קר אצמנ %s

en: Premature end of regular expression
he: ידמ םדקומ םייתסמ ירלוגר יוטיב

en: Regular expression too big
he: ידמ בכרומ וא לודג ירלוגר יוטיב

en: Report bugs to <bug-gnu-utils@gnu.org>.
he: .<bug-gnu-utils@gnu.org> תבותכל תולקת לע םיחוויד חולשל אנ

en: SKIP values may be followed by the following multiplicative suffixes:
    kB 1000, K 1024, MB 1,000,000, M 1,048,576,
    GB 1,000,000,000, G 1,073,741,824, and so on for T, P, E, Z, Y.
he:                            :תוילפכ תומויס םע SKIP יכרע ןייצל ןתינ
                         ,M 1,048,576, MB 1,000,000 ,K 1024 ,kB 1000,
      .T, P, E, Z, Y רובע האלה ןכו ,G 1,073,741,824 ,GB 1,000,000,000

en: SKIP1 and SKIP2 are the number of bytes to skip in each file.
he:       .םיצבקהמ דחא לכב גלדל שי םהילע םיתבה ירפסמ םה SKIP2-ו SKIP1

en: Side-by-side merge of file differences.
he: .הז דצב הז םיצבק ןיב םייוניש לש גוזימ

en: Success
he: החלצה

en: This program comes with NO WARRANTY, to the extent permitted by law.
    You may redistribute copies of this program
    under the terms of the GNU General Public License.
    For more information about these matters, see the file named COPYING.
he:       .תאז ריתמ קוחהש המכ דע ,אוהשלכ תוירחא בתכב הוולמ הניא וז תינכות
    .GNU General Public License ןוישרה יאנתל םאתהב וז תינכות ץיפהל םכתוכז
                             .COPYING ץבוקב ונייע ,ולא םינינעב טוריפ רתיל

en: Trailing backslash
he: `\' ירוחא ןסכולב םייתסמ ירלוגר יוטיב

en: Try `%s --help' for more information.
he: .רתוי בר עדימ תגצהל `%s --help' שיקהל הסנ

en: Unknown system error
he: ההוזמ-יתלב הלקת

en: Unmatched ( or \(
he: גוז-ןב ול ןיאש \( וא (

en: Unmatched ) or \)
he: גוז-ןב ול ןיאש \) וא )

en: Unmatched [ or [^
he: גוז-ןב ול ןיאש [^ וא [

en: Unmatched \{
he: גוז-ןב ול ןיאש \{

en: Usage: %s [OPTION]... FILE1 FILE2
he: %s [OPTION]... FILE1 FILE2  :שומיש ןפוא

en: Usage: %s [OPTION]... FILE1 [FILE2 [SKIP1 [SKIP2]]]
he:    %s [OPTION]... FILE1 [FILE2 [SKIP1 [SKIP2]]] :שומיש ןפוא

en: Usage: %s [OPTION]... FILES
he: %s [OPTION]... FILES   :שומיש ןפוא

en: Usage: %s [OPTION]... MYFILE OLDFILE YOURFILE
he: %s [OPTION]... MYFILE OLDFILE YOURFILE   :שומיש ןפוא

en: Written by Paul Eggert, Mike Haertel, David Hayes,
    Richard Stallman, and Len Tower.
he:                         ,David Hayes ,Mike Haertel ,Paul Eggert י"ע בתכנ
                                                 .Len Tower-ו ,Richard Stallman

en: Written by Randy Smith.
he: .Randy Smith י"ע בתכנ

en: Written by Thomas Lord.
he: .Thomas Lord י"ע בתכנ

en: Written by Torbjorn Granlund and David MacKenzie.
he: .David MacKenzie-ו Torbjorn Granlund י"ע בתכנ

en: `-%ld' option is obsolete; omit it
he: ןשוימ וניהש `-%ld'-ב שמתשהל אל ץלמומ

en: `-%ld' option is obsolete; use `-%c %ld'
he: ןשוימ וניהש `-%ld' םוקמב `-%c %ld'-ב שמתשהל ץלמומ

en: `-' specified for more than one input file
he: דחא טלק ץבוקמ רתוי רובע `-' תנייצ

en: block special file
he: םיקולב ןקתה ץבוק

en: both files to be compared are directories
he: תויקית םניה האוושהל םיצבקה ינש

en: cannot compare `-' to a directory
he: היקיתל `-' תוושהל תורשפא ןיא

en: cannot compare file names `%s' and `%s'
he: `%s'-ו `%s' םיצבק תומש תוושהל ןתינ אל

en: cannot interactively merge standard input
he: יביטקארטניא ןפואב ינקת טלק ץורע גזמל תורשפא ןיא

en: character special file
he: םיות ןקתה ץבוק

en: cmp: EOF on %s
he: cmp: %s ץבוק ףוס

en: conflicting %s option value `%s'
he: %s ןייפאמ לש םדוק ךרע רתוס `%s' ךרע

en: conflicting output style options
he: טלפ ןונגס לש םירתוס םינייפאמ

en: conflicting width options
he: םירתוס הרוש בחור ינייפאמ

en: directory
he: היקית

en: ed:	Edit then use both versions, each decorated with a header.
    eb:	Edit then use both versions.
    el:	Edit then use the left version.
    er:	Edit then use the right version.
    e:	Edit a new version.
    l:	Use the left version.
    r:	Use the right version.
    s:	Silently include common lines.
    v:	Verbosely include common lines.
    q:	Quit.
he: ed  --  התרתוכ םע תחא לכ ,תואסרגה יתשב שמתשה זאו ,ךורע
    eb  --                    תואסרגה יתשב שמתשה זאו ,ךורע
    el  --                    לאמשמש אסרגב שמתשה זאו ,ךורע
    er  --                    ןימימש אסרגב שמתשה זאו ,ךורע
    e   --                            ירמגל השדח אסרג ךורע
    l   --                              לאמשמש אסרגב שמתשה
    r   --                              ןימימש אסרגב שמתשה
    s   --                  ןגיצהל ילבמ תופתושמ תורוש קתעה
    v   --                    ןתגצה ךות תופתושמ תורוש קתעה
    q   --  האיצי

en: extra operand `%s'
he: `%s' ירחא רתוימ טנמוגרא

en: fifo
he: fifo ץבוק

en: incompatible options
he: םירתוס םינייפאמ

en: input file shrank
he: קמטצה טלק ץבוק

en: internal error: invalid diff type in process_diff
he: process_diff תייצקנופב יוניש לש יוגש גוס :תימינפ הנכת תאיגש

en: internal error: invalid diff type passed to output
he: טלפ יכרצל יוניש לש יוגש גוס :תימינפ הנכת תאיגש

en: internal error: screwup in format of diff blocks
he: diff יעטק טמרופב החירמ :תימינפ הנכת תאיגש

en: invalid --bytes value `%s'
he: --bytes ןייפאמ רובע `%s' יוגש ךרע

en: invalid --ignore-initial value `%s'
he: --ignore-initial ןייפאמ רובע `%s' יוגש ךרע

en: invalid context length `%s'
he: `%s' יוגש רשקה ךרוא

en: invalid diff format; incomplete last line
he: המלש הניא הנורחא הרוש :יוניש לש יוגש טמרופ

en: invalid diff format; incorrect leading line chars
he: הרוש תליחתב םייוגש םיוות :יוניש לש יוגש טמרופ

en: invalid diff format; invalid change separator
he: היוגש םייוניש תדרפה תזורחמ :יוניש לש יוגש טמרופ

en: invalid horizon length `%s'
he: --horizon-lines ןייפאמב `%s' יוגש תורוש רפסמ

en: invalid width `%s'
he: `%s' יוגש הרוש בחור

en: memory exhausted
he: ןורכזה רמגנ

en: message queue
he: תועדוה רות

en: missing operand after `%s'
he: `%s' ירחא רסח טנמוגרא

en: options -l and -s are incompatible
he: הז תא הז םירתוס -s-ו -l םינייפאמה

en: pagination not supported on this host
he: וז תכרעמב טלפה דומיעב הכימת ןיא

en: program error
he: תינכתב הרומח הלקת

en: read failed
he: האירקב הלקת

en: regular empty file
he: קיר ץבוק

en: regular file
he: ץבוק

en: semaphore
he: רופמס

en: shared memory object
he: ףתושמ ןורכז טקייבוא

en: socket
he: עקש

en: stack overflow
he: תינסחמ תשילג

en: standard output
he: ינקת טלפ ץורעל

en: subsidiary program `%s' failed
he: `%s' תינכת-תת תצרהב ןולשכ

en: subsidiary program `%s' not executable
he: עוציב תב הניא `%s' תינכת-תת

en: subsidiary program `%s' not found
he: האצמנ אל `%s' תינכת-תת

en: too many file label options
he: םיצבק תיוות רובע -L ינייפאמ ידמ רתוי

en: typed memory object
he: גוויס לעב ןורכז טקייבוא

en: weird file
he: רזומ ץבוק

en: write failed
he: הביתכב הלקת
