# Kinyarwanda translations for cpplib package.
# Copyright (C) 2005 Free Software Foundation, Inc.
# This file is distributed under the same license as the cpplib package.
# Steve Murphy <murf@e-tools.com>, 2005.
# Steve performed initial rough translation from compendium built from translations provided by the following translators:
# Philibert Ndandali  <ndandali@yahoo.fr>, 2005.
# Viateur MUGENZI <muvia1@yahoo.fr>, 2005.
# Noëlla Mupole <s24211045@tuks.co.za>, 2005.
# Carole Karema <karemacarole@hotmail.com>, 2005.
# JEAN BAPTISTE NGENDAHAYO <ngenda_denis@yahoo.co.uk>, 2005.
# Augustin KIBERWA  <akiberwa@yahoo.co.uk>, 2005.
# Donatien NSENGIYUMVA <ndonatienuk@yahoo.co.uk>, 2005.
# Antoine Bigirimana <antoine@e-tools.com>, 2005.
#
msgid ""
msgstr ""
"Project-Id-Version: cpplib 3.3\n"
"Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
"POT-Creation-Date: 2007-05-13 19:48-0700\n"
"PO-Revision-Date: 2005-04-04 10:55-0700\n"
"Last-Translator: Steven Michael Murphy <murf@e-tools.com>\n"
"Language-Team: Kinyarwanda <translation-team-rw@lists.sourceforge.net>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: charset.c:654
#, fuzzy, c-format
msgid "conversion from %s to %s not supported by iconv"
msgstr "Ihindurangero Bivuye Kuri ni"

#: charset.c:657
msgid "iconv_open"
msgstr ""

#: charset.c:665
#, c-format
msgid "no iconv implementation, cannot convert from %s to %s"
msgstr ""

#: charset.c:742
#, c-format
msgid "character 0x%lx is not in the basic source character set\n"
msgstr ""

#: charset.c:759 charset.c:1352
msgid "converting to execution character set"
msgstr ""

#: charset.c:765
#, c-format
msgid "character 0x%lx is not unibyte in execution character set"
msgstr ""

#: charset.c:889
#, c-format
msgid "Character %x might not be NFKC"
msgstr ""

#: charset.c:949
#, fuzzy
msgid "universal character names are only valid in C++ and C99"
msgstr "Ky'isi yose Inyuguti Izina: OYA Byemewe in Ikiranga"

#: charset.c:952
#, fuzzy, c-format
msgid "the meaning of '\\%c' is different in traditional C"
msgstr "i Igisobanuro Bya ni in C"

#: charset.c:961
msgid "In _cpp_valid_ucn but not a UCN"
msgstr ""

#: charset.c:986
#, fuzzy, c-format
msgid "incomplete universal character name %.*s"
msgstr "Ky'isi yose Inyuguti Izina:"

#: charset.c:998
#, fuzzy, c-format
msgid "%.*s is not a valid universal character"
msgstr "`%T::%D'ni OYA a Byemewe"

#: charset.c:1008 lex.c:472
#, fuzzy
msgid "'$' in identifier or number"
msgstr "'$'Inyuguti S in Ikiranga Cyangwa Umubare"

#: charset.c:1018
#, fuzzy, c-format
msgid "universal character %.*s is not valid in an identifier"
msgstr "Ky'isi yose Inyuguti Izina: OYA Byemewe in Ikiranga"

#: charset.c:1022
#, fuzzy, c-format
msgid "universal character %.*s is not valid at the start of an identifier"
msgstr "Ky'isi yose Inyuguti Izina: OYA Byemewe in Ikiranga"

#: charset.c:1056 charset.c:1571
#, fuzzy
msgid "converting UCN to source character set"
msgstr "Guhindura.... Kuri Mweretsi Ubwoko"

#: charset.c:1060
#, fuzzy
msgid "converting UCN to execution character set"
msgstr "Guhindura.... Kuri Mweretsi Ubwoko"

#: charset.c:1132
#, fuzzy
msgid "the meaning of '\\x' is different in traditional C"
msgstr "i Igisobanuro Bya ni in C"

#: charset.c:1149
#, fuzzy
msgid "\\x used with no following hex digits"
msgstr "\\xNa: Oya"

#: charset.c:1156
#, fuzzy
msgid "hex escape sequence out of range"
msgstr "Inyuma Bya Urutonde"

#: charset.c:1195
#, fuzzy
msgid "octal escape sequence out of range"
msgstr "Inyuma Bya Urutonde"

#: charset.c:1263
#, fuzzy
msgid "the meaning of '\\a' is different in traditional C"
msgstr "i Igisobanuro Bya ni in C"

#: charset.c:1270
#, fuzzy, c-format
msgid "non-ISO-standard escape sequence, '\\%c'"
msgstr "Bisanzwe"

#: charset.c:1278
#, fuzzy, c-format
msgid "unknown escape sequence '\\%c'"
msgstr "Kitazwi"

#: charset.c:1286
#, fuzzy, c-format
msgid "unknown escape sequence: '\\%s'"
msgstr "Kitazwi"

#: charset.c:1293
#, fuzzy
msgid "converting escape sequence to execution character set"
msgstr "Inyuma Bya Urutonde"

#: charset.c:1415 charset.c:1478
#, fuzzy
msgid "character constant too long for its type"
msgstr "Inyuguti kugirango Ubwoko"

#: charset.c:1418
#, fuzzy
msgid "multi-character character constant"
msgstr "Inyuguti Inyuguti"

#: charset.c:1510
#, fuzzy
msgid "empty character constant"
msgstr "ubusa Inyuguti"

#: charset.c:1612
#, fuzzy, c-format
msgid "failure to convert %s to %s"
msgstr "OYA GUHINDURA Kuri"

#: directives.c:214 directives.c:240
#, fuzzy, c-format
msgid "extra tokens at end of #%s directive"
msgstr "Birenga ku Impera Bya"

#: directives.c:343
#, fuzzy, c-format
msgid "#%s is a GCC extension"
msgstr "#%sni a Umugereka"

#: directives.c:355
#, fuzzy
msgid "suggest not using #elif in traditional C"
msgstr "OYA ikoresha in C"

#: directives.c:358
#, fuzzy, c-format
msgid "traditional C ignores #%s with the # indented"
msgstr "C Na: i hariho marije"

#: directives.c:362
#, fuzzy, c-format
msgid "suggest hiding #%s from traditional C with an indented #"
msgstr "Bivuye C Na: hariho marije"

#: directives.c:388
#, fuzzy
msgid "embedding a directive within macro arguments is not portable"
msgstr "a muri Makoro ingingo ni OYA"

#: directives.c:408
#, fuzzy
msgid "style of line directive is a GCC extension"
msgstr "IMISUSIRE Bya Umurongo ni a Umugereka"

#: directives.c:458
#, fuzzy, c-format
msgid "invalid preprocessing directive #%s"
msgstr "Sibyo"

#: directives.c:524
#, fuzzy
msgid "\"defined\" cannot be used as a macro name"
msgstr "\"Nka a Makoro Izina:"

#: directives.c:530
#, fuzzy, c-format
msgid "\"%s\" cannot be used as a macro name as it is an operator in C++"
msgstr "\"%s\"Nka a Makoro Izina: Nka ni Mukoresha in C"

#: directives.c:533
#, fuzzy, c-format
msgid "no macro name given in #%s directive"
msgstr "Oya Makoro Izina: in"

#: directives.c:536
#, fuzzy
msgid "macro names must be identifiers"
msgstr "Makoro Amazina"

#: directives.c:577
#, c-format
msgid "undefining \"%s\""
msgstr ""

#: directives.c:632
#, fuzzy
msgid "missing terminating > character"
msgstr "Ibuze Inyuguti"

#: directives.c:687
#, fuzzy, c-format
msgid "#%s expects \"FILENAME\" or <FILENAME>"
msgstr "#%sCyangwa"

#: directives.c:727
#, fuzzy, c-format
msgid "empty filename in #%s"
msgstr "ubusa IDOSIYE Izina: in"

#: directives.c:737
#, fuzzy
msgid "#include nested too deeply"
msgstr "#Gushyiramo"

#: directives.c:778
#, fuzzy
msgid "#include_next in primary source file"
msgstr "#in Inkomoko IDOSIYE"

#: directives.c:804
#, fuzzy, c-format
msgid "invalid flag \"%s\" in line directive"
msgstr "Sibyo Ibendera in Umurongo"

#: directives.c:856
#, fuzzy, c-format
msgid "\"%s\" after #line is not a positive integer"
msgstr "\"%s\"Nyuma Umurongo ni OYA a Umubare wuzuye"

#: directives.c:862
#, fuzzy
msgid "line number out of range"
msgstr "Umurongo Umubare Inyuma Bya Urutonde"

#: directives.c:875 directives.c:952
#, fuzzy, c-format
msgid "\"%s\" is not a valid filename"
msgstr "\"%s\"ni OYA a Byemewe Izina ry'idosiye:"

#: directives.c:912
#, fuzzy, c-format
msgid "\"%s\" after # is not a positive integer"
msgstr "\"%s\"Nyuma ni OYA a Umubare wuzuye"

#: directives.c:1014
#, fuzzy, c-format
msgid "invalid #%s directive"
msgstr "Sibyo"

#: directives.c:1077
#, c-format
msgid "registering pragmas in namespace \"%s\" with mismatched name expansion"
msgstr ""

#: directives.c:1086
#, fuzzy, c-format
msgid "registering pragma \"%s\" with name expansion and no namespace"
msgstr "Nka Byombi a Na a"

#: directives.c:1104
#, fuzzy, c-format
msgid "registering \"%s\" as both a pragma and a pragma namespace"
msgstr "Nka Byombi a Na a"

#: directives.c:1107
#, fuzzy, c-format
msgid "#pragma %s %s is already registered"
msgstr "#ni"

#: directives.c:1110
#, fuzzy, c-format
msgid "#pragma %s is already registered"
msgstr "#ni"

#: directives.c:1140
msgid "registering pragma with NULL handler"
msgstr ""

#: directives.c:1350
#, fuzzy
msgid "#pragma once in main file"
msgstr "#Rimwe in IDOSIYE"

#: directives.c:1373
#, fuzzy
msgid "invalid #pragma GCC poison directive"
msgstr "Sibyo"

#: directives.c:1382
#, fuzzy, c-format
msgid "poisoning existing macro \"%s\""
msgstr "Makoro"

#: directives.c:1403
#, fuzzy
msgid "#pragma system_header ignored outside include file"
msgstr "#Hanze Gushyiramo IDOSIYE"

#: directives.c:1427
#, fuzzy, c-format
msgid "cannot find source file %s"
msgstr "Gushaka Inkomoko"

#: directives.c:1431
#, fuzzy, c-format
msgid "current file is older than %s"
msgstr "KIGEZWEHO IDOSIYE ni"

#: directives.c:1599
#, fuzzy
msgid "_Pragma takes a parenthesized string literal"
msgstr "a Ikurikiranyanyuguti"

#: directives.c:1671
#, fuzzy
msgid "#else without #if"
msgstr "#Ikindi NIBA"

#: directives.c:1676
#, fuzzy
msgid "#else after #else"
msgstr "#Ikindi Nyuma Ikindi"

#: directives.c:1678 directives.c:1711
#, fuzzy
msgid "the conditional began here"
msgstr "i"

#: directives.c:1704
#, fuzzy
msgid "#elif without #if"
msgstr "#NIBA"

#: directives.c:1709
#, fuzzy
msgid "#elif after #else"
msgstr "#Nyuma Ikindi"

#: directives.c:1739
#, fuzzy
msgid "#endif without #if"
msgstr "#NIBA"

#: directives.c:1816
#, fuzzy
msgid "missing '(' after predicate"
msgstr "Ibuze Nyuma"

#: directives.c:1831
#, fuzzy
msgid "missing ')' to complete answer"
msgstr "Ibuze Kuri Byuzuye"

#: directives.c:1851
#, fuzzy
msgid "predicate's answer is empty"
msgstr "ni ubusa"

#: directives.c:1878
msgid "assertion without predicate"
msgstr ""

#: directives.c:1880
#, fuzzy
msgid "predicate must be an identifier"
msgstr "Ikiranga"

#: directives.c:1966
#, c-format
msgid "\"%s\" re-asserted"
msgstr ""

#: directives.c:2190
#, c-format
msgid "unterminated #%s"
msgstr ""

#: errors.c:118
#, fuzzy
msgid "warning: "
msgstr "Iburira!"

#: errors.c:120
#, fuzzy
msgid "internal error: "
msgstr "Ikosa ry'imbere"

#: errors.c:122
#, fuzzy
msgid "error: "
msgstr "Ikosa ry'imbere"

#: errors.c:186
msgid "stdout"
msgstr ""

# desktop/source\app\ssodlg.src:DLG_SSOLOGIN.text
#: errors.c:188
#, fuzzy, c-format
msgid "%s: %s"
msgstr "%s:%s"

#: expr.c:203
#, fuzzy
msgid "too many decimal points in number"
msgstr "NYACUMI Utudomo in Umubare"

#: expr.c:223
#, fuzzy, c-format
msgid "invalid digit \"%c\" in octal constant"
msgstr "Sibyo in"

#: expr.c:229
#, fuzzy
msgid "use of C99 hexadecimal floating constant"
msgstr "Gukoresha Bya Bihindagurika"

#: expr.c:238
#, fuzzy
msgid "exponent has no digits"
msgstr "Oya"

#: expr.c:245
#, fuzzy
msgid "hexadecimal floating constants require an exponent"
msgstr "Bihindagurika"

#: expr.c:251
#, fuzzy, c-format
msgid "invalid suffix \"%.*s\" on floating constant"
msgstr "Sibyo Ingereka S ku Bihindagurika"

#: expr.c:261 expr.c:295
#, fuzzy, c-format
msgid "traditional C rejects the \"%.*s\" suffix"
msgstr "C i S Ingereka"

#: expr.c:268
#, fuzzy, c-format
msgid "invalid suffix \"%.*s\" with hexadecimal floating constant"
msgstr "Sibyo Ingereka S ku Bihindagurika"

#: expr.c:281
#, fuzzy, c-format
msgid "invalid suffix \"%.*s\" on integer constant"
msgstr "Sibyo Ingereka S ku Umubare wuzuye"

#: expr.c:303
#, fuzzy
msgid "use of C99 long long integer constant"
msgstr "Gukoresha Bya Umubare wuzuye"

#: expr.c:310
#, fuzzy
msgid "imaginary constants are a GCC extension"
msgstr "NYURABWENGE a Umugereka"

#: expr.c:396
#, fuzzy
msgid "integer constant is too large for its type"
msgstr "Umubare wuzuye ni Binini kugirango Ubwoko"

#: expr.c:408
#, fuzzy
msgid "integer constant is so large that it is unsigned"
msgstr "Umubare wuzuye ni Binini ni Bitashizweho umukono"

#: expr.c:490
#, fuzzy
msgid "missing ')' after \"defined\""
msgstr "Ibuze Nyuma"

#: expr.c:497
#, fuzzy
msgid "operator \"defined\" requires an identifier"
msgstr "Mukoresha Ikiranga"

#: expr.c:505
#, fuzzy, c-format
msgid "(\"%s\" is an alternative token for \"%s\" in C++)"
msgstr "(\"%s\"ni kugirango in C"

#: expr.c:515
#, fuzzy
msgid "this use of \"defined\" may not be portable"
msgstr "iyi Gukoresha Bya Gicurasi OYA"

#: expr.c:554
#, fuzzy
msgid "floating constant in preprocessor expression"
msgstr "Bihindagurika in imvugo"

#: expr.c:560
#, fuzzy
msgid "imaginary number in preprocessor expression"
msgstr "NYURABWENGE Umubare in imvugo"

#: expr.c:605
#, fuzzy, c-format
msgid "\"%s\" is not defined"
msgstr "\"%s\"ni OYA"

#: expr.c:733 expr.c:762
#, fuzzy, c-format
msgid "missing binary operator before token \"%s\""
msgstr "Ibuze Nyabibiri Mukoresha Mbere"

#: expr.c:753
#, fuzzy, c-format
msgid "token \"%s\" is not valid in preprocessor expressions"
msgstr "ni OYA Byemewe in"

#: expr.c:770
#, fuzzy
msgid "missing expression between '(' and ')'"
msgstr "imvugo hagati Na"

#: expr.c:773
#, fuzzy
msgid "#if with no expression"
msgstr "#NIBA Na: Oya imvugo"

#: expr.c:776
#, fuzzy, c-format
msgid "operator '%s' has no right operand"
msgstr "Mukoresha Oya Iburyo:"

#: expr.c:781
#, fuzzy, c-format
msgid "operator '%s' has no left operand"
msgstr "Mukoresha Oya Iburyo:"

#: expr.c:807
msgid " ':' without preceding '?'"
msgstr ""

#: expr.c:834
#, fuzzy
msgid "unbalanced stack in #if"
msgstr "in NIBA"

#: expr.c:853
#, fuzzy, c-format
msgid "impossible operator '%u'"
msgstr "Mukoresha"

#: expr.c:943
#, fuzzy
msgid "missing ')' in expression"
msgstr "Ibuze in imvugo"

#: expr.c:964
#, fuzzy
msgid "'?' without following ':'"
msgstr ""
"''Project- Id- Version: basctl\n"
"POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
"PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
"Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
"Content- Type: text/ plain; charset= UTF- 8\n"
"Content- Transfer- Encoding: 8bit\n"
"X- Generator: KBabel 1. 0\n"
"."

#: expr.c:974
#, fuzzy
msgid "integer overflow in preprocessor expression"
msgstr "Umubare wuzuye Byarenze urugero in imvugo"

#: expr.c:979
#, fuzzy
msgid "missing '(' in expression"
msgstr "Ibuze in imvugo"

#: expr.c:1011
#, fuzzy, c-format
msgid "the left operand of \"%s\" changes sign when promoted"
msgstr "i Ibumoso: Bya Amahinduka IKIMENYETSO Ryari:"

#: expr.c:1016
#, fuzzy, c-format
msgid "the right operand of \"%s\" changes sign when promoted"
msgstr "i Iburyo: Bya Amahinduka IKIMENYETSO Ryari:"

#: expr.c:1275
#, fuzzy
msgid "traditional C rejects the unary plus operator"
msgstr "C i Guteranya Mukoresha"

#: expr.c:1358
#, fuzzy
msgid "comma operator in operand of #if"
msgstr "Akitso Mukoresha in Bya NIBA"

#: expr.c:1490
#, fuzzy
msgid "division by zero in #if"
msgstr "ku Zeru in NIBA"

#: files.c:402
msgid "NULL directory in find_file"
msgstr ""

#: files.c:440
msgid "one or more PCH files were found, but they were invalid"
msgstr ""

#: files.c:443
msgid "use -Winvalid-pch for more information"
msgstr ""

#: files.c:501
#, fuzzy, c-format
msgid "%s is a block device"
msgstr "%sni a Funga APAREYE"

#: files.c:518
#, fuzzy, c-format
msgid "%s is too large"
msgstr "%sni Binini"

#: files.c:553
#, fuzzy, c-format
msgid "%s is shorter than expected"
msgstr "%sni Ikitezwe:"

#: files.c:782
#, fuzzy, c-format
msgid "no include path in which to search for %s"
msgstr "Oya Gushyiramo Inzira in Kuri Gushaka"

#: files.c:1071
#, fuzzy
msgid "Multiple include guards may be useful for:\n"
msgstr "Gushyiramo Gicurasi kugirango"

#: init.c:407
#, fuzzy
msgid "cppchar_t must be an unsigned type"
msgstr "Bitashizweho umukono Ubwoko"

#: init.c:411
#, fuzzy, c-format
msgid "preprocessor arithmetic has maximum precision of %lu bits; target requires %lu bits"
msgstr "Kinini Bya Intego"

#: init.c:418
#, fuzzy
msgid "CPP arithmetic must be at least as precise as a target int"
msgstr "ku Nka Nka a Intego INT"

#: init.c:421
#, fuzzy
msgid "target char is less than 8 bits wide"
msgstr "Intego INYUGUTI ni Birutwa 8"

#: init.c:425
#, fuzzy
msgid "target wchar_t is narrower than target char"
msgstr "Intego ni Intego INYUGUTI"

#: init.c:429
#, fuzzy
msgid "target int is narrower than target char"
msgstr "Intego INT ni Intego INYUGUTI"

#: init.c:434
#, fuzzy
msgid "CPP half-integer narrower than CPP character"
msgstr "Umubare wuzuye Inyuguti"

#: init.c:438
#, fuzzy, c-format
msgid "CPP on this host cannot handle wide character constants over %lu bits, but the target requires %lu bits"
msgstr "ku iyi Ubuturo Inyuguti KURI i Intego"

#: lex.c:271
#, fuzzy
msgid "backslash and newline separated by space"
msgstr "Na ku Umwanya"

#: lex.c:276
#, fuzzy
msgid "backslash-newline at end of file"
msgstr "ku Impera Bya IDOSIYE"

#: lex.c:291
#, fuzzy, c-format
msgid "trigraph ??%c converted to %c"
msgstr ""
"Project- Id- Version: basctl\n"
"POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
"PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
"Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
"Content- Type: text/ plain; charset= UTF- 8\n"
"Content- Transfer- Encoding: 8bit\n"
"X- Generator: KBabel 1. 0\n"
"."

#: lex.c:298
#, fuzzy, c-format
msgid "trigraph ??%c ignored, use -trigraphs to enable"
msgstr ""
"Project- Id- Version: basctl\n"
"POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
"PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
"Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
"Content- Type: text/ plain; charset= UTF- 8\n"
"Content- Transfer- Encoding: 8bit\n"
"X- Generator: KBabel 1. 0\n"
"."

#: lex.c:344
#, fuzzy
msgid "\"/*\" within comment"
msgstr "\"/*\"muri Icyo wongeraho"

#: lex.c:402
#, fuzzy, c-format
msgid "%s in preprocessing directive"
msgstr "%sin"

#: lex.c:411
#, fuzzy
msgid "null character(s) ignored"
msgstr "NTAGIHARI Inyuguti S"

#: lex.c:448
#, fuzzy, c-format
msgid "`%.*s' is not in NFKC"
msgstr "\"%s\"ni OYA"

#: lex.c:451
#, fuzzy, c-format
msgid "`%.*s' is not in NFC"
msgstr "\"%s\"ni OYA"

#: lex.c:539
#, fuzzy, c-format
msgid "attempt to use poisoned \"%s\""
msgstr "Kuri Gukoresha"

#: lex.c:547
#, fuzzy
msgid "__VA_ARGS__ can only appear in the expansion of a C99 variadic macro"
msgstr "_Kugaragara in i Bya a Makoro"

#: lex.c:647
#, fuzzy
msgid "null character(s) preserved in literal"
msgstr "NTAGIHARI Inyuguti S in"

#: lex.c:650
#, fuzzy, c-format
msgid "missing terminating %c character"
msgstr "Ibuze Inyuguti"

#: lex.c:842
#, fuzzy
msgid "no newline at end of file"
msgstr "Oya ku Impera Bya IDOSIYE"

#: lex.c:1002 traditional.c:162
#, fuzzy
msgid "unterminated comment"
msgstr "Icyo wongeraho"

#: lex.c:1013
#, fuzzy
msgid "C++ style comments are not allowed in ISO C90"
msgstr "C IMISUSIRE Ibisobanuro OYA in"

#: lex.c:1015
#, fuzzy
msgid "(this will be reported only once per input file)"
msgstr "(iyi Rimwe Iyinjiza IDOSIYE"

#: lex.c:1020
#, fuzzy
msgid "multi-line comment"
msgstr "Umurongo Icyo wongeraho"

#: lex.c:1333
#, c-format
msgid "unspellable token %s"
msgstr ""

#: line-map.c:313
#, fuzzy, c-format
msgid "In file included from %s:%u"
msgstr "IDOSIYE Bivuye"

#: line-map.c:331
#, fuzzy, c-format
msgid ""
",\n"
"                 from %s:%u"
msgstr ",Bivuye"

#: macro.c:83
#, fuzzy, c-format
msgid "macro \"%s\" is not used"
msgstr "Makoro ni OYA"

#: macro.c:122 macro.c:312
#, fuzzy, c-format
msgid "invalid built-in macro \"%s\""
msgstr "Sibyo in Makoro"

#: macro.c:156
#, fuzzy
msgid "could not determine file timestamp"
msgstr "OYA Itariki Na Igihe"

#: macro.c:253
#, fuzzy
msgid "could not determine date and time"
msgstr "OYA Itariki Na Igihe"

#: macro.c:416
#, fuzzy
msgid "invalid string literal, ignoring final '\\'"
msgstr "Sibyo Ikurikiranyanyuguti"

#: macro.c:466
#, fuzzy, c-format
msgid "pasting \"%s\" and \"%s\" does not give a valid preprocessing token"
msgstr "Na OYA a Byemewe"

#: macro.c:538
#, fuzzy
msgid "ISO C99 requires rest arguments to be used"
msgstr "ingingo Kuri"

#: macro.c:543
#, fuzzy, c-format
msgid "macro \"%s\" requires %u arguments, but only %u given"
msgstr "Makoro ingingo"

#: macro.c:548
#, fuzzy, c-format
msgid "macro \"%s\" passed %u arguments, but takes just %u"
msgstr "Makoro ingingo"

#: macro.c:659 traditional.c:675
#, fuzzy, c-format
msgid "unterminated argument list invoking macro \"%s\""
msgstr "Urutonde Makoro"

#: macro.c:762
#, fuzzy, c-format
msgid "function-like macro \"%s\" must be used with arguments in traditional C"
msgstr "Umumaro nka Makoro Na: ingingo in C"

#: macro.c:1278
#, fuzzy, c-format
msgid "duplicate macro parameter \"%s\""
msgstr "Gusubiramo Makoro"

#: macro.c:1324
#, fuzzy, c-format
msgid "\"%s\" may not appear in macro parameter list"
msgstr "\"%s\"Gicurasi OYA Kugaragara in Makoro Urutonde"

#: macro.c:1332
#, fuzzy
msgid "macro parameters must be comma-separated"
msgstr "Makoro Ibigenga Akitso"

#: macro.c:1349
#, fuzzy
msgid "parameter name missing"
msgstr "Izina: Ibuze"

#: macro.c:1366
#, fuzzy
msgid "anonymous variadic macros were introduced in C99"
msgstr "Makoro in"

#: macro.c:1371
#, fuzzy
msgid "ISO C does not permit named variadic macros"
msgstr "C OYA Makoro"

#: macro.c:1380
#, fuzzy
msgid "missing ')' in macro parameter list"
msgstr "Ibuze in Makoro Urutonde"

#: macro.c:1458
#, fuzzy
msgid "ISO C99 requires whitespace after the macro name"
msgstr "C Nyuma i Makoro Izina:"

#: macro.c:1482
#, fuzzy
msgid "missing whitespace after the macro name"
msgstr "C Nyuma i Makoro Izina:"

#: macro.c:1512
#, fuzzy
msgid "'#' is not followed by a macro parameter"
msgstr "'#'ni OYA ku a Makoro"

#: macro.c:1531
#, fuzzy
msgid "'##' cannot appear at either end of a macro expansion"
msgstr "'##'Kugaragara ku Impera Bya a Makoro"

#: macro.c:1629
#, c-format
msgid "\"%s\" redefined"
msgstr ""

#: macro.c:1634
#, fuzzy
msgid "this is the location of the previous definition"
msgstr "iyi ni i Ahantu Bya i Ibanjirije Insobanuro"

#: macro.c:1684
#, fuzzy, c-format
msgid "macro argument \"%s\" would be stringified in traditional C"
msgstr "Makoro in C"

#: macro.c:1707
#, fuzzy, c-format
msgid "invalid hash type %d in cpp_macro_definition"
msgstr "Sibyo Ubwoko in"

#: pch.c:84 pch.c:332 pch.c:354 pch.c:360
msgid "while writing precompiled header"
msgstr ""

#: pch.c:467
#, fuzzy, c-format
msgid "%s: not used because `%.*s' not defined"
msgstr "Akarango OYA"

#: pch.c:479
#, c-format
msgid "%s: not used because `%.*s' defined as `%s' not `%.*s'"
msgstr ""

#: pch.c:520
#, fuzzy, c-format
msgid "%s: not used because `%s' is defined"
msgstr "`%s'Nta narimwe"

#: pch.c:533 pch.c:696
msgid "while reading precompiled header"
msgstr ""

#: traditional.c:745
#, fuzzy, c-format
msgid "detected recursion whilst expanding macro \"%s\""
msgstr "Makoro"

#: traditional.c:912
#, fuzzy
msgid "syntax error in macro parameter list"
msgstr "\"%s\"Gicurasi OYA Kugaragara in Makoro Urutonde"

#, fuzzy
#~ msgid "`%s' attribute directive ignored"
#~ msgstr "`%s'Ikiranga"

#, fuzzy
#~ msgid "wrong number of arguments specified for `%s' attribute"
#~ msgstr "Umubare Bya ingingo kugirango Ikiranga"

#, fuzzy
#~ msgid "`%s' attribute does not apply to types"
#~ msgstr "`%s'Ikiranga OYA Gukurikiza Kuri"

#, fuzzy
#~ msgid "`%s' attribute only applies to function types"
#~ msgstr "`%s'Ikiranga Kuri Umumaro"

#, fuzzy
#~ msgid "`%s' attribute ignored"
#~ msgstr "`%s'Ikiranga"

#, fuzzy
#~ msgid "offset outside bounds of constant string"
#~ msgstr "Nta- boneza Hanze Bya Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "second arg to `__builtin_prefetch' must be a constant"
#~ msgstr "ISEGONDA Kuri a"

#, fuzzy
#~ msgid "invalid second arg to __builtin_prefetch; using zero"
#~ msgstr "Sibyo ISEGONDA Kuri ikoresha Zeru"

#, fuzzy
#~ msgid "third arg to `__builtin_prefetch' must be a constant"
#~ msgstr "Kuri a"

#, fuzzy
#~ msgid "invalid third arg to __builtin_prefetch; using zero"
#~ msgstr "Sibyo Kuri ikoresha Zeru"

#, fuzzy
#~ msgid "__builtin_saveregs not supported by this target"
#~ msgstr "_OYA ku iyi Intego"

#, fuzzy
#~ msgid "argument of `__builtin_args_info' must be constant"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "argument of `__builtin_args_info' out of range"
#~ msgstr "Bya Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "missing argument in `__builtin_args_info'"
#~ msgstr "Ibuze in"

#, fuzzy
#~ msgid "`va_start' used in function with fixed args"
#~ msgstr "`in Umumaro Na: BIHAMYE"

#, fuzzy
#~ msgid "second parameter of `va_start' not last named argument"
#~ msgstr "ISEGONDA Bya OYA Iheruka"

#, fuzzy
#~ msgid "too many arguments to function `va_start'"
#~ msgstr "ingingo Kuri Umumaro"

#, fuzzy
#~ msgid "first argument to `va_arg' not of type `va_list'"
#~ msgstr "Itangira Kuri OYA Bya Ubwoko"

#, fuzzy
#~ msgid "`%s' is promoted to `%s' when passed through `...'"
#~ msgstr "`%s'ni Kuri Ryari: Gihinguranya"

#, fuzzy
#~ msgid "(so you should pass `%s' not `%s' to `va_arg')"
#~ msgstr "(OYA Kuri"

#, fuzzy
#~ msgid "invalid arg to `__builtin_frame_address'"
#~ msgstr "Sibyo Kuri"

#, fuzzy
#~ msgid "invalid arg to `__builtin_return_address'"
#~ msgstr "Sibyo Kuri"

#, fuzzy
#~ msgid "unsupported arg to `__builtin_frame_address'"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "unsupported arg to `__builtin_return_address'"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "second arg to `__builtin_expect' must be a constant"
#~ msgstr "ISEGONDA Kuri a"

#, fuzzy
#~ msgid "__builtin_longjmp second argument must be 1"
#~ msgstr "_ISEGONDA 1."

#, fuzzy
#~ msgid "built-in function `%s' not currently supported"
#~ msgstr "in Umumaro OYA"

#, fuzzy
#~ msgid "target format does not support infinity"
#~ msgstr "Intego Imiterere OYA Gushigikira Bidashira"

#, fuzzy
#~ msgid "`%s' is not defined outside of function scope"
#~ msgstr "`%s'ni OYA Hanze Bya Umumaro Ingano:"

#, fuzzy
#~ msgid "string length `%d' is greater than the length `%d' ISO C%d compilers are required to support"
#~ msgstr "Ikurikiranyanyuguti Uburebure ni Biruta i Uburebure C Bya ngombwa Kuri Gushigikira"

#, fuzzy
#~ msgid "concatenation of string literals with __FUNCTION__ is deprecated"
#~ msgstr "Bya Ikurikiranyanyuguti Na: ni Bitemewe."

#, fuzzy
#~ msgid "overflow in constant expression"
#~ msgstr "Byarenze urugero in imvugo"

#, fuzzy
#~ msgid "integer overflow in expression"
#~ msgstr "Umubare wuzuye Byarenze urugero in imvugo"

#, fuzzy
#~ msgid "floating point overflow in expression"
#~ msgstr "Bihindagurika Akadomo Byarenze urugero in imvugo"

#, fuzzy
#~ msgid "vector overflow in expression"
#~ msgstr "Byarenze urugero in imvugo"

#, fuzzy
#~ msgid "large integer implicitly truncated to unsigned type"
#~ msgstr "Binini Umubare wuzuye Kuri Bitashizweho umukono Ubwoko"

#, fuzzy
#~ msgid "negative integer implicitly converted to unsigned type"
#~ msgstr "Umubare wuzuye Kuri Bitashizweho umukono Ubwoko"

#, fuzzy
#~ msgid "overflow in implicit constant conversion"
#~ msgstr "Byarenze urugero in Ihindurangero"

#, fuzzy
#~ msgid "operation on `%s' may be undefined"
#~ msgstr "ku Gicurasi kidasobanuye"

#, fuzzy
#~ msgid "expression statement has incomplete type"
#~ msgstr "imvugo Inyandiko Ubwoko"

#, fuzzy
#~ msgid "case label does not reduce to an integer constant"
#~ msgstr "Akarango OYA Kuri Umubare wuzuye"

#, fuzzy
#~ msgid "invalid truth-value expression"
#~ msgstr "Sibyo Agaciro imvugo"

#, fuzzy
#~ msgid "invalid operands to binary %s"
#~ msgstr "Sibyo Kuri Nyabibiri"

#, fuzzy
#~ msgid "comparison is always false due to limited range of data type"
#~ msgstr "ni Buri gihe SIBYO Kuri Urutonde Bya Ibyatanzwe Ubwoko"

#, fuzzy
#~ msgid "comparison is always true due to limited range of data type"
#~ msgstr "ni Buri gihe NIBYO Kuri Urutonde Bya Ibyatanzwe Ubwoko"

#, fuzzy
#~ msgid "comparison of unsigned expression >= 0 is always true"
#~ msgstr "Bya Bitashizweho umukono imvugo 0 ni Buri gihe NIBYO"

#, fuzzy
#~ msgid "comparison of unsigned expression < 0 is always false"
#~ msgstr "Bya Bitashizweho umukono imvugo 0 ni Buri gihe SIBYO"

#, fuzzy
#~ msgid "pointer of type `void *' used in arithmetic"
#~ msgstr "Mweretsi Bya Ubwoko in"

#, fuzzy
#~ msgid "pointer to a function used in arithmetic"
#~ msgstr "Mweretsi Kuri a Umumaro in"

#, fuzzy
#~ msgid "pointer to member function used in arithmetic"
#~ msgstr "Mweretsi Kuri Umumaro in"

#, fuzzy
#~ msgid "pointer to a member used in arithmetic"
#~ msgstr "Mweretsi Kuri a in"

#, fuzzy
#~ msgid "struct type value used where scalar is required"
#~ msgstr "Ubwoko Agaciro ni Bya ngombwa"

#, fuzzy
#~ msgid "union type value used where scalar is required"
#~ msgstr "Ihuza Ubwoko Agaciro ni Bya ngombwa"

#, fuzzy
#~ msgid "array type value used where scalar is required"
#~ msgstr "Imbonerahamwe Ubwoko Agaciro ni Bya ngombwa"

#, fuzzy
#~ msgid "suggest parentheses around assignment used as truth value"
#~ msgstr "Igenera Nka Agaciro"

#, fuzzy
#~ msgid "invalid use of `restrict'"
#~ msgstr "Sibyo Gukoresha Bya"

#, fuzzy
#~ msgid "invalid application of `sizeof' to a function type"
#~ msgstr "Sibyo Porogaramu Bya Kuri a Umumaro Ubwoko"

#, fuzzy
#~ msgid "invalid application of `%s' to a void type"
#~ msgstr "Sibyo Porogaramu Bya Kuri a Ubwoko"

#, fuzzy
#~ msgid "invalid application of `%s' to an incomplete type"
#~ msgstr "Sibyo Porogaramu Bya Kuri Ubwoko"

#, fuzzy
#~ msgid "`__alignof' applied to a bit-field"
#~ msgstr "`_Byashyizweho Kuri a Umwanya"

#, fuzzy
#~ msgid "cannot disable built-in function `%s'"
#~ msgstr "in Umumaro"

#, fuzzy
#~ msgid "too few arguments to function `%s'"
#~ msgstr "ingingo Kuri Umumaro"

#, fuzzy
#~ msgid "too many arguments to function `%s'"
#~ msgstr "ingingo Kuri Umumaro"

#, fuzzy
#~ msgid "non-floating-point argument to function `%s'"
#~ msgstr "Bihindagurika Akadomo Kuri Umumaro"

#, fuzzy
#~ msgid "pointers are not permitted as case values"
#~ msgstr "OYA Nka Uduciro"

#, fuzzy
#~ msgid "ISO C++ forbids range expressions in switch statements"
#~ msgstr "C Urutonde in Hindura"

#, fuzzy
#~ msgid "ISO C forbids range expressions in switch statements"
#~ msgstr "C Urutonde in Hindura"

#, fuzzy
#~ msgid "empty range specified"
#~ msgstr "ubusa Urutonde"

#, fuzzy
#~ msgid "duplicate (or overlapping) case value"
#~ msgstr "Gusubiramo Cyangwa iyorosa Agaciro"

#, fuzzy
#~ msgid "this is the first entry overlapping that value"
#~ msgstr "iyi ni i Itangira Icyinjijwe iyorosa Agaciro"

#, fuzzy
#~ msgid "duplicate case value"
#~ msgstr "Gusubiramo Agaciro"

#, fuzzy
#~ msgid "multiple default labels in one switch"
#~ msgstr "Igikubo Mburabuzi Uturango... in Hindura"

#, fuzzy
#~ msgid "this is the first default label"
#~ msgstr "iyi ni i Itangira Mburabuzi Akarango"

#, fuzzy
#~ msgid "ISO C++ forbids taking the address of a label"
#~ msgstr "C i Aderesi Bya a Akarango"

#, fuzzy
#~ msgid "ISO C forbids taking the address of a label"
#~ msgstr "C i Aderesi Bya a Akarango"

#, fuzzy
#~ msgid "declaration of `%s' shadows %s"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "unknown machine mode `%s'"
#~ msgstr "Kitazwi Ubwoko"

#, fuzzy
#~ msgid "no data type for mode `%s'"
#~ msgstr "Oya Ibyatanzwe Ubwoko kugirango Ubwoko"

#, fuzzy
#~ msgid "unable to emulate '%s'"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "section attribute cannot be specified for local variables"
#~ msgstr "Icyiciro Ikiranga kugirango Ibihinduka"

#, fuzzy
#~ msgid "section of `%s' conflicts with previous declaration"
#~ msgstr "Icyiciro Bya Na: Ibanjirije"

#, fuzzy
#~ msgid "section attribute not allowed for `%s'"
#~ msgstr "Icyiciro Ikiranga OYA kugirango"

#, fuzzy
#~ msgid "section attributes are not supported for this target"
#~ msgstr "Icyiciro Ibiranga OYA kugirango iyi Intego"

#, fuzzy
#~ msgid "requested alignment is not a constant"
#~ msgstr "Itunganya ni OYA a"

#, fuzzy
#~ msgid "requested alignment is not a power of 2"
#~ msgstr "Itunganya ni OYA a UMWIKUBE Bya 2."

#, fuzzy
#~ msgid "requested alignment is too large"
#~ msgstr "Itunganya ni Binini"

#, fuzzy
#~ msgid "alignment may not be specified for `%s'"
#~ msgstr "Itunganya Gicurasi OYA kugirango"

#, fuzzy
#~ msgid "`%s' defined both normally and as an alias"
#~ msgstr "`%s'Byombi Na Nka Irihimbano"

#, fuzzy
#~ msgid "alias arg not a string"
#~ msgstr "Irihimbano OYA a Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "visibility arg not a string"
#~ msgstr "Ukugaragara OYA a Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\""
#~ msgstr "Ukugaragara Bya Mburabuzi gihishwe Birinzwe Cyangwa By'imbere"

#, fuzzy
#~ msgid "tls_model arg not a string"
#~ msgstr "OYA a Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\""
#~ msgstr "Bya Cyangwa"

#, fuzzy
#~ msgid "`%s' attribute applies only to functions"
#~ msgstr "`%s'Ikiranga Kuri Imimaro"

#, fuzzy
#~ msgid "can't set `%s' attribute after definition"
#~ msgstr "Gushyiraho Ikiranga Nyuma Insobanuro"

#, fuzzy
#~ msgid "`%s' attribute ignored for `%s'"
#~ msgstr "`%s'Ikiranga kugirango"

#, fuzzy
#~ msgid "invalid vector type for attribute `%s'"
#~ msgstr "Sibyo Ubwoko kugirango Ikiranga"

#, fuzzy
#~ msgid "no vector mode with the size and type specified could be found"
#~ msgstr "Oya Ubwoko Na: i Ingano Na Ubwoko Byabonetse"

#, fuzzy
#~ msgid "nonnull attribute without arguments on a non-prototype"
#~ msgstr "Ikiranga ingingo ku a"

#, fuzzy
#~ msgid "nonnull argument has invalid operand number (arg %lu)"
#~ msgstr "Sibyo Umubare"

#, fuzzy
#~ msgid "nonnull argument with out-of-range operand number (arg %lu, operand %lu)"
#~ msgstr "Na: Inyuma Bya Urutonde Umubare"

#, fuzzy
#~ msgid "nonnull argument references non-pointer operand (arg %lu, operand %lu)"
#~ msgstr "Indango Mweretsi"

#, fuzzy
#~ msgid "null argument where non-null required (arg %lu)"
#~ msgstr "NTAGIHARI NTAGIHARI Bya ngombwa"

#, fuzzy
#~ msgid "void value not ignored as it ought to be"
#~ msgstr "Agaciro OYA Nka Kuri"

#, fuzzy
#~ msgid "conversion to non-scalar type requested"
#~ msgstr "Ihindurangero Kuri Ubwoko"

#, fuzzy
#~ msgid "array `%s' assumed to have one element"
#~ msgstr "Imbonerahamwe Kuri Ikigize:"

#, fuzzy
#~ msgid "`struct %s' incomplete in scope ending here"
#~ msgstr "`in Ingano:"

#, fuzzy
#~ msgid "`union %s' incomplete in scope ending here"
#~ msgstr "`Ihuza in Ingano:"

#, fuzzy
#~ msgid "`enum %s' incomplete in scope ending here"
#~ msgstr "`in Ingano:"

#, fuzzy
#~ msgid "label `%s' defined but not used"
#~ msgstr "Akarango OYA"

#, fuzzy
#~ msgid "function `%s' redeclared as inline"
#~ msgstr "Umumaro Nka Mumurongo"

#, fuzzy
#~ msgid "previous declaration of function `%s' with attribute noinline"
#~ msgstr "Ibanjirije Bya Umumaro Na: Ikiranga"

#, fuzzy
#~ msgid "function `%s' redeclared with attribute noinline"
#~ msgstr "Umumaro Na: Ikiranga"

#, fuzzy
#~ msgid "previous declaration of function `%s' was inline"
#~ msgstr "Ibanjirije Bya Umumaro Mumurongo"

#, fuzzy
#~ msgid "shadowing built-in function `%s'"
#~ msgstr "Ishyiraho ry'igicucu in Umumaro"

#, fuzzy
#~ msgid "shadowing library function `%s'"
#~ msgstr "Ishyiraho ry'igicucu Isomero Umumaro"

#, fuzzy
#~ msgid "library function `%s' declared as non-function"
#~ msgstr "Isomero Umumaro Nka Umumaro"

#, fuzzy
#~ msgid "built-in function `%s' declared as non-function"
#~ msgstr "in Umumaro Nka Umumaro"

#, fuzzy
#~ msgid "`%s' redeclared as different kind of symbol"
#~ msgstr "`%s'Nka Bya IKIMENYETSO"

#, fuzzy
#~ msgid "previous declaration of `%s'"
#~ msgstr "Ibanjirije Bya"

#, fuzzy
#~ msgid "conflicting types for built-in function `%s'"
#~ msgstr "kugirango in Umumaro"

#, fuzzy
#~ msgid "conflicting types for `%s'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "a parameter list with an ellipsis can't match an empty parameter name list declaration"
#~ msgstr "a Urutonde Na: BIHUYE ubusa Izina: Urutonde"

#, fuzzy
#~ msgid "an argument type that has a default promotion can't match an empty parameter name list declaration"
#~ msgstr "Ubwoko a Mburabuzi BIHUYE ubusa Izina: Urutonde"

#, fuzzy
#~ msgid "thread-local declaration of `%s' follows non thread-local declaration"
#~ msgstr "Urudodo Bya Urudodo"

#, fuzzy
#~ msgid "non thread-local declaration of `%s' follows thread-local declaration"
#~ msgstr "Urudodo Bya Urudodo"

#, fuzzy
#~ msgid "redefinition of `%s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "redeclaration of `%s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "conflicting declarations of `%s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "prototype for `%s' follows"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "non-prototype definition here"
#~ msgstr "Insobanuro"

#, fuzzy
#~ msgid "prototype for `%s' follows and number of arguments doesn't match"
#~ msgstr "kugirango Na Umubare Bya ingingo BIHUYE"

#, fuzzy
#~ msgid "prototype for `%s' follows and argument %d doesn't match"
#~ msgstr "kugirango Na BIHUYE"

#, fuzzy
#~ msgid "`%s' declared inline after being called"
#~ msgstr "`%s'Mumurongo Nyuma"

#, fuzzy
#~ msgid "`%s' declared inline after its definition"
#~ msgstr "`%s'Mumurongo Nyuma Insobanuro"

#, fuzzy
#~ msgid "static declaration for `%s' follows non-static"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "non-static declaration for `%s' follows static"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "const declaration for `%s' follows non-const"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "type qualifiers for `%s' conflict with previous decl"
#~ msgstr "Ubwoko kugirango Na: Ibanjirije"

#, fuzzy
#~ msgid "redundant redeclaration of `%s' in same scope"
#~ msgstr "Bya in Ingano:"

#, fuzzy
#~ msgid "declaration of `%s' shadows a parameter"
#~ msgstr "Bya a"

#, fuzzy
#~ msgid "declaration of `%s' shadows a symbol from the parameter list"
#~ msgstr "Bya a IKIMENYETSO Bivuye i Urutonde"

#, fuzzy
#~ msgid "a parameter"
#~ msgstr "a"

#, fuzzy
#~ msgid "a previous local"
#~ msgstr "a Ibanjirije"

#, fuzzy
#~ msgid "a global declaration"
#~ msgstr "a"

#, fuzzy
#~ msgid "nested extern declaration of `%s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "`%s' used prior to declaration"
#~ msgstr "`%s'Kuri"

#, fuzzy
#~ msgid "`%s' was declared implicitly `extern' and later `static'"
#~ msgstr "`%s'Na"

#, fuzzy
#~ msgid "type mismatch with previous external decl"
#~ msgstr "Ubwoko Na: Ibanjirije external"

#, fuzzy
#~ msgid "previous external decl of `%s'"
#~ msgstr "Ibanjirije external Bya"

#, fuzzy
#~ msgid "type mismatch with previous implicit declaration"
#~ msgstr "Ubwoko Na: Ibanjirije"

#, fuzzy
#~ msgid "previous implicit declaration of `%s'"
#~ msgstr "Ibanjirije Bya"

#, fuzzy
#~ msgid "`%s' was previously implicitly declared to return `int'"
#~ msgstr "`%s'Kuri Garuka"

#, fuzzy
#~ msgid "`%s' was declared `extern' and later `static'"
#~ msgstr "`%s'Na"

#, fuzzy
#~ msgid "extern declaration of `%s' doesn't match global one"
#~ msgstr "Bya BIHUYE"

#, fuzzy
#~ msgid "`%s' locally external but globally static"
#~ msgstr "`%s'external"

#, fuzzy
#~ msgid "function `%s' was previously declared within a block"
#~ msgstr "Umumaro muri a Funga"

#, fuzzy
#~ msgid "implicit declaration of function `%s'"
#~ msgstr "Bya Umumaro"

#, fuzzy
#~ msgid "label %s referenced outside of any function"
#~ msgstr "Akarango Hanze Bya Umumaro"

#, fuzzy
#~ msgid "duplicate label declaration `%s'"
#~ msgstr "Gusubiramo Akarango"

#, fuzzy
#~ msgid "this is a previous declaration"
#~ msgstr "iyi ni a Ibanjirije"

#, fuzzy
#~ msgid "unnamed struct/union that defines no instances"
#~ msgstr "Kitiswe Ihuza Oya Ingero"

#, fuzzy
#~ msgid "useless keyword or type name in empty declaration"
#~ msgstr "Ijambo- banze Cyangwa Ubwoko Izina: in ubusa"

#, fuzzy
#~ msgid "two types specified in one empty declaration"
#~ msgstr "in ubusa"

#, fuzzy
#~ msgid "empty declaration"
#~ msgstr "ubusa"

#, fuzzy
#~ msgid "ISO C90 does not support `static' or type qualifiers in parameter array declarators"
#~ msgstr "OYA Gushigikira Cyangwa Ubwoko in Imbonerahamwe"

#, fuzzy
#~ msgid "ISO C90 does not support `[*]' array declarators"
#~ msgstr "OYA Gushigikira Imbonerahamwe"

#, fuzzy
#~ msgid "GCC does not yet properly implement `[*]' array declarators"
#~ msgstr "OYA Imbonerahamwe"

#, fuzzy
#~ msgid "static or type qualifiers in abstract declarator"
#~ msgstr "Cyangwa Ubwoko in Incamake"

#, fuzzy
#~ msgid "`%s' is usually a function"
#~ msgstr "`%s'ni a Umumaro"

#, fuzzy
#~ msgid "typedef `%s' is initialized (use __typeof__ instead)"
#~ msgstr "ni Gukoresha"

#, fuzzy
#~ msgid "function `%s' is initialized like a variable"
#~ msgstr "Umumaro ni nka a IMPINDURAGACIRO"

#, fuzzy
#~ msgid "parameter `%s' is initialized"
#~ msgstr "ni"

#, fuzzy
#~ msgid "variable-sized object may not be initialized"
#~ msgstr "IMPINDURAGACIRO Igikoresho Gicurasi OYA"

#, fuzzy
#~ msgid "variable `%s' has initializer but incomplete type"
#~ msgstr "IMPINDURAGACIRO Ubwoko"

#, fuzzy
#~ msgid "elements of array `%s' have incomplete type"
#~ msgstr "Ibintu Bya Imbonerahamwe Ubwoko"

#, fuzzy
#~ msgid "declaration of `%s' has `extern' and is initialized"
#~ msgstr "Bya Na ni"

#, fuzzy
#~ msgid "inline function `%s' given attribute noinline"
#~ msgstr "Mumurongo Umumaro Ikiranga"

#, fuzzy
#~ msgid "initializer fails to determine size of `%s'"
#~ msgstr "Kuri Ingano Bya"

#, fuzzy
#~ msgid "array size missing in `%s'"
#~ msgstr "Imbonerahamwe Ingano Ibuze in"

#, fuzzy
#~ msgid "zero or negative size array `%s'"
#~ msgstr "Zeru Cyangwa Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "storage size of `%s' isn't known"
#~ msgstr "Ingano Bya si"

#, fuzzy
#~ msgid "storage size of `%s' isn't constant"
#~ msgstr "Ingano Bya si"

#, fuzzy
#~ msgid "ignoring asm-specifier for non-static local variable `%s'"
#~ msgstr "kugirango IMPINDURAGACIRO"

#, fuzzy
#~ msgid "ISO C forbids parameter `%s' shadowing typedef"
#~ msgstr "C Ishyiraho ry'igicucu"

#, fuzzy
#~ msgid "`long long long' is too long for GCC"
#~ msgstr "`ni kugirango"

#, fuzzy
#~ msgid "ISO C90 does not support `long long'"
#~ msgstr "OYA Gushigikira"

#, fuzzy
#~ msgid "duplicate `%s'"
#~ msgstr "Gusubiramo"

#, fuzzy
#~ msgid "`__thread' before `extern'"
#~ msgstr "`_Mbere"

#, fuzzy
#~ msgid "`__thread' before `static'"
#~ msgstr "`_Mbere"

#, fuzzy
#~ msgid "two or more data types in declaration of `%s'"
#~ msgstr "Cyangwa Birenzeho Ibyatanzwe in Bya"

#, fuzzy
#~ msgid "`%s' fails to be a typedef or built in type"
#~ msgstr "`%s'Kuri a Cyangwa in Ubwoko"

#, fuzzy
#~ msgid "type defaults to `int' in declaration of `%s'"
#~ msgstr "Ubwoko Kuri in Bya"

#, fuzzy
#~ msgid "both long and short specified for `%s'"
#~ msgstr "Byombi Na kugirango"

#, fuzzy
#~ msgid "long or short specified with char for `%s'"
#~ msgstr "Cyangwa Na: INYUGUTI kugirango"

#, fuzzy
#~ msgid "long or short specified with floating type for `%s'"
#~ msgstr "Cyangwa Na: Bihindagurika Ubwoko kugirango"

#, fuzzy
#~ msgid "the only valid combination is `long double'"
#~ msgstr "i Byemewe Ivanga ni"

#, fuzzy
#~ msgid "both signed and unsigned specified for `%s'"
#~ msgstr "Byombi Na Bitashizweho umukono kugirango"

#, fuzzy
#~ msgid "long, short, signed or unsigned invalid for `%s'"
#~ msgstr "Cyangwa Bitashizweho umukono Sibyo kugirango"

#, fuzzy
#~ msgid "long, short, signed or unsigned used invalidly for `%s'"
#~ msgstr "Cyangwa Bitashizweho umukono kugirango"

#, fuzzy
#~ msgid "complex invalid for `%s'"
#~ msgstr "ITSINDA RY'IMIBARE C Sibyo kugirango"

#, fuzzy
#~ msgid "ISO C90 does not support complex types"
#~ msgstr "OYA Gushigikira ITSINDA RY'IMIBARE C"

#, fuzzy
#~ msgid "ISO C does not support plain `complex' meaning `double complex'"
#~ msgstr "C OYA Gushigikira Byuzuye Igisobanuro MAHARAKUBIRI"

#, fuzzy
#~ msgid "ISO C does not support complex integer types"
#~ msgstr "C OYA Gushigikira ITSINDA RY'IMIBARE C Umubare wuzuye"

#, fuzzy
#~ msgid "duplicate `const'"
#~ msgstr "Gusubiramo"

#, fuzzy
#~ msgid "duplicate `restrict'"
#~ msgstr "Gusubiramo"

#, fuzzy
#~ msgid "duplicate `volatile'"
#~ msgstr "Gusubiramo"

#, fuzzy
#~ msgid "multiple storage classes in declaration of `%s'"
#~ msgstr "Igikubo Inzego in Bya"

#, fuzzy
#~ msgid "function definition declared `auto'"
#~ msgstr "Umumaro Insobanuro"

#, fuzzy
#~ msgid "function definition declared `register'"
#~ msgstr "Umumaro Insobanuro"

#, fuzzy
#~ msgid "function definition declared `typedef'"
#~ msgstr "Umumaro Insobanuro"

#, fuzzy
#~ msgid "function definition declared `__thread'"
#~ msgstr "Umumaro Insobanuro"

#, fuzzy
#~ msgid "storage class specified for structure field `%s'"
#~ msgstr "ishuri kugirango Imiterere Umwanya"

#, fuzzy
#~ msgid "storage class specified for parameter `%s'"
#~ msgstr "ishuri kugirango"

#, fuzzy
#~ msgid "storage class specified for typename"
#~ msgstr "ishuri kugirango"

#, fuzzy
#~ msgid "`%s' initialized and declared `extern'"
#~ msgstr "`%s'Na"

#, fuzzy
#~ msgid "`%s' has both `extern' and initializer"
#~ msgstr "`%s'Byombi Na"

#, fuzzy
#~ msgid "top-level declaration of `%s' specifies `auto'"
#~ msgstr "Hejuru: urwego Bya"

#, fuzzy
#~ msgid "nested function `%s' declared `extern'"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "function-scope `%s' implicitly auto and declared `__thread'"
#~ msgstr "Umumaro Ingano: Ikiyega Na"

#, fuzzy
#~ msgid "static or type qualifiers in non-parameter array declarator"
#~ msgstr "Cyangwa Ubwoko in Imbonerahamwe"

#, fuzzy
#~ msgid "declaration of `%s' as array of voids"
#~ msgstr "Bya Nka Imbonerahamwe Bya"

#, fuzzy
#~ msgid "declaration of `%s' as array of functions"
#~ msgstr "Bya Nka Imbonerahamwe Bya Imimaro"

#, fuzzy
#~ msgid "invalid use of structure with flexible array member"
#~ msgstr "Sibyo Gukoresha Bya Imiterere Na: Imbonerahamwe"

#, fuzzy
#~ msgid "size of array `%s' has non-integer type"
#~ msgstr "Ingano Bya Imbonerahamwe Umubare wuzuye Ubwoko"

#, fuzzy
#~ msgid "ISO C forbids zero-size array `%s'"
#~ msgstr "C Zeru Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "size of array `%s' is negative"
#~ msgstr "Ingano Bya Imbonerahamwe ni"

#, fuzzy
#~ msgid "ISO C90 forbids array `%s' whose size can't be evaluated"
#~ msgstr "Imbonerahamwe bya Ingano"

#, fuzzy
#~ msgid "ISO C90 forbids variable-size array `%s'"
#~ msgstr "IMPINDURAGACIRO Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "size of array `%s' is too large"
#~ msgstr "Ingano Bya Imbonerahamwe ni Binini"

#, fuzzy
#~ msgid "ISO C90 does not support flexible array members"
#~ msgstr "OYA Gushigikira Imbonerahamwe"

#, fuzzy
#~ msgid "array type has incomplete element type"
#~ msgstr "Imbonerahamwe Ubwoko Ikigize: Ubwoko"

#, fuzzy
#~ msgid "ISO C forbids const or volatile function types"
#~ msgstr "C Cyangwa Umumaro"

#, fuzzy
#~ msgid "`%s' declared as function returning a function"
#~ msgstr "`%s'Nka Umumaro a Umumaro"

#, fuzzy
#~ msgid "`%s' declared as function returning an array"
#~ msgstr "`%s'Nka Umumaro Imbonerahamwe"

#, fuzzy
#~ msgid "ISO C forbids qualified void function return type"
#~ msgstr "C Umumaro Garuka Ubwoko"

#, fuzzy
#~ msgid "type qualifiers ignored on function return type"
#~ msgstr "Ubwoko ku Umumaro Garuka Ubwoko"

#, fuzzy
#~ msgid "ISO C forbids qualified function types"
#~ msgstr "C Umumaro"

#, fuzzy
#~ msgid "invalid type modifier within pointer declarator"
#~ msgstr "Sibyo Ubwoko muri Mweretsi"

#, fuzzy
#~ msgid "variable or field `%s' declared void"
#~ msgstr "IMPINDURAGACIRO Cyangwa Umwanya"

#, fuzzy
#~ msgid "attributes in parameter array declarator ignored"
#~ msgstr "Ibiranga in Imbonerahamwe"

#, fuzzy
#~ msgid "invalid type modifier within array declarator"
#~ msgstr "Sibyo Ubwoko muri Imbonerahamwe"

#, fuzzy
#~ msgid "field `%s' declared as a function"
#~ msgstr "Umwanya Nka a Umumaro"

#, fuzzy
#~ msgid "field `%s' has incomplete type"
#~ msgstr "Umwanya Ubwoko"

#, fuzzy
#~ msgid "invalid storage class for function `%s'"
#~ msgstr "Sibyo ishuri kugirango Umumaro"

#, fuzzy
#~ msgid "`noreturn' function returns non-void value"
#~ msgstr "`Umumaro Agaciro"

#, fuzzy
#~ msgid "cannot inline function `main'"
#~ msgstr "Mumurongo Umumaro"

#, fuzzy
#~ msgid "variable `%s' declared `inline'"
#~ msgstr "IMPINDURAGACIRO"

#, fuzzy
#~ msgid "thread-local storage not supported for this target"
#~ msgstr "Urudodo OYA kugirango iyi Intego"

#, fuzzy
#~ msgid "function declaration isn't a prototype"
#~ msgstr "Umumaro si a"

#, fuzzy
#~ msgid "parameter names (without types) in function declaration"
#~ msgstr "Amazina in Umumaro"

#, fuzzy
#~ msgid "parameter `%s' has incomplete type"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "parameter has incomplete type"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "parameter `%s' points to incomplete type"
#~ msgstr "Utudomo Kuri Ubwoko"

#, fuzzy
#~ msgid "parameter points to incomplete type"
#~ msgstr "Utudomo Kuri Ubwoko"

#, fuzzy
#~ msgid "parameter `%s' has just a forward declaration"
#~ msgstr "a Imbere"

#, fuzzy
#~ msgid "`void' in parameter list must be the entire list"
#~ msgstr "`in Urutonde i Urutonde"

#, fuzzy
#~ msgid "`struct %s' declared inside parameter list"
#~ msgstr "`Mo Imbere Urutonde"

#, fuzzy
#~ msgid "`union %s' declared inside parameter list"
#~ msgstr "`Ihuza Mo Imbere Urutonde"

#, fuzzy
#~ msgid "`enum %s' declared inside parameter list"
#~ msgstr "`Mo Imbere Urutonde"

#, fuzzy
#~ msgid "anonymous struct declared inside parameter list"
#~ msgstr "Mo Imbere Urutonde"

#, fuzzy
#~ msgid "anonymous union declared inside parameter list"
#~ msgstr "Ihuza Mo Imbere Urutonde"

#, fuzzy
#~ msgid "anonymous enum declared inside parameter list"
#~ msgstr "Mo Imbere Urutonde"

#, fuzzy
#~ msgid "its scope is only this definition or declaration, which is probably not what you want"
#~ msgstr "Ingano: ni iyi Insobanuro Cyangwa ni OYA"

#, fuzzy
#~ msgid "redefinition of `union %s'"
#~ msgstr "Bya Ihuza"

#, fuzzy
#~ msgid "redefinition of `struct %s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "declaration does not declare anything"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "%s defined inside parms"
#~ msgstr "%sMo Imbere"

# starmath/source\smres.src:RID_TOOLBOXWINDOW.3.RID_XUNIONY.text
#, fuzzy
#~ msgid "union"
#~ msgstr "Ihuza"

# sc/source\ui\formdlg\formdlgs.src:RID_SCTAB_STRUCT.FT_STRUCT.text
#, fuzzy
#~ msgid "structure"
#~ msgstr "Imiterere"

#, fuzzy
#~ msgid "%s has no %s"
#~ msgstr "%sOya"

#, fuzzy
#~ msgid "nested redefinition of `%s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "bit-field `%s' width not an integer constant"
#~ msgstr "Umwanya Ubugari OYA Umubare wuzuye"

#, fuzzy
#~ msgid "bit-field `%s' has invalid type"
#~ msgstr "Umwanya Sibyo Ubwoko"

#, fuzzy
#~ msgid "bit-field `%s' type invalid in ISO C"
#~ msgstr "Umwanya Ubwoko Sibyo in C"

#, fuzzy
#~ msgid "negative width in bit-field `%s'"
#~ msgstr "Ubugari in Umwanya"

#, fuzzy
#~ msgid "width of `%s' exceeds its type"
#~ msgstr "Ubugari Bya Ubwoko"

#, fuzzy
#~ msgid "zero width for bit-field `%s'"
#~ msgstr "Zeru Ubugari kugirango Umwanya"

#, fuzzy
#~ msgid "`%s' is narrower than values of its type"
#~ msgstr "`%s'ni Uduciro Bya Ubwoko"

#, fuzzy
#~ msgid "flexible array member in union"
#~ msgstr "Imbonerahamwe in Ihuza"

#, fuzzy
#~ msgid "flexible array member not at end of struct"
#~ msgstr "Imbonerahamwe OYA ku Impera Bya"

#, fuzzy
#~ msgid "flexible array member in otherwise empty struct"
#~ msgstr "Imbonerahamwe in ubusa"

#, fuzzy
#~ msgid "duplicate member `%s'"
#~ msgstr "Gusubiramo"

#, fuzzy
#~ msgid "union cannot be made transparent"
#~ msgstr "Ihuza Bibonerana"

#, fuzzy
#~ msgid "redeclaration of `enum %s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "enum defined inside parms"
#~ msgstr "Mo Imbere"

#, fuzzy
#~ msgid "enumeration values exceed range of largest integer"
#~ msgstr "Uduciro Urutonde Bya Kinini Umubare wuzuye"

#, fuzzy
#~ msgid "enumerator value for `%s' not integer constant"
#~ msgstr "Agaciro kugirango OYA Umubare wuzuye"

#, fuzzy
#~ msgid "overflow in enumeration values"
#~ msgstr "Byarenze urugero in Uduciro"

#, fuzzy
#~ msgid "ISO C restricts enumerator values to range of `int'"
#~ msgstr "C Uduciro Kuri Urutonde Bya"

#, fuzzy
#~ msgid "return type is an incomplete type"
#~ msgstr "Garuka Ubwoko ni Ubwoko"

#, fuzzy
#~ msgid "return type defaults to `int'"
#~ msgstr "Garuka Ubwoko Kuri"

#, fuzzy
#~ msgid "no previous prototype for `%s'"
#~ msgstr "Oya Ibanjirije kugirango"

#, fuzzy
#~ msgid "`%s' was used with no prototype before its definition"
#~ msgstr "`%s'Na: Oya Mbere Insobanuro"

#, fuzzy
#~ msgid "no previous declaration for `%s'"
#~ msgstr "Oya Ibanjirije kugirango"

#, fuzzy
#~ msgid "`%s' was used with no declaration before its definition"
#~ msgstr "`%s'Na: Oya Mbere Insobanuro"

#, fuzzy
#~ msgid "return type of `%s' is not `int'"
#~ msgstr "Garuka Ubwoko Bya ni OYA"

#, fuzzy
#~ msgid "first argument of `%s' should be `int'"
#~ msgstr "Itangira Bya"

#, fuzzy
#~ msgid "second argument of `%s' should be `char **'"
#~ msgstr "ISEGONDA Bya INYUGUTI"

#, fuzzy
#~ msgid "third argument of `%s' should probably be `char **'"
#~ msgstr "Bya INYUGUTI"

#, fuzzy
#~ msgid "`%s' takes only zero or two arguments"
#~ msgstr "`%s'Zeru Cyangwa ingingo"

#, fuzzy
#~ msgid "`%s' is normally a non-static function"
#~ msgstr "`%s'ni a Umumaro"

#, fuzzy
#~ msgid "parm types given both in parmlist and separately"
#~ msgstr "Byombi in Na"

#, fuzzy
#~ msgid "parameter name omitted"
#~ msgstr "Izina:"

#, fuzzy
#~ msgid "parameter name missing from parameter list"
#~ msgstr "Izina: Ibuze Bivuye Urutonde"

#, fuzzy
#~ msgid "multiple parameters named `%s'"
#~ msgstr "Igikubo Ibigenga"

#, fuzzy
#~ msgid "type of `%s' defaults to `int'"
#~ msgstr "Ubwoko Bya Kuri"

#, fuzzy
#~ msgid "declaration for parameter `%s' but no such parameter"
#~ msgstr "kugirango Oya"

#, fuzzy
#~ msgid "number of arguments doesn't match prototype"
#~ msgstr "Umubare Bya ingingo BIHUYE"

#, fuzzy
#~ msgid "promoted argument `%s' doesn't match prototype"
#~ msgstr "BIHUYE"

#, fuzzy
#~ msgid "argument `%s' doesn't match prototype"
#~ msgstr "BIHUYE"

#, fuzzy
#~ msgid "no return statement in function returning non-void"
#~ msgstr "Oya Garuka Inyandiko in Umumaro"

#, fuzzy
#~ msgid "this function may return with or without a value"
#~ msgstr "iyi Umumaro Gicurasi Garuka Na: Cyangwa a Agaciro"

#, fuzzy
#~ msgid "size of return value of `%s' is %u bytes"
#~ msgstr "Ingano Bya Garuka Agaciro Bya ni Bayite"

#, fuzzy
#~ msgid "size of return value of `%s' is larger than %d bytes"
#~ msgstr "Ingano Bya Garuka Agaciro Bya ni Kinini Bayite"

#, fuzzy
#~ msgid "`for' loop initial declaration used outside C99 mode"
#~ msgstr "`Hanze Ubwoko"

#, fuzzy
#~ msgid "`struct %s' declared in `for' loop initial declaration"
#~ msgstr "`in"

#, fuzzy
#~ msgid "`union %s' declared in `for' loop initial declaration"
#~ msgstr "`Ihuza in"

#, fuzzy
#~ msgid "`enum %s' declared in `for' loop initial declaration"
#~ msgstr "`in"

#, fuzzy
#~ msgid "declaration of non-variable `%s' in `for' loop initial declaration"
#~ msgstr "Bya IMPINDURAGACIRO in"

#, fuzzy
#~ msgid "declaration of static variable `%s' in `for' loop initial declaration"
#~ msgstr "Bya IMPINDURAGACIRO in"

#, fuzzy
#~ msgid "declaration of `extern' variable `%s' in `for' loop initial declaration"
#~ msgstr "Bya IMPINDURAGACIRO in"

#, fuzzy
#~ msgid "format string arg not a string type"
#~ msgstr "Imiterere Ikurikiranyanyuguti OYA a Ikurikiranyanyuguti Ubwoko"

#, fuzzy
#~ msgid "args to be formatted is not '...'"
#~ msgstr "Kuri Byahanaguwe ni OYA"

#, fuzzy
#~ msgid "strftime formats cannot format arguments"
#~ msgstr "Imiterere Imiterere ingingo"

#, fuzzy
#~ msgid "format string has invalid operand number"
#~ msgstr "Imiterere Ikurikiranyanyuguti Sibyo Umubare"

#, fuzzy
#~ msgid "function does not return string type"
#~ msgstr "Umumaro OYA Garuka Ikurikiranyanyuguti Ubwoko"

#, fuzzy
#~ msgid "unrecognized format specifier"
#~ msgstr "Imiterere"

#, fuzzy
#~ msgid "`%s' is an unrecognized format function type"
#~ msgstr "`%s'ni Imiterere Umumaro Ubwoko"

#, fuzzy
#~ msgid "format string arg follows the args to be formatted"
#~ msgstr "Imiterere Ikurikiranyanyuguti i Kuri Byahanaguwe"

#, fuzzy
#~ msgid "` ' flag"
#~ msgstr "`'Ibendera"

#, fuzzy
#~ msgid "the ` ' printf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`+' flag"
#~ msgstr "`+'Ibendera"

#, fuzzy
#~ msgid "the `+' printf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`#' flag"
#~ msgstr "`#'Ibendera"

#, fuzzy
#~ msgid "the `#' printf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`0' flag"
#~ msgstr "`Ibendera"

#, fuzzy
#~ msgid "the `0' printf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`-' flag"
#~ msgstr "`-'Ibendera"

#, fuzzy
#~ msgid "the `-' printf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`'' flag"
#~ msgstr "`''Ibendera"

#, fuzzy
#~ msgid "the `'' printf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`I' flag"
#~ msgstr "`Ibendera"

#, fuzzy
#~ msgid "the `I' printf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "field width"
#~ msgstr "Umwanya Ubugari"

#, fuzzy
#~ msgid "field width in printf format"
#~ msgstr "Umwanya Ubugari in Imiterere"

#, fuzzy
#~ msgid "precision in printf format"
#~ msgstr "in Imiterere"

#, fuzzy
#~ msgid "length modifier"
#~ msgstr "Uburebure"

#, fuzzy
#~ msgid "length modifier in printf format"
#~ msgstr "Uburebure in Imiterere"

#, fuzzy
#~ msgid "assignment suppression"
#~ msgstr "Igenera"

#, fuzzy
#~ msgid "the assignment suppression scanf feature"
#~ msgstr "i Igenera"

#, fuzzy
#~ msgid "`a' flag"
#~ msgstr "`Ibendera"

#, fuzzy
#~ msgid "the `a' scanf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "field width in scanf format"
#~ msgstr "Umwanya Ubugari in Imiterere"

#, fuzzy
#~ msgid "length modifier in scanf format"
#~ msgstr "Uburebure in Imiterere"

#, fuzzy
#~ msgid "the `'' scanf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "the `I' scanf flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`_' flag"
#~ msgstr "`_'Ibendera"

#, fuzzy
#~ msgid "the `_' strftime flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "the `-' strftime flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "the `0' strftime flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`^' flag"
#~ msgstr "`^'Ibendera"

#, fuzzy
#~ msgid "the `^' strftime flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "the `#' strftime flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "field width in strftime format"
#~ msgstr "Umwanya Ubugari in Imiterere"

#, fuzzy
#~ msgid "the `E' strftime modifier"
#~ msgstr "i"

#, fuzzy
#~ msgid "the `O' strftime modifier"
#~ msgstr "i"

#, fuzzy
#~ msgid "the `O' modifier"
#~ msgstr "i"

# svx/source\dialog\tabstpge.src:RID_SVXPAGE_TABULATOR.FL_FILLCHAR.text
#, fuzzy
#~ msgid "fill character"
#~ msgstr "Kuzuza inyuguti"

#, fuzzy
#~ msgid "fill character in strfmon format"
#~ msgstr "Kuzuza Inyuguti in Imiterere"

#, fuzzy
#~ msgid "the `^' strfmon flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "the `+' strfmon flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`(' flag"
#~ msgstr "`('Ibendera"

#, fuzzy
#~ msgid "the `(' strfmon flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "`!' flag"
#~ msgstr "`!'Ibendera"

#, fuzzy
#~ msgid "the `!' strfmon flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "the `-' strfmon flag"
#~ msgstr "i Ibendera"

#, fuzzy
#~ msgid "field width in strfmon format"
#~ msgstr "Umwanya Ubugari in Imiterere"

#, fuzzy
#~ msgid "left precision"
#~ msgstr "Ibumoso:"

#, fuzzy
#~ msgid "left precision in strfmon format"
#~ msgstr "Ibumoso: in Imiterere"

#, fuzzy
#~ msgid "right precision"
#~ msgstr "Iburyo:"

#, fuzzy
#~ msgid "right precision in strfmon format"
#~ msgstr "Iburyo: in Imiterere"

#, fuzzy
#~ msgid "length modifier in strfmon format"
#~ msgstr "Uburebure in Imiterere"

#, fuzzy
#~ msgid "function might be possible candidate for `%s' format attribute"
#~ msgstr "Umumaro kugirango Imiterere Ikiranga"

#, fuzzy
#~ msgid "missing $ operand number in format"
#~ msgstr "Ibuze Umubare in Imiterere"

#, fuzzy
#~ msgid "%s does not support %%n$ operand number formats"
#~ msgstr "%sOYA Gushigikira Umubare Imiterere"

#, fuzzy
#~ msgid "operand number out of range in format"
#~ msgstr "Umubare Inyuma Bya Urutonde in Imiterere"

#, fuzzy
#~ msgid "format argument %d used more than once in %s format"
#~ msgstr "Imiterere Birenzeho Rimwe in Imiterere"

#, fuzzy
#~ msgid "format argument %d unused before used argument %d in $-style format"
#~ msgstr "Imiterere Kidakoreshwa Mbere in IMISUSIRE Imiterere"

#, fuzzy
#~ msgid "format not a string literal, format string not checked"
#~ msgstr "Imiterere OYA a Ikurikiranyanyuguti Imiterere Ikurikiranyanyuguti OYA Ivivuwe"

#, fuzzy
#~ msgid "format not a string literal and no format arguments"
#~ msgstr "Imiterere OYA a Ikurikiranyanyuguti Na Oya Imiterere ingingo"

#, fuzzy
#~ msgid "format not a string literal, argument types not checked"
#~ msgstr "Imiterere OYA a Ikurikiranyanyuguti OYA Ivivuwe"

#, fuzzy
#~ msgid "too many arguments for format"
#~ msgstr "ingingo kugirango Imiterere"

#, fuzzy
#~ msgid "unused arguments in $-style format"
#~ msgstr "Kidakoreshwa ingingo in IMISUSIRE Imiterere"

#, fuzzy
#~ msgid "zero-length %s format string"
#~ msgstr "Zeru Uburebure Imiterere Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "format is a wide character string"
#~ msgstr "Imiterere ni a Inyuguti Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "unterminated format string"
#~ msgstr "Imiterere Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "embedded `\\0' in format"
#~ msgstr "Gitsindiye in Imiterere"

#, fuzzy
#~ msgid "spurious trailing `%%' in format"
#~ msgstr "in Imiterere"

#, fuzzy
#~ msgid "repeated %s in format"
#~ msgstr "byasubiyemo in Imiterere"

#, fuzzy
#~ msgid "missing fill character at end of strfmon format"
#~ msgstr "Ibuze Kuzuza Inyuguti ku Impera Bya Imiterere"

#, fuzzy
#~ msgid "too few arguments for format"
#~ msgstr "ingingo kugirango Imiterere"

#, fuzzy
#~ msgid "zero width in %s format"
#~ msgstr "Zeru Ubugari in Imiterere"

#, fuzzy
#~ msgid "empty left precision in %s format"
#~ msgstr "ubusa Ibumoso: in Imiterere"

#, fuzzy
#~ msgid "field precision"
#~ msgstr "Umwanya"

#, fuzzy
#~ msgid "empty precision in %s format"
#~ msgstr "ubusa in Imiterere"

#, fuzzy
#~ msgid "%s does not support the `%s' %s length modifier"
#~ msgstr "%sOYA Gushigikira i Uburebure"

#, fuzzy
#~ msgid "conversion lacks type at end of format"
#~ msgstr "Ihindurangero Ubwoko ku Impera Bya Imiterere"

#, fuzzy
#~ msgid "unknown conversion type character `%c' in format"
#~ msgstr "Kitazwi Ihindurangero Ubwoko Inyuguti in Imiterere"

#, fuzzy
#~ msgid "unknown conversion type character 0x%x in format"
#~ msgstr "Kitazwi Ihindurangero Ubwoko Inyuguti in Imiterere"

#, fuzzy
#~ msgid "%s does not support the `%%%c' %s format"
#~ msgstr "%sOYA Gushigikira i Imiterere"

#, fuzzy
#~ msgid "%s used with `%%%c' %s format"
#~ msgstr "%sNa: Imiterere"

#, fuzzy
#~ msgid "%s does not support %s"
#~ msgstr "%sOYA Gushigikira"

#, fuzzy
#~ msgid "%s does not support %s with the `%%%c' %s format"
#~ msgstr "%sOYA Gushigikira Na: i Imiterere"

#, fuzzy
#~ msgid "%s ignored with %s and `%%%c' %s format"
#~ msgstr "%sNa: Na Imiterere"

#, fuzzy
#~ msgid "%s ignored with %s in %s format"
#~ msgstr "%sNa: in Imiterere"

#, fuzzy
#~ msgid "use of %s and %s together with `%%%c' %s format"
#~ msgstr "Gukoresha Bya Na Na: Imiterere"

#, fuzzy
#~ msgid "use of %s and %s together in %s format"
#~ msgstr "Gukoresha Bya Na in Imiterere"

#, fuzzy
#~ msgid "`%%%c' yields only last 2 digits of year in some locales"
#~ msgstr "`%%%c'Iheruka 2. Bya Umwaka in"

#, fuzzy
#~ msgid "`%%%c' yields only last 2 digits of year"
#~ msgstr "`%%%c'Iheruka 2. Bya Umwaka"

#, fuzzy
#~ msgid "no closing `]' for `%%[' format"
#~ msgstr "Oya kugirango Imiterere"

#, fuzzy
#~ msgid "use of `%s' length modifier with `%c' type character"
#~ msgstr "Gukoresha Bya Uburebure Na: Ubwoko Inyuguti"

#, fuzzy
#~ msgid "%s does not support the `%%%s%c' %s format"
#~ msgstr "%sOYA Gushigikira i Imiterere"

#, fuzzy
#~ msgid "operand number specified with suppressed assignment"
#~ msgstr "Umubare Na: Igenera"

#, fuzzy
#~ msgid "operand number specified for format taking no argument"
#~ msgstr "Umubare kugirango Imiterere Oya"

#, fuzzy
#~ msgid "writing through null pointer (arg %d)"
#~ msgstr "Gihinguranya NTAGIHARI Mweretsi"

#, fuzzy
#~ msgid "reading through null pointer (arg %d)"
#~ msgstr "Gihinguranya NTAGIHARI Mweretsi"

#, fuzzy
#~ msgid "writing into constant object (arg %d)"
#~ msgstr "Igikoresho"

#, fuzzy
#~ msgid "extra type qualifiers in format argument (arg %d)"
#~ msgstr "Birenga Ubwoko in Imiterere"

#, fuzzy
#~ msgid "format argument is not a pointer (arg %d)"
#~ msgstr "Imiterere ni OYA a Mweretsi"

#, fuzzy
#~ msgid "format argument is not a pointer to a pointer (arg %d)"
#~ msgstr "Imiterere ni OYA a Mweretsi Kuri a Mweretsi"

#, fuzzy
#~ msgid "pointer"
#~ msgstr "Mweretsi"

#, fuzzy
#~ msgid "different type"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "%s is not type %s (arg %d)"
#~ msgstr "%sni OYA Ubwoko"

#, fuzzy
#~ msgid "%s format, %s arg (arg %d)"
#~ msgstr "%sImiterere"

#, fuzzy
#~ msgid "YYDEBUG not defined"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "badly nested C headers from preprocessor"
#~ msgstr "C Imitwe Bivuye"

#, fuzzy
#~ msgid "universal-character-name '\\u%04x' not valid in identifier"
#~ msgstr "Ky'isi yose Inyuguti Izina: OYA Byemewe in Ikiranga"

#, fuzzy
#~ msgid "stray '%c' in program"
#~ msgstr "in Porogaramu"

#, fuzzy
#~ msgid "stray '\\%o' in program"
#~ msgstr "in Porogaramu"

#, fuzzy
#~ msgid "this decimal constant is unsigned only in ISO C90"
#~ msgstr "iyi NYACUMI ni Bitashizweho umukono in"

#, fuzzy
#~ msgid "this decimal constant would be unsigned in ISO C90"
#~ msgstr "iyi NYACUMI Bitashizweho umukono in"

#, fuzzy
#~ msgid "integer constant is too large for \"%s\" type"
#~ msgstr "Umubare wuzuye ni Binini kugirango Ubwoko"

#, fuzzy
#~ msgid "floating constant exceeds range of \"%s\""
#~ msgstr "Bihindagurika Urutonde Bya"

#, fuzzy
#~ msgid "ignoring invalid multibyte character"
#~ msgstr "Sibyo Inyuguti"

#, fuzzy
#~ msgid "missing argument to \"-%s\""
#~ msgstr "Ibuze Kuri"

#, fuzzy
#~ msgid "no class name specified with \"-%s\""
#~ msgstr "Oya ishuri Izina: Na:"

#, fuzzy
#~ msgid "missing filename after \"-%s\""
#~ msgstr "Ibuze Izina ry'idosiye: Nyuma"

#, fuzzy
#~ msgid "missing target after \"-%s\""
#~ msgstr "Ibuze Intego Nyuma"

#, fuzzy
#~ msgid "options array incorrectly sorted: %s is before %s"
#~ msgstr "Amahitamo Imbonerahamwe bishunguwe ni Mbere"

#, fuzzy
#~ msgid "too many filenames given.  Type %s --help for usage"
#~ msgstr "Ifashayobora kugirango Ikoresha:"

#, fuzzy
#~ msgid "-Wno-strict-prototypes is not supported in C++"
#~ msgstr "-ni OYA in C"

#, fuzzy
#~ msgid "switch \"%s\" is no longer supported"
#~ msgstr "Hindura ni Oya"

#, fuzzy
#~ msgid "switch \"%s\" is deprecated, please see documentation for details"
#~ msgstr "Hindura ni Bitemewe. kugirango Birambuye"

#, fuzzy
#~ msgid "-fhandle-exceptions has been renamed to -fexceptions (and is now on by default)"
#~ msgstr "-Amarengayobora Kuri Na ni NONEAHA ku ku Mburabuzi"

#, fuzzy
#~ msgid "output filename specified twice"
#~ msgstr "Ibisohoka Izina ry'idosiye:"

#, fuzzy
#~ msgid "-Wformat-extra-args ignored without -Wformat"
#~ msgstr "-Birenga"

#, fuzzy
#~ msgid "-Wformat-zero-length ignored without -Wformat"
#~ msgstr "-Zeru Uburebure"

#, fuzzy
#~ msgid "-Wformat-security ignored without -Wformat"
#~ msgstr "-Umutekano"

#, fuzzy
#~ msgid "-Wmissing-format-attribute ignored without -Wformat"
#~ msgstr "-Imiterere Ikiranga"

#, fuzzy
#~ msgid "opening output file %s"
#~ msgstr "Gufungura %s%S Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid "opening dependency file %s"
#~ msgstr "Gufungura %s%S IDOSIYE"

#, fuzzy
#~ msgid "closing dependency file %s"
#~ msgstr "IDOSIYE"

#, fuzzy
#~ msgid "when writing output to %s"
#~ msgstr "Ryari: Ibisohoka Kuri"

#, fuzzy
#~ msgid "to generate dependencies you must specify either -M or -MM"
#~ msgstr "Kuri Cyangwa"

#, fuzzy
#~ msgid "\"-%s\" is valid for %s but not for %s"
#~ msgstr "\"-%s\"ni Byemewe kugirango OYA kugirango"

#, fuzzy
#~ msgid ""
#~ "Switches:\n"
#~ "  -include <file>           Include the contents of <file> before other files\n"
#~ "  -imacros <file>           Accept definition of macros in <file>\n"
#~ "  -iprefix <path>           Specify <path> as a prefix for next two options\n"
#~ "  -iwithprefix <dir>        Add <dir> to the end of the system include path\n"
#~ "  -iwithprefixbefore <dir>  Add <dir> to the end of the main include path\n"
#~ "  -isystem <dir>            Add <dir> to the start of the system include path\n"
#~ msgstr "Gushyiramo IDOSIYE i Ibigize Bya IDOSIYE Mbere Ikindi IDOSIYE Insobanuro Bya Makoro in IDOSIYE Inzira Inzira Nka a Imbanziriza kugirango Komeza>> Kuri i Impera Bya i Sisitemu Gushyiramo Kuri i Impera Bya i Gushyiramo Kuri i Gutangira Bya i Sisitemu Gushyiramo"

#, fuzzy
#~ msgid ""
#~ "  -idirafter <dir>          Add <dir> to the end of the system include path\n"
#~ "  -I <dir>                  Add <dir> to the end of the main include path\n"
#~ "  -I-                       Fine-grained include path control; see info docs\n"
#~ "  -nostdinc                 Do not search system include directories\n"
#~ "                             (dirs specified with -isystem will still be used)\n"
#~ "  -nostdinc++               Do not search system include directories for C++\n"
#~ "  -o <file>                 Put output into <file>\n"
#~ msgstr "-Kuri i Impera Bya i Sisitemu Gushyiramo Kuri i Impera Bya i Gushyiramo Gushyiramo Inzira Igenzura Ibisobanuro OYA Gushaka Sisitemu Gushyiramo Na: OYA Gushaka Sisitemu Gushyiramo ububiko bw'amaderese kugirango C o IDOSIYE Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid ""
#~ "  -trigraphs                Support ISO C trigraphs\n"
#~ "  -std=<std name>           Specify the conformance standard; one of:\n"
#~ "                            gnu89, gnu99, c89, c99, iso9899:1990,\n"
#~ "                            iso9899:199409, iso9899:1999, c++98\n"
#~ "  -w                        Inhibit warning messages\n"
#~ "  -W[no-]trigraphs          Warn if trigraphs are encountered\n"
#~ "  -W[no-]comment{s}         Warn if one comment starts inside another\n"
#~ msgstr "-C STD STD Izina: i Bisanzwe Bya C W Iburira Oya NIBA Oya Icyo wongeraho S NIBA Icyo wongeraho Mo Imbere"

#, fuzzy
#~ msgid ""
#~ "  -W[no-]traditional        Warn about features not present in traditional C\n"
#~ "  -W[no-]undef              Warn if an undefined macro is used by #if\n"
#~ "  -W[no-]import             Warn about the use of the #import directive\n"
#~ msgstr "-Oya Ibyerekeye Ibiranga OYA in Oya NIBA kidasobanuye Makoro ni ku Oya Kuzana Ibyerekeye i Gukoresha Bya i Kuzana"

#, fuzzy
#~ msgid ""
#~ "  -W[no-]error              Treat all warnings as errors\n"
#~ "  -W[no-]system-headers     Do not suppress warnings from system headers\n"
#~ "  -W[no-]all                Enable most preprocessor warnings\n"
#~ msgstr "-Oya Ikosa Byose Iburira Nka Oya Sisitemu Imitwe OYA Iburira Bivuye Sisitemu Oya Byose"

#, fuzzy
#~ msgid ""
#~ "  -M                        Generate make dependencies\n"
#~ "  -MM                       As -M, but ignore system header files\n"
#~ "  -MD                       Generate make dependencies and compile\n"
#~ "  -MMD                      As -MD, but ignore system header files\n"
#~ "  -MF <file>                Write dependency output to the given file\n"
#~ "  -MG                       Treat missing header file as generated files\n"
#~ msgstr "-Ubwoko Kwirengagiza Sisitemu Umutwempangano Ubwoko Na Kwirengagiza Sisitemu Umutwempangano IDOSIYE Ibisohoka Kuri i Ibuze Umutwempangano IDOSIYE Nka"

#, fuzzy
#~ msgid ""
#~ "  -MP\t\t\t    Generate phony targets for all headers\n"
#~ "  -MQ <target>              Add a MAKE-quoted target\n"
#~ "  -MT <target>              Add an unquoted target\n"
#~ msgstr "-kugirango Byose Intego a Intego"

#, fuzzy
#~ msgid ""
#~ "  -D<macro>                 Define a <macro> with string '1' as its value\n"
#~ "  -D<macro>=<val>           Define a <macro> with <val> as its value\n"
#~ "  -A<question>=<answer>     Assert the <answer> to <question>\n"
#~ "  -A-<question>=<answer>    Disable the <answer> to <question>\n"
#~ "  -U<macro>                 Undefine <macro> \n"
#~ "  -v                        Display the version number\n"
#~ msgstr "-Makoro a Makoro Na: Ikurikiranyanyuguti Nka Makoro a Makoro Na: Nka A i Kuri A i Kuri U Makoro Makoro v i Verisiyo"

#, fuzzy
#~ msgid ""
#~ "  -H                        Print the name of header files as they are used\n"
#~ "  -C                        Do not discard comments\n"
#~ "  -dM                       Display a list of macro definitions active at end\n"
#~ "  -dD                       Preserve macro definitions in output\n"
#~ "  -dN                       As -dD except that only the names are preserved\n"
#~ "  -dI                       Include #include directives in the output\n"
#~ msgstr "-H i Izina: Bya Umutwempangano Idosiye Nka C OYA Kwanga a Urutonde Bya Makoro Gikora ku Makoro in i Amazina Gushyiramo in i"

#, fuzzy
#~ msgid ""
#~ "  -f[no-]preprocessed       Treat the input file as already preprocessed\n"
#~ "  -ftabstop=<number>        Distance between tab stops for column reporting\n"
#~ "  -P                        Do not generate #line directives\n"
#~ "  -remap                    Remap file names when including files\n"
#~ "  --help                    Display this information\n"
#~ msgstr "-F Oya i Iyinjiza IDOSIYE Nka Umubare hagati Isunika kugirango Inkingi OYA Umurongo IDOSIYE Amazina Ryari: Ifashayobora iyi"

#~ msgid "syntax error"
#~ msgstr "Ikosa mu myandikire"

#, fuzzy
#~ msgid "syntax error: cannot back up"
#~ msgstr "Ikosa Inyuma Hejuru"

#, fuzzy
#~ msgid "ISO C forbids an empty source file"
#~ msgstr "C ubusa Inkomoko IDOSIYE"

#, fuzzy
#~ msgid "argument of `asm' is not a constant string"
#~ msgstr "Bya ni OYA a Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "ISO C forbids data definition with no type or storage class"
#~ msgstr "C Ibyatanzwe Insobanuro Na: Oya Ubwoko Cyangwa ishuri"

#, fuzzy
#~ msgid "data definition has no type or storage class"
#~ msgstr "Ibyatanzwe Insobanuro Oya Ubwoko Cyangwa ishuri"

#, fuzzy
#~ msgid "ISO C does not allow extra `;' outside of a function"
#~ msgstr "C OYA Kwemerera Birenga Hanze Bya a Umumaro"

#, fuzzy
#~ msgid "`sizeof' applied to a bit-field"
#~ msgstr "`Byashyizweho Kuri a Umwanya"

#, fuzzy
#~ msgid "ISO C forbids omitting the middle term of a ?: expression"
#~ msgstr "C i Hagati Ijambo Bya a imvugo"

#, fuzzy
#~ msgid "ISO C forbids braced-groups within expressions"
#~ msgstr "C Amatsinda muri"

#, fuzzy
#~ msgid "first argument to __builtin_choose_expr not a constant"
#~ msgstr "Itangira Kuri OYA a"

#, fuzzy
#~ msgid "traditional C rejects ISO C style function definitions"
#~ msgstr "C C IMISUSIRE Umumaro"

#, fuzzy
#~ msgid "`%s' is not at beginning of declaration"
#~ msgstr "`%s'ni OYA ku Itangiriro Bya"

#, fuzzy
#~ msgid "ISO C forbids empty initializer braces"
#~ msgstr "C ubusa Ingirwadusodeko"

#, fuzzy
#~ msgid "ISO C89 forbids specifying subobject to initialize"
#~ msgstr "Kuri gutangiza"

#, fuzzy
#~ msgid "obsolete use of designated initializer without `='"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "obsolete use of designated initializer with `:'"
#~ msgstr "Gukoresha Bya Na:"

#, fuzzy
#~ msgid "ISO C forbids specifying range of elements to initialize"
#~ msgstr "C Urutonde Bya Ibintu Kuri gutangiza"

#, fuzzy
#~ msgid "ISO C forbids nested functions"
#~ msgstr "C Imimaro"

#, fuzzy
#~ msgid "ISO C forbids forward references to `enum' types"
#~ msgstr "C Imbere Indango Kuri"

#, fuzzy
#~ msgid "comma at end of enumerator list"
#~ msgstr "Akitso ku Impera Bya Urutonde"

#, fuzzy
#~ msgid "no semicolon at end of struct or union"
#~ msgstr "Oya Akabago n'Akitso ku Impera Bya Cyangwa Ihuza"

#, fuzzy
#~ msgid "extra semicolon in struct or union specified"
#~ msgstr "Birenga Akabago n'Akitso in Cyangwa Ihuza"

#, fuzzy
#~ msgid "ISO C doesn't support unnamed structs/unions"
#~ msgstr "C Gushigikira Kitiswe"

#, fuzzy
#~ msgid "ISO C forbids member declarations with no members"
#~ msgstr "C Na: Oya"

#, fuzzy
#~ msgid "deprecated use of label at end of compound statement"
#~ msgstr "Bitemewe. Gukoresha Bya Akarango ku Impera Bya Inyandiko"

#, fuzzy
#~ msgid "ISO C89 forbids mixed declarations and code"
#~ msgstr "Bivanze Na ITEGEKONGENGA"

#, fuzzy
#~ msgid "ISO C forbids label declarations"
#~ msgstr "C Akarango"

#, fuzzy
#~ msgid "braced-group within expression allowed only inside a function"
#~ msgstr "Itsinda muri imvugo Mo Imbere a Umumaro"

#, fuzzy
#~ msgid "empty body in an else-statement"
#~ msgstr "ubusa Umubiri in Ikindi Inyandiko"

#, fuzzy
#~ msgid "ISO C forbids `goto *expr;'"
#~ msgstr "C"

#, fuzzy
#~ msgid "ISO C forbids forward parameter declarations"
#~ msgstr "C Imbere"

#, fuzzy
#~ msgid "ISO C requires a named argument before `...'"
#~ msgstr "C a Mbere"

#, fuzzy
#~ msgid "`...' in old-style identifier list"
#~ msgstr "`...'in ki/ bishaje IMISUSIRE Ikiranga Urutonde"

#, fuzzy
#~ msgid "parse error; also virtual memory exhausted"
#~ msgstr "Ikosa Kitaboneka Ububiko"

#, fuzzy
#~ msgid "parse error"
#~ msgstr "Ikosa"

#, fuzzy
#~ msgid "parser stack overflow"
#~ msgstr "Byarenze urugero"

#, fuzzy
#~ msgid "%s at end of input"
#~ msgstr "%sku Impera Bya Iyinjiza"

#, fuzzy
#~ msgid "%s before %s'%c'"
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "%s before %s'\\x%x'"
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "%s before string constant"
#~ msgstr "%sMbere Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "%s before numeric constant"
#~ msgstr "%sMbere Bikurikije umubare"

#, fuzzy
#~ msgid "%s before \"%s\""
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "%s before '%s' token"
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "traditional C rejects string concatenation"
#~ msgstr "C Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "syntax error at '%s' token"
#~ msgstr "Ikosa ku"

#, fuzzy
#~ msgid "#pragma pack (pop) encountered without matching #pragma pack (push, <n>)"
#~ msgstr "#Ipaki Ipaki N"

#, fuzzy
#~ msgid "#pragma pack(pop, %s) encountered without matching #pragma pack(push, %s, <n>)"
#~ msgstr "#Ipaki Ipaki N"

#, fuzzy
#~ msgid "#pragma pack(push[, id], <n>) is not supported on this target"
#~ msgstr "#Ipaki ID N ni OYA ku iyi Intego"

#, fuzzy
#~ msgid "#pragma pack(pop[, id], <n>) is not supported on this target"
#~ msgstr "#Ipaki ID N ni OYA ku iyi Intego"

#, fuzzy
#~ msgid "missing '(' after '#pragma pack' - ignored"
#~ msgstr "Ibuze Nyuma"

#, fuzzy
#~ msgid "malformed '#pragma pack(push[, id], <n>)' - ignored"
#~ msgstr "Ipaki ID N"

#, fuzzy
#~ msgid "malformed '#pragma pack(pop[, id])' - ignored"
#~ msgstr "Ipaki ID"

#, fuzzy
#~ msgid "unknown action '%s' for '#pragma pack' - ignored"
#~ msgstr "Kitazwi Igikorwa kugirango"

#, fuzzy
#~ msgid "junk at end of '#pragma pack'"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "alignment must be a small power of two, not %d"
#~ msgstr "Itunganya a Gitoya UMWIKUBE Bya OYA"

#, fuzzy
#~ msgid "applying #pragma weak `%s' after first use results in unspecified behavior"
#~ msgstr "Nyuma Itangira Gukoresha Ibisubizo ku in imyitwarire"

#, fuzzy
#~ msgid "junk at end of #pragma weak"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "junk at end of #pragma redefine_extname"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "#pragma redefine_extname conflicts with declaration"
#~ msgstr "#Na:"

#, fuzzy
#~ msgid "junk at end of #pragma extern_prefix"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "asm declaration conflicts with previous rename"
#~ msgstr "Na: Ibanjirije Guhindura izina"

#, fuzzy
#~ msgid "break statement not within loop or switch"
#~ msgstr "itandukanya Inyandiko OYA muri Cyangwa Hindura"

#, fuzzy
#~ msgid "continue statement not within a loop"
#~ msgstr "urifuzagukomeza Inyandiko OYA muri a"

#, fuzzy
#~ msgid "destructor needed for `%#D'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "where case label appears here"
#~ msgstr "Akarango"

#, fuzzy
#~ msgid "(enclose actions of previous case statements requiring destructors in their own scope.)"
#~ msgstr "(Bya Ibanjirije in Ingano:"

#, fuzzy
#~ msgid "%s qualifier ignored on asm"
#~ msgstr "%sku"

#, fuzzy
#~ msgid "`%s' has an incomplete type"
#~ msgstr "`%s'Ubwoko"

#, fuzzy
#~ msgid "invalid use of void expression"
#~ msgstr "Sibyo Gukoresha Bya imvugo"

#, fuzzy
#~ msgid "invalid use of flexible array member"
#~ msgstr "Sibyo Gukoresha Bya Imbonerahamwe"

#, fuzzy
#~ msgid "invalid use of array with unspecified bounds"
#~ msgstr "Sibyo Gukoresha Bya Imbonerahamwe Na:"

#, fuzzy
#~ msgid "invalid use of undefined type `%s %s'"
#~ msgstr "Sibyo Gukoresha Bya kidasobanuye Ubwoko"

#, fuzzy
#~ msgid "invalid use of incomplete typedef `%s'"
#~ msgstr "Sibyo Gukoresha Bya"

#, fuzzy
#~ msgid "function types not truly compatible in ISO C"
#~ msgstr "Umumaro OYA in C"

#, fuzzy
#~ msgid "types are not quite compatible"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "arithmetic on pointer to an incomplete type"
#~ msgstr "ku Mweretsi Kuri Ubwoko"

#, fuzzy
#~ msgid "%s has no member named `%s'"
#~ msgstr "%sOya"

#, fuzzy
#~ msgid "request for member `%s' in something not a structure or union"
#~ msgstr "Kubaza... kugirango in OYA a Imiterere Cyangwa Ihuza"

#, fuzzy
#~ msgid "dereferencing pointer to incomplete type"
#~ msgstr "Mweretsi Kuri Ubwoko"

#, fuzzy
#~ msgid "dereferencing `void *' pointer"
#~ msgstr "Mweretsi"

#, fuzzy
#~ msgid "invalid type argument of `%s'"
#~ msgstr "Sibyo Ubwoko Bya"

#, fuzzy
#~ msgid "subscript missing in array reference"
#~ msgstr "Inyandiko nyesi Ibuze in Imbonerahamwe Indango"

#, fuzzy
#~ msgid "array subscript has type `char'"
#~ msgstr "Imbonerahamwe Inyandiko nyesi Ubwoko"

#, fuzzy
#~ msgid "array subscript is not an integer"
#~ msgstr "Imbonerahamwe Inyandiko nyesi ni OYA Umubare wuzuye"

#, fuzzy
#~ msgid "ISO C forbids subscripting `register' array"
#~ msgstr "C Imbonerahamwe"

#, fuzzy
#~ msgid "ISO C90 forbids subscripting non-lvalue array"
#~ msgstr "Imbonerahamwe"

#, fuzzy
#~ msgid "subscript has type `char'"
#~ msgstr "Inyandiko nyesi Ubwoko"

#, fuzzy
#~ msgid "subscripted value is neither array nor pointer"
#~ msgstr "Agaciro ni Imbonerahamwe Mweretsi"

#, fuzzy
#~ msgid "`%s' undeclared here (not in a function)"
#~ msgstr "`%s'OYA in a Umumaro"

#, fuzzy
#~ msgid "`%s' undeclared (first use in this function)"
#~ msgstr "`%s'Itangira Gukoresha in iyi Umumaro"

#, fuzzy
#~ msgid "(Each undeclared identifier is reported only once"
#~ msgstr "(Ikiranga ni Rimwe"

#, fuzzy
#~ msgid "for each function it appears in.)"
#~ msgstr "kugirango Umumaro in"

#, fuzzy
#~ msgid "local declaration of `%s' hides instance variable"
#~ msgstr "Bya Urugero IMPINDURAGACIRO"

#, fuzzy
#~ msgid "called object is not a function"
#~ msgstr "Igikoresho ni OYA a Umumaro"

#, fuzzy
#~ msgid "too many arguments to function"
#~ msgstr "ingingo Kuri Umumaro"

#, fuzzy
#~ msgid "type of formal parameter %d is incomplete"
#~ msgstr "Ubwoko Bya ni"

#, fuzzy
#~ msgid "%s as integer rather than floating due to prototype"
#~ msgstr "%sNka Umubare wuzuye Bihindagurika Kuri"

#, fuzzy
#~ msgid "%s as integer rather than complex due to prototype"
#~ msgstr "%sNka Umubare wuzuye ITSINDA RY'IMIBARE C Kuri"

#, fuzzy
#~ msgid "%s as complex rather than floating due to prototype"
#~ msgstr "%sNka ITSINDA RY'IMIBARE C Bihindagurika Kuri"

#, fuzzy
#~ msgid "%s as floating rather than integer due to prototype"
#~ msgstr "%sNka Bihindagurika Umubare wuzuye Kuri"

#, fuzzy
#~ msgid "%s as complex rather than integer due to prototype"
#~ msgstr "%sNka ITSINDA RY'IMIBARE C Umubare wuzuye Kuri"

#, fuzzy
#~ msgid "%s as floating rather than complex due to prototype"
#~ msgstr "%sNka Bihindagurika ITSINDA RY'IMIBARE C Kuri"

#, fuzzy
#~ msgid "%s as `float' rather than `double' due to prototype"
#~ msgstr "%sNka Kuri"

#, fuzzy
#~ msgid "%s with different width due to prototype"
#~ msgstr "%sNa: Ubugari Kuri"

#, fuzzy
#~ msgid "%s as unsigned due to prototype"
#~ msgstr "%sNka Bitashizweho umukono Kuri"

#, fuzzy
#~ msgid "%s as signed due to prototype"
#~ msgstr "%sNka Kuri"

#, fuzzy
#~ msgid "too few arguments to function"
#~ msgstr "ingingo Kuri Umumaro"

#, fuzzy
#~ msgid "suggest parentheses around + or - inside shift"
#~ msgstr "Cyangwa Mo Imbere Gusunika"

#, fuzzy
#~ msgid "suggest parentheses around && within ||"
#~ msgstr "muri"

#, fuzzy
#~ msgid "suggest parentheses around arithmetic in operand of |"
#~ msgstr "in Bya"

#, fuzzy
#~ msgid "suggest parentheses around comparison in operand of |"
#~ msgstr "in Bya"

#, fuzzy
#~ msgid "suggest parentheses around arithmetic in operand of ^"
#~ msgstr "in Bya"

#, fuzzy
#~ msgid "suggest parentheses around comparison in operand of ^"
#~ msgstr "in Bya"

#, fuzzy
#~ msgid "suggest parentheses around + or - in operand of &"
#~ msgstr "Cyangwa in Bya"

#, fuzzy
#~ msgid "suggest parentheses around comparison in operand of &"
#~ msgstr "in Bya"

#, fuzzy
#~ msgid "comparisons like X<=Y<=Z do not have their mathematical meaning"
#~ msgstr "nka OYA Bijyanye n'imibare Igisobanuro"

#, fuzzy
#~ msgid "division by zero"
#~ msgstr "Kugabanya na zeru"

#, fuzzy
#~ msgid "right shift count is negative"
#~ msgstr "Iburyo: Gusunika IBARA ni"

#, fuzzy
#~ msgid "right shift count >= width of type"
#~ msgstr "Iburyo: Gusunika IBARA Ubugari Bya Ubwoko"

#, fuzzy
#~ msgid "left shift count is negative"
#~ msgstr "Ibumoso: Gusunika IBARA ni"

#, fuzzy
#~ msgid "left shift count >= width of type"
#~ msgstr "Ibumoso: Gusunika IBARA Ubugari Bya Ubwoko"

#, fuzzy
#~ msgid "shift count is negative"
#~ msgstr "Gusunika IBARA ni"

#, fuzzy
#~ msgid "shift count >= width of type"
#~ msgstr "Gusunika IBARA Ubugari Bya Ubwoko"

#, fuzzy
#~ msgid "comparing floating point with == or != is unsafe"
#~ msgstr "Bihindagurika Akadomo Na: Cyangwa ni"

#, fuzzy
#~ msgid "ISO C forbids comparison of `void *' with function pointer"
#~ msgstr "C Bya Na: Umumaro Mweretsi"

#, fuzzy
#~ msgid "comparison of distinct pointer types lacks a cast"
#~ msgstr "Bya Mweretsi a"

#, fuzzy
#~ msgid "comparison between pointer and integer"
#~ msgstr "hagati Mweretsi Na Umubare wuzuye"

#, fuzzy
#~ msgid "ISO C forbids ordered comparisons of pointers to functions"
#~ msgstr "C Bya Kuri Imimaro"

#, fuzzy
#~ msgid "comparison of complete and incomplete pointers"
#~ msgstr "Bya Byuzuye Na"

#, fuzzy
#~ msgid "ordered comparison of pointer with integer zero"
#~ msgstr "Bya Mweretsi Na: Umubare wuzuye Zeru"

#, fuzzy
#~ msgid "unordered comparison on non-floating point argument"
#~ msgstr "ku Bihindagurika Akadomo"

#, fuzzy
#~ msgid "comparison between signed and unsigned"
#~ msgstr "hagati Na Bitashizweho umukono"

#, fuzzy
#~ msgid "comparison of promoted ~unsigned with constant"
#~ msgstr "Bya Bitashizweho umukono Na:"

#, fuzzy
#~ msgid "comparison of promoted ~unsigned with unsigned"
#~ msgstr "Bya Bitashizweho umukono Na: Bitashizweho umukono"

#, fuzzy
#~ msgid "pointer of type `void *' used in subtraction"
#~ msgstr "Mweretsi Bya Ubwoko in Gukuramo"

#, fuzzy
#~ msgid "pointer to a function used in subtraction"
#~ msgstr "Mweretsi Kuri a Umumaro in Gukuramo"

#, fuzzy
#~ msgid "wrong type argument to unary plus"
#~ msgstr "Ubwoko Kuri Guteranya"

#, fuzzy
#~ msgid "wrong type argument to unary minus"
#~ msgstr "Ubwoko Kuri"

#, fuzzy
#~ msgid "ISO C does not support `~' for complex conjugation"
#~ msgstr "C OYA Gushigikira kugirango ITSINDA RY'IMIBARE C"

#, fuzzy
#~ msgid "wrong type argument to bit-complement"
#~ msgstr "Ubwoko Kuri"

#, fuzzy
#~ msgid "wrong type argument to abs"
#~ msgstr "Ubwoko Kuri ABS"

#, fuzzy
#~ msgid "wrong type argument to conjugation"
#~ msgstr "Ubwoko Kuri"

#, fuzzy
#~ msgid "wrong type argument to unary exclamation mark"
#~ msgstr "Ubwoko Kuri Ikimenyetso"

#, fuzzy
#~ msgid "ISO C does not support `++' and `--' on complex types"
#~ msgstr "C OYA Gushigikira Na ku ITSINDA RY'IMIBARE C"

#, fuzzy
#~ msgid "wrong type argument to increment"
#~ msgstr "Ubwoko Kuri Iyongeragaciro"

#, fuzzy
#~ msgid "wrong type argument to decrement"
#~ msgstr "Ubwoko Kuri"

#, fuzzy
#~ msgid "increment of pointer to unknown structure"
#~ msgstr "Iyongeragaciro Bya Mweretsi Kuri Kitazwi Imiterere"

#, fuzzy
#~ msgid "decrement of pointer to unknown structure"
#~ msgstr "Bya Mweretsi Kuri Kitazwi Imiterere"

#, fuzzy
#~ msgid "ISO C forbids the address of a cast expression"
#~ msgstr "C i Aderesi Bya a imvugo"

#, fuzzy
#~ msgid "invalid lvalue in unary `&'"
#~ msgstr "Sibyo in"

#, fuzzy
#~ msgid "attempt to take address of bit-field structure member `%s'"
#~ msgstr "Kuri Aderesi Bya Umwanya Imiterere"

# basctl/source\basicide\basidesh.src:RID_IMGBTN_REMOVEWATCH.text
#, fuzzy
#~ msgid "%s"
#~ msgstr "%s"

#, fuzzy
#~ msgid "ISO C forbids use of conditional expressions as lvalues"
#~ msgstr "C Gukoresha Bya Nka"

#, fuzzy
#~ msgid "ISO C forbids use of compound expressions as lvalues"
#~ msgstr "C Gukoresha Bya Nka"

#, fuzzy
#~ msgid "ISO C forbids use of cast expressions as lvalues"
#~ msgstr "C Gukoresha Bya Nka"

#, fuzzy
#~ msgid "%s of read-only member `%s'"
#~ msgstr "%sBya Gusoma"

#, fuzzy
#~ msgid "%s of read-only variable `%s'"
#~ msgstr "%sBya Gusoma IMPINDURAGACIRO"

#, fuzzy
#~ msgid "%s of read-only location"
#~ msgstr "%sBya Gusoma Ahantu"

#, fuzzy
#~ msgid "cannot take address of bit-field `%s'"
#~ msgstr "Aderesi Bya Umwanya"

#, fuzzy
#~ msgid "global register variable `%s' used in nested function"
#~ msgstr "Kwiyandikisha IMPINDURAGACIRO in Umumaro"

#, fuzzy
#~ msgid "register variable `%s' used in nested function"
#~ msgstr "Kwiyandikisha IMPINDURAGACIRO in Umumaro"

#, fuzzy
#~ msgid "address of global register variable `%s' requested"
#~ msgstr "Aderesi Bya Kwiyandikisha IMPINDURAGACIRO"

#, fuzzy
#~ msgid "cannot put object with volatile field into register"
#~ msgstr "Gushyira Igikoresho Na: Umwanya Kwiyandikisha"

#, fuzzy
#~ msgid "address of register variable `%s' requested"
#~ msgstr "Aderesi Bya Kwiyandikisha IMPINDURAGACIRO"

#, fuzzy
#~ msgid "signed and unsigned type in conditional expression"
#~ msgstr "Na Bitashizweho umukono Ubwoko in imvugo"

#, fuzzy
#~ msgid "ISO C forbids conditional expr with only one void side"
#~ msgstr "C Na:"

#, fuzzy
#~ msgid "ISO C forbids conditional expr between `void *' and function pointer"
#~ msgstr "C hagati Na Umumaro Mweretsi"

#, fuzzy
#~ msgid "pointer type mismatch in conditional expression"
#~ msgstr "Mweretsi Ubwoko in imvugo"

#, fuzzy
#~ msgid "pointer/integer type mismatch in conditional expression"
#~ msgstr "Mweretsi Umubare wuzuye Ubwoko in imvugo"

#, fuzzy
#~ msgid "type mismatch in conditional expression"
#~ msgstr "Ubwoko in imvugo"

#, fuzzy
#~ msgid "left-hand operand of comma expression has no effect"
#~ msgstr "Ibumoso: Bya Akitso imvugo Oya INGARUKA"

#, fuzzy
#~ msgid "cast specifies array type"
#~ msgstr "Imbonerahamwe Ubwoko"

#, fuzzy
#~ msgid "cast specifies function type"
#~ msgstr "Umumaro Ubwoko"

#, fuzzy
#~ msgid "ISO C forbids casting nonscalar to the same type"
#~ msgstr "C Kuri i Ubwoko"

#, fuzzy
#~ msgid "ISO C forbids casts to union type"
#~ msgstr "C Kuri Ihuza Ubwoko"

#, fuzzy
#~ msgid "cast to union type from type not present in union"
#~ msgstr "Kuri Ihuza Ubwoko Bivuye Ubwoko OYA in Ihuza"

#, fuzzy
#~ msgid "cast adds new qualifiers to function type"
#~ msgstr "Gishya Kuri Umumaro Ubwoko"

#, fuzzy
#~ msgid "cast discards qualifiers from pointer target type"
#~ msgstr "Bivuye Mweretsi Intego Ubwoko"

#, fuzzy
#~ msgid "cast increases required alignment of target type"
#~ msgstr "Bya ngombwa Itunganya Bya Intego Ubwoko"

#, fuzzy
#~ msgid "cast from pointer to integer of different size"
#~ msgstr "Bivuye Mweretsi Kuri Umubare wuzuye Bya Ingano"

#, fuzzy
#~ msgid "cast does not match function type"
#~ msgstr "OYA BIHUYE Umumaro Ubwoko"

#, fuzzy
#~ msgid "cast to pointer from integer of different size"
#~ msgstr "Kuri Mweretsi Bivuye Umubare wuzuye Bya Ingano"

#, fuzzy
#~ msgid "type-punning to incomplete type might break strict-aliasing rules"
#~ msgstr "Ubwoko Kuri Ubwoko itandukanya"

#, fuzzy
#~ msgid "dereferencing type-punned pointer will break strict-aliasing rules"
#~ msgstr "Ubwoko Mweretsi itandukanya"

#, fuzzy
#~ msgid "invalid lvalue in assignment"
#~ msgstr "Sibyo in Igenera"

#, fuzzy
#~ msgid "assignment"
#~ msgstr "Igenera"

#, fuzzy
#~ msgid "cannot pass rvalue to reference parameter"
#~ msgstr "Kuri Indango"

#, fuzzy
#~ msgid "%s makes qualified function pointer from unqualified"
#~ msgstr "%sUmumaro Mweretsi Bivuye"

#, fuzzy
#~ msgid "%s discards qualifiers from pointer target type"
#~ msgstr "%sBivuye Mweretsi Intego Ubwoko"

#, fuzzy
#~ msgid "ISO C prohibits argument conversion to union type"
#~ msgstr "C Ihindurangero Kuri Ihuza Ubwoko"

#, fuzzy
#~ msgid "ISO C forbids %s between function pointer and `void *'"
#~ msgstr "C hagati Umumaro Mweretsi Na"

#, fuzzy
#~ msgid "pointer targets in %s differ in signedness"
#~ msgstr "Mweretsi in in"

#, fuzzy
#~ msgid "%s from incompatible pointer type"
#~ msgstr "%sBivuye Mweretsi Ubwoko"

#, fuzzy
#~ msgid "%s makes pointer from integer without a cast"
#~ msgstr "%sMweretsi Bivuye Umubare wuzuye a"

#, fuzzy
#~ msgid "%s makes integer from pointer without a cast"
#~ msgstr "%sUmubare wuzuye Bivuye Mweretsi a"

#, fuzzy
#~ msgid "incompatible type for argument %d of `%s'"
#~ msgstr "Ubwoko kugirango Bya"

#, fuzzy
#~ msgid "incompatible type for argument %d of indirect function call"
#~ msgstr "Ubwoko kugirango Bya BUZIGUYE Umumaro"

#, fuzzy
#~ msgid "incompatible types in %s"
#~ msgstr "in"

#, fuzzy
#~ msgid "passing arg of `%s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "passing arg of pointer to function"
#~ msgstr "Bya Mweretsi Kuri Umumaro"

#, fuzzy
#~ msgid "passing arg %d of `%s'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "passing arg %d of pointer to function"
#~ msgstr "Bya Mweretsi Kuri Umumaro"

#, fuzzy
#~ msgid "initializer for static variable is not constant"
#~ msgstr "kugirango IMPINDURAGACIRO ni OYA"

#, fuzzy
#~ msgid "initializer for static variable uses complicated arithmetic"
#~ msgstr "kugirango IMPINDURAGACIRO"

#, fuzzy
#~ msgid "aggregate initializer is not constant"
#~ msgstr "ni OYA"

#, fuzzy
#~ msgid "traditional C rejects automatic aggregate initialization"
#~ msgstr "C Byikoresha"

#, fuzzy
#~ msgid "(near initialization for `%s')"
#~ msgstr "(kugirango"

#, fuzzy
#~ msgid "char-array initialized from wide string"
#~ msgstr "INYUGUTI Imbonerahamwe Bivuye Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "int-array initialized from non-wide string"
#~ msgstr "INT Imbonerahamwe Bivuye Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "initializer-string for array of chars is too long"
#~ msgstr "Ikurikiranyanyuguti kugirango Imbonerahamwe Bya ni"

#, fuzzy
#~ msgid "array initialized from non-constant array expression"
#~ msgstr "Imbonerahamwe Bivuye Imbonerahamwe imvugo"

#, fuzzy
#~ msgid "initializer element is not constant"
#~ msgstr "Ikigize: ni OYA"

#, fuzzy
#~ msgid "initializer element is not computable at load time"
#~ msgstr "Ikigize: ni OYA ku Ibirimo Igihe"

#, fuzzy
#~ msgid "invalid initializer"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "extra brace group at end of initializer"
#~ msgstr "Birenga Itsinda ku Impera Bya"

#, fuzzy
#~ msgid "missing braces around initializer"
#~ msgstr "Ibuze Ingirwadusodeko"

#, fuzzy
#~ msgid "braces around scalar initializer"
#~ msgstr "Ingirwadusodeko"

#, fuzzy
#~ msgid "initialization of flexible array member in a nested context"
#~ msgstr "Bya Imbonerahamwe in a Imvugiro"

#, fuzzy
#~ msgid "initialization of a flexible array member"
#~ msgstr "Bya a Imbonerahamwe"

#, fuzzy
#~ msgid "missing initializer"
#~ msgstr "Ibuze"

#, fuzzy
#~ msgid "empty scalar initializer"
#~ msgstr "ubusa"

#, fuzzy
#~ msgid "extra elements in scalar initializer"
#~ msgstr "Birenga Ibintu in"

#, fuzzy
#~ msgid "initialization designators may not nest"
#~ msgstr "Gicurasi OYA"

#, fuzzy
#~ msgid "array index in non-array initializer"
#~ msgstr "Imbonerahamwe Umubarendanga in Imbonerahamwe"

#, fuzzy
#~ msgid "field name not in record or union initializer"
#~ msgstr "Umwanya Izina: OYA in Icyabitswe Cyangwa Ihuza"

#, fuzzy
#~ msgid "nonconstant array index in initializer"
#~ msgstr "Imbonerahamwe Umubarendanga in"

#, fuzzy
#~ msgid "array index in initializer exceeds array bounds"
#~ msgstr "Imbonerahamwe Umubarendanga in Imbonerahamwe"

#, fuzzy
#~ msgid "empty index range in initializer"
#~ msgstr "ubusa Umubarendanga Urutonde in"

#, fuzzy
#~ msgid "array index range in initializer exceeds array bounds"
#~ msgstr "Imbonerahamwe Umubarendanga Urutonde in Imbonerahamwe"

#, fuzzy
#~ msgid "unknown field `%s' specified in initializer"
#~ msgstr "Kitazwi Umwanya in"

#, fuzzy
#~ msgid "initialized field with side-effects overwritten"
#~ msgstr "Umwanya Na: Ingaruka"

#, fuzzy
#~ msgid "excess elements in char array initializer"
#~ msgstr "Ibintu in INYUGUTI Imbonerahamwe"

#, fuzzy
#~ msgid "excess elements in struct initializer"
#~ msgstr "Ibintu in"

#, fuzzy
#~ msgid "non-static initialization of a flexible array member"
#~ msgstr "Bya a Imbonerahamwe"

#, fuzzy
#~ msgid "excess elements in union initializer"
#~ msgstr "Ibintu in Ihuza"

#, fuzzy
#~ msgid "traditional C rejects initialization of unions"
#~ msgstr "C Bya"

#, fuzzy
#~ msgid "excess elements in array initializer"
#~ msgstr "Ibintu in Imbonerahamwe"

#, fuzzy
#~ msgid "excess elements in vector initializer"
#~ msgstr "Ibintu in"

#, fuzzy
#~ msgid "excess elements in scalar initializer"
#~ msgstr "Ibintu in"

#, fuzzy
#~ msgid "asm template is not a string constant"
#~ msgstr "Inyandikorugero ni OYA a Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "invalid lvalue in asm statement"
#~ msgstr "Sibyo in Inyandiko"

#, fuzzy
#~ msgid "modification by `asm'"
#~ msgstr "ku"

#, fuzzy
#~ msgid "function declared `noreturn' has a `return' statement"
#~ msgstr "Umumaro a Inyandiko"

#, fuzzy
#~ msgid "`return' with no value, in function returning non-void"
#~ msgstr "`Na: Oya Agaciro in Umumaro"

#, fuzzy
#~ msgid "`return' with a value, in function returning void"
#~ msgstr "`Na: a Agaciro in Umumaro"

#, fuzzy
#~ msgid "return"
#~ msgstr "Garuka"

#, fuzzy
#~ msgid "function returns address of local variable"
#~ msgstr "Umumaro Aderesi Bya IMPINDURAGACIRO"

#, fuzzy
#~ msgid "switch quantity not an integer"
#~ msgstr "Hindura Ingano OYA Umubare wuzuye"

#, fuzzy
#~ msgid "`long' switch expression not converted to `int' in ISO C"
#~ msgstr "`Hindura imvugo OYA Kuri in C"

#, fuzzy
#~ msgid "case label not within a switch statement"
#~ msgstr "Akarango OYA muri a Hindura Inyandiko"

#, fuzzy
#~ msgid "`default' label not within a switch statement"
#~ msgstr "`Akarango OYA muri a Hindura Inyandiko"

#, fuzzy
#~ msgid "inlining failed in call to `%s'"
#~ msgstr "Byanze in Kuri"

#, fuzzy
#~ msgid "called from here"
#~ msgstr "Bivuye"

#, fuzzy
#~ msgid "can't inline call to `%s'"
#~ msgstr "Mumurongo Kuri"

#, fuzzy
#~ msgid "function call has aggregate value"
#~ msgstr "Umumaro Agaciro"

#, fuzzy
#~ msgid "Size of loop %d should be %d, not %d."
#~ msgstr "Bya OYA"

#, fuzzy
#~ msgid "Bb %d do not belong to loop %d."
#~ msgstr "OYA Kuri"

#, fuzzy
#~ msgid "Loop %d's header does not have exactly 2 entries."
#~ msgstr "S Umutwempangano OYA 2. Ibyinjijwe"

#, fuzzy
#~ msgid "Loop %d's latch does not have exactly 1 successor."
#~ msgstr "S OYA 1."

#, fuzzy
#~ msgid "Loop %d's latch does not have header as successor."
#~ msgstr "S OYA Umutwempangano Nka"

#, fuzzy
#~ msgid "Loop %d's latch does not belong directly to it."
#~ msgstr "S OYA Kuri"

#, fuzzy
#~ msgid "Loop %d's header does not belong directly to it."
#~ msgstr "S Umutwempangano OYA Kuri"

#, fuzzy
#~ msgid "bb %d on wrong place"
#~ msgstr "ku"

#, fuzzy
#~ msgid "prev_bb of %d should be %d, not %d"
#~ msgstr "Bya OYA"

#, fuzzy
#~ msgid "end insn %d for block %d not found in the insn stream"
#~ msgstr "Impera kugirango Funga OYA Byabonetse in i"

#, fuzzy
#~ msgid "insn %d is in multiple basic blocks (%d and %d)"
#~ msgstr "ni in Igikubo BASIC Na"

#, fuzzy
#~ msgid "head insn %d for block %d not found in the insn stream"
#~ msgstr "kugirango Funga OYA Byabonetse in i"

#, fuzzy
#~ msgid "verify_flow_info: REG_BR_PROB does not match cfg %i %i"
#~ msgstr "OYA BIHUYE"

#, fuzzy
#~ msgid "verify_flow_info: Wrong count of block %i %i"
#~ msgstr "IBARA Bya Funga"

#, fuzzy
#~ msgid "verify_flow_info: Wrong frequency of block %i %i"
#~ msgstr "Ubwisubire Bya Funga"

#, fuzzy
#~ msgid "verify_flow_info: Wrong probability of edge %i->%i %i"
#~ msgstr "Imishobokere Bya"

#, fuzzy
#~ msgid "verify_flow_info: Wrong count of edge %i->%i %i"
#~ msgstr "IBARA Bya"

#, fuzzy
#~ msgid "verify_flow_info: Incorrect blocks for fallthru %i->%i"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "wrong insn in the fallthru edge"
#~ msgstr "in i"

#, fuzzy
#~ msgid "verify_flow_info: Basic block %d succ edge is corrupted"
#~ msgstr "Funga ni"

#, fuzzy
#~ msgid "Missing REG_EH_REGION note in the end of bb %i"
#~ msgstr "Impugukirwa in i Impera Bya"

#, fuzzy
#~ msgid "Too many outgoing branch edges from bb %i"
#~ msgstr "Bivuye"

#, fuzzy
#~ msgid "Fallthru edge after unconditional jump %i"
#~ msgstr "Nyuma Simbuka"

#, fuzzy
#~ msgid "Wrong amount of branch edges after unconditional jump %i"
#~ msgstr "Igiteranyo Bya Nyuma Simbuka"

#, fuzzy
#~ msgid "Wrong amount of branch edges after conditional jump %i"
#~ msgstr "Igiteranyo Bya Nyuma Simbuka"

#, fuzzy
#~ msgid "Call edges for non-call insn in bb %i"
#~ msgstr "kugirango in"

#, fuzzy
#~ msgid "Abnormal edges for no purpose in bb %i"
#~ msgstr "kugirango Oya Intego in"

#, fuzzy
#~ msgid "missing barrier after block %i"
#~ msgstr "Ibuze Nyuma Funga"

#, fuzzy
#~ msgid "basic block %d pred edge is corrupted"
#~ msgstr "BASIC Funga ni"

#, fuzzy
#~ msgid "insn %d inside basic block %d but block_for_insn is NULL"
#~ msgstr "Mo Imbere BASIC Funga ni"

#, fuzzy
#~ msgid "insn %d inside basic block %d but block_for_insn is %i"
#~ msgstr "Mo Imbere BASIC Funga ni"

#, fuzzy
#~ msgid "NOTE_INSN_BASIC_BLOCK is missing for block %d"
#~ msgstr "ni Ibuze kugirango Funga"

#, fuzzy
#~ msgid "NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d"
#~ msgstr "in Hagati Bya BASIC Funga"

#, fuzzy
#~ msgid "in basic block %d:"
#~ msgstr "in BASIC Funga"

#, fuzzy
#~ msgid "flow control insn inside a basic block"
#~ msgstr "Igenzura Mo Imbere a BASIC Funga"

#, fuzzy
#~ msgid "basic block %i edge lists are corrupted"
#~ msgstr "BASIC Funga Intonde"

#, fuzzy
#~ msgid "basic blocks not numbered consecutively"
#~ msgstr "BASIC OYA Iriho Imibare"

#, fuzzy
#~ msgid "insn outside basic block"
#~ msgstr "Hanze BASIC Funga"

#, fuzzy
#~ msgid "return not followed by barrier"
#~ msgstr "Garuka OYA ku"

#, fuzzy
#~ msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
#~ msgstr "Umubare Bya Ibisobanuro in"

#, fuzzy
#~ msgid "verify_flow_info failed"
#~ msgstr "Byanze"

#, fuzzy
#~ msgid "internal error"
#~ msgstr "Ikosa ry'imbere"

#, fuzzy
#~ msgid "no arguments"
#~ msgstr "Oya ingingo"

#, fuzzy
#~ msgid "collect2 version %s"
#~ msgstr "Verisiyo"

#, fuzzy
#~ msgid "%d constructor(s) found\n"
#~ msgstr "%dS"

#, fuzzy
#~ msgid "%d destructor(s)  found\n"
#~ msgstr "%dS"

#, fuzzy
#~ msgid "%d frame table(s) found\n"
#~ msgstr "%dIkadiri imbonerahamwe# S"

#, fuzzy
#~ msgid "%s terminated with signal %d [%s]%s"
#~ msgstr "%sNa:"

#, fuzzy
#~ msgid "%s returned %d exit status"
#~ msgstr "%sGusohoka Imimerere"

#, fuzzy
#~ msgid "[cannot find %s]"
#~ msgstr "[Gushaka"

#, fuzzy
#~ msgid "cannot find `%s'"
#~ msgstr "Gushaka"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "write_c_file - output name is %s, prefix is %s\n"
#~ msgstr "Ibisohoka Izina: ni Imbanziriza ni"

#, fuzzy
#~ msgid "cannot find `nm'"
#~ msgstr "Gushaka"

#, fuzzy
#~ msgid "dup2 %d 1"
#~ msgstr "1."

# svx/source\svdraw\svdstr.src:STR_EditShut.text
#, fuzzy
#~ msgid "close %d"
#~ msgstr "Gufunga"

#, fuzzy
#~ msgid "init function found in object %s"
#~ msgstr "Umumaro Byabonetse in Igikoresho"

#, fuzzy
#~ msgid "fini function found in object %s"
#~ msgstr "Umumaro Byabonetse in Igikoresho"

#, fuzzy
#~ msgid "unable to open file '%s'"
#~ msgstr "Kuri Gufungura IDOSIYE"

#, fuzzy
#~ msgid "unable to stat file '%s'"
#~ msgstr "Kuri IDOSIYE"

#, fuzzy
#~ msgid "unable to mmap file '%s'"
#~ msgstr "Kuri IDOSIYE"

#, fuzzy
#~ msgid "not found\n"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "dynamic dependency %s not found"
#~ msgstr "OYA Byabonetse"

#, fuzzy
#~ msgid "bad magic number in file '%s'"
#~ msgstr "Umubare in IDOSIYE"

#, fuzzy
#~ msgid "cannot find `ldd'"
#~ msgstr "Gushaka"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "ldd output with constructors/destructors.\n"
#~ msgstr "Ibisohoka Na:"

#, fuzzy
#~ msgid "unable to open dynamic dependency '%s'"
#~ msgstr "Kuri Gufungura"

#, fuzzy
#~ msgid "%s: not a COFF file"
#~ msgstr "%s:OYA a IDOSIYE"

#, fuzzy
#~ msgid "%s: cannot open as COFF file"
#~ msgstr "%s:Gufungura Nka IDOSIYE"

#, fuzzy
#~ msgid "library lib%s not found"
#~ msgstr "Isomero OYA Byabonetse"

# sfx2/source\appl\minbox.src:RID_MAIL_INBOX.BTN_MAILINBOX_OPEN.text
#, fuzzy
#~ msgid "open %s"
#~ msgstr "Gufungura..."

#, fuzzy
#~ msgid "incompatibilities between object file & expected values"
#~ msgstr "hagati Igikoresho IDOSIYE Ikitezwe: Uduciro"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "Processing symbol table #%d, offset = 0x%.8lx, kind = %s\n"
#~ msgstr "IKIMENYETSO imbonerahamwe# Nta- boneza"

#, fuzzy
#~ msgid "string section missing"
#~ msgstr "Ikurikiranyanyuguti Icyiciro Ibuze"

#, fuzzy
#~ msgid "section pointer missing"
#~ msgstr "Icyiciro Mweretsi Ibuze"

#, fuzzy
#~ msgid "no symbol table found"
#~ msgstr "Oya IKIMENYETSO imbonerahamwe# Byabonetse"

#, fuzzy
#~ msgid "no cmd_strings found"
#~ msgstr "Oya Byabonetse"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "Updating header and load commands.\n"
#~ "\n"
#~ msgstr "Umutwempangano Na Ibirimo Amabwiriza"

#, fuzzy
#~ msgid "load command map, %d cmds, new size %ld.\n"
#~ msgstr "Ibirimo Komandi: Gishya Ingano"

#, fuzzy
#~ msgid ""
#~ "writing load commands.\n"
#~ "\n"
#~ msgstr "Ibirimo Amabwiriza"

# svx/source\svdraw\svdstr.src:STR_EditShut.text
#, fuzzy
#~ msgid "close %s"
#~ msgstr "Gufunga"

#, fuzzy
#~ msgid "could not convert 0x%l.8x into a region"
#~ msgstr "OYA GUHINDURA a"

#, fuzzy
#~ msgid "%s function, region %d, offset = %ld (0x%.8lx)\n"
#~ msgstr "%sUmumaro Nta- boneza"

#, fuzzy
#~ msgid "bad magic number"
#~ msgstr "Umubare"

#, fuzzy
#~ msgid "bad header version"
#~ msgstr "Umutwempangano Verisiyo"

#, fuzzy
#~ msgid "bad raw header version"
#~ msgstr "Umutwempangano Verisiyo"

#, fuzzy
#~ msgid "raw header buffer too small"
#~ msgstr "Umutwempangano Gitoya"

#, fuzzy
#~ msgid "old raw header file"
#~ msgstr "ki/ bishaje Umutwempangano IDOSIYE"

#, fuzzy
#~ msgid "unsupported version"
#~ msgstr "Verisiyo"

#, fuzzy
#~ msgid "unknown {de,en}code_mach_o_hdr return value %d"
#~ msgstr "Kitazwi Garuka Agaciro"

#, fuzzy
#~ msgid "lseek %s 0"
#~ msgstr "0"

# svx/inc\globlmn.hrc:ITEM_FILE_MAIL_INBOX.text
#, fuzzy
#~ msgid "read %s"
#~ msgstr "Gusoma"

#, fuzzy
#~ msgid "read %ld bytes, expected %ld, from %s"
#~ msgstr "Gusoma Bayite Ikitezwe: Bivuye"

# #-#-#-#-#  officecfg.pot (PACKAGE VERSION)  #-#-#-#-#
# officecfg/registry\schema\org\openoffice\Office\Common.xcs:....Filter.HTML.Export.Browser..3.text
# #-#-#-#-#  officecfg.pot (PACKAGE VERSION)  #-#-#-#-#
# officecfg/registry\schema\org\openoffice\Office\Writer.xcs:....FormLetter.MailingOutput.Format..8.text
#, fuzzy
#~ msgid "write %s"
#~ msgstr "Kwandika"

#, fuzzy
#~ msgid "wrote %ld bytes, expected %ld, to %s"
#~ msgstr "Bayite Ikitezwe: Kuri"

#, fuzzy
#~ msgid ""
#~ ";; Combiner statistics: %d attempts, %d substitutions (%d requiring new space),\n"
#~ ";; %d successes.\n"
#~ "\n"
#~ msgstr ";;Sitatisitiki Gishya Umwanya Ibyatunganye"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ ";; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n"
#~ ";; %d successes.\n"
#~ msgstr ";;Gishya Umwanya Ibyatunganye"

#, fuzzy
#~ msgid "cannot convert to a pointer type"
#~ msgstr "GUHINDURA Kuri a Mweretsi Ubwoko"

#, fuzzy
#~ msgid "pointer value used where a floating point value was expected"
#~ msgstr "Mweretsi Agaciro a Bihindagurika Akadomo Agaciro Ikitezwe:"

#, fuzzy
#~ msgid "aggregate value used where a float was expected"
#~ msgstr "Agaciro a Kureremba Ikitezwe:"

#, fuzzy
#~ msgid "conversion to incomplete type"
#~ msgstr "Ihindurangero Kuri Ubwoko"

#, fuzzy
#~ msgid "can't convert between vector values of different size"
#~ msgstr "GUHINDURA hagati Uduciro Bya Ingano"

#, fuzzy
#~ msgid "aggregate value used where an integer was expected"
#~ msgstr "Agaciro Umubare wuzuye Ikitezwe:"

#, fuzzy
#~ msgid "pointer value used where a complex was expected"
#~ msgstr "Mweretsi Agaciro a ITSINDA RY'IMIBARE C Ikitezwe:"

#, fuzzy
#~ msgid "aggregate value used where a complex was expected"
#~ msgstr "Agaciro a ITSINDA RY'IMIBARE C Ikitezwe:"

#, fuzzy
#~ msgid "can't convert value to a vector"
#~ msgstr "GUHINDURA Agaciro Kuri a"

#, fuzzy
#~ msgid "ISO C++ does not permit \"%s\" in #if"
#~ msgstr "C OYA in NIBA"

#, fuzzy
#~ msgid "invalid character '%c' in #if"
#~ msgstr "Sibyo Inyuguti in NIBA"

#, fuzzy
#~ msgid "invalid character '\\%03o' in #if"
#~ msgstr "Sibyo Inyuguti in NIBA"

#, fuzzy
#~ msgid "absolute file name in remap_filename"
#~ msgstr "IDOSIYE Izina: in"

#, fuzzy
#~ msgid "ignoring nonexistent directory \"%s\"\n"
#~ msgstr "bushyinguro"

#, fuzzy
#~ msgid "%s: Not a directory"
#~ msgstr "%s:a bushyinguro"

#, fuzzy
#~ msgid "ignoring duplicate directory \"%s\"\n"
#~ msgstr "Gusubiramo bushyinguro"

#, fuzzy
#~ msgid "  as it is a non-system directory that duplicates a system directory\n"
#~ msgstr "Nka ni a Sisitemu bushyinguro a Sisitemu"

#, fuzzy
#~ msgid "#include \"...\" search starts here:\n"
#~ msgstr "#Gushyiramo Gushaka"

#, fuzzy
#~ msgid "#include <...> search starts here:\n"
#~ msgstr "#Gushyiramo Gushaka"

#, fuzzy
#~ msgid "End of search list.\n"
#~ msgstr "Impera Bya Gushaka Urutonde"

#, fuzzy
#~ msgid "<built-in>"
#~ msgstr "<in"

#, fuzzy
#~ msgid "<command line>"
#~ msgstr "<Komandi: Umurongo"

#, fuzzy
#~ msgid "assertion missing after %s"
#~ msgstr "Ibuze Nyuma"

#, fuzzy
#~ msgid "directory name missing after %s"
#~ msgstr "bushyinguro Izina: Ibuze Nyuma"

#, fuzzy
#~ msgid "file name missing after %s"
#~ msgstr "IDOSIYE Izina: Ibuze Nyuma"

#, fuzzy
#~ msgid "macro name missing after %s"
#~ msgstr "Makoro Izina: Ibuze Nyuma"

#, fuzzy
#~ msgid "path name missing after %s"
#~ msgstr "Inzira Izina: Ibuze Nyuma"

#, fuzzy
#~ msgid "unknown string token %s\n"
#~ msgstr "Kitazwi Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "non-hex digit '%c' in universal-character-name"
#~ msgstr "in Ky'isi yose Inyuguti Izina:"

#, fuzzy
#~ msgid "universal-character-name on EBCDIC target"
#~ msgstr "Ky'isi yose Inyuguti Izina: ku Intego"

#, fuzzy
#~ msgid "universal-character-name out of range"
#~ msgstr "Ky'isi yose Inyuguti Izina: Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "unknown escape sequence: '\\%03o'"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "escape sequence out of range for its type"
#~ msgstr "Inyuma Bya Urutonde kugirango Ubwoko"

#, fuzzy
#~ msgid "#import is obsolete, use an #ifndef wrapper in the header file"
#~ msgstr "#Kuzana ni Gukoresha in i Umutwempangano IDOSIYE"

#, fuzzy
#~ msgid "#pragma once is obsolete"
#~ msgstr "#Rimwe ni"

#, fuzzy
#~ msgid "\"%s\" is not a valid option to the preprocessor"
#~ msgstr "\"%s\"ni OYA a Byemewe Ihitamo Kuri i"

#, fuzzy
#~ msgid "too many input files"
#~ msgstr "Iyinjiza Idosiye"

#, fuzzy
#~ msgid ";; Processing block from %d to %d, %d sets.\n"
#~ msgstr ";;Funga Bivuye Kuri"

#, fuzzy
#~ msgid "%s: warnings being treated as errors\n"
#~ msgstr "%s:Iburira Nka"

#, fuzzy
#~ msgid "%s: %s: "
#~ msgstr "%s:%s:"

# basctl/source\basicide\basidesh.src:RID_IMGBTN_REMOVEWATCH.text
#, fuzzy
#~ msgid "%s "
#~ msgstr "%s"

# basctl/source\basicide\basidesh.src:RID_IMGBTN_REMOVEWATCH.text
#, fuzzy
#~ msgid " %s"
#~ msgstr "%s"

#, fuzzy
#~ msgid "At top level:"
#~ msgstr "Hejuru: urwego"

#, fuzzy
#~ msgid "In member function `%s':"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "In function `%s':"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "%s:%d: confused by earlier errors, bailing out\n"
#~ msgstr "%s:%d:ku Amakosa"

#, fuzzy
#~ msgid ""
#~ "Please submit a full bug report,\n"
#~ "with preprocessed source if appropriate.\n"
#~ "See %s for instructions.\n"
#~ msgstr "Tanga a Icyegeranyo Na: Inkomoko NIBA kugirango Amabwiriza"

#, fuzzy
#~ msgid "Internal compiler error: Error reporting routines re-entered.\n"
#~ msgstr "Ikosa"

#, fuzzy
#~ msgid "in %s, at %s:%d"
#~ msgstr "in ku"

#, fuzzy
#~ msgid "In file included from %s:%d"
#~ msgstr "IDOSIYE Bivuye"

#, fuzzy
#~ msgid ""
#~ ",\n"
#~ "                 from %s:%d"
#~ msgstr ",Bivuye"

# basctl/source\basicide\basidesh.src:RID_IMGBTN_REMOVEWATCH.text
#, fuzzy
#~ msgid ":\n"
#~ msgstr ":"

#, fuzzy
#~ msgid "`%s' is deprecated (declared at %s:%d)"
#~ msgstr "`%s'ni Bitemewe. ku"

#, fuzzy
#~ msgid "`%s' is deprecated"
#~ msgstr "`%s'ni Bitemewe."

#, fuzzy
#~ msgid "type is deprecated (declared at %s:%d)"
#~ msgstr "Ubwoko ni Bitemewe. ku"

#, fuzzy
#~ msgid "type is deprecated"
#~ msgstr "Ubwoko ni Bitemewe."

#, fuzzy
#~ msgid "dominator of %d should be %d, not %d"
#~ msgstr "Bya OYA"

#, fuzzy
#~ msgid "DW_LOC_OP %s not implemented\n"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "internal regno botch: `%s' has regno = %d\n"
#~ msgstr "By'imbere"

#, fuzzy
#~ msgid "support for the DWARF1 debugging format is deprecated"
#~ msgstr "Gushigikira kugirango i Imiterere ni Bitemewe."

#, fuzzy
#~ msgid "can't get current directory"
#~ msgstr "Kubona KIGEZWEHO bushyinguro"

#, fuzzy
#~ msgid "can't access real part of complex value in hard register"
#~ msgstr "Bya ITSINDA RY'IMIBARE C Agaciro in Ikomeye Kwiyandikisha"

#, fuzzy
#~ msgid "can't access imaginary part of complex value in hard register"
#~ msgstr "NYURABWENGE Bya ITSINDA RY'IMIBARE C Agaciro in Ikomeye Kwiyandikisha"

#, fuzzy
#~ msgid "abort in %s, at %s:%d"
#~ msgstr "Kureka in ku"

#, fuzzy
#~ msgid "exception handling disabled, use -fexceptions to enable"
#~ msgstr "Irengayobora(-) Yahagaritswe Gukoresha Kuri Gushoboza"

#, fuzzy
#~ msgid "argument of `__builtin_eh_return_regno' must be constant"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "__builtin_eh_return not supported on this target"
#~ msgstr "_OYA ku iyi Intego"

#, fuzzy
#~ msgid "stack limits not supported on this target"
#~ msgstr "Imbibi OYA ku iyi Intego"

#, fuzzy
#~ msgid "function using short complex types cannot be inline"
#~ msgstr "Umumaro ikoresha ITSINDA RY'IMIBARE C Mumurongo"

#, fuzzy
#~ msgid "unsupported wide integer operation"
#~ msgstr "Umubare wuzuye"

#, fuzzy
#~ msgid "prior parameter's size depends on `%s'"
#~ msgstr "Ingano ku"

#, fuzzy
#~ msgid "returned value in block_exit_expr"
#~ msgstr "Agaciro in"

#, fuzzy
#~ msgid "cannot take the address of an unaligned member"
#~ msgstr "i Aderesi Bya"

#, fuzzy
#~ msgid "negative insn length"
#~ msgstr "Uburebure"

#, fuzzy
#~ msgid "could not split insn"
#~ msgstr "OYA Gutandukanya"

#, fuzzy
#~ msgid "invalid `asm': "
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "operand number missing after %%-letter"
#~ msgstr "Umubare Ibuze Nyuma"

#, fuzzy
#~ msgid "operand number out of range"
#~ msgstr "Umubare Inyuma Bya Urutonde"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_INVALID.text
#, fuzzy
#~ msgid "invalid %%-code"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "`%%l' operand isn't a label"
#~ msgstr "`%%l'si a Akarango"

#, fuzzy
#~ msgid "floating constant misused"
#~ msgstr "Bihindagurika"

#, fuzzy
#~ msgid "invalid expression as operand"
#~ msgstr "Sibyo imvugo Nka"

#, fuzzy
#~ msgid "function might be possible candidate for attribute `noreturn'"
#~ msgstr "Umumaro kugirango Ikiranga"

#, fuzzy
#~ msgid "`noreturn' function does return"
#~ msgstr "`Umumaro Garuka"

#, fuzzy
#~ msgid "control reaches end of non-void function"
#~ msgstr "Igenzura Impera Bya Umumaro"

#, fuzzy
#~ msgid "Attempt to delete prologue/epilogue insn:"
#~ msgstr "Kuri Gusiba"

#, fuzzy
#~ msgid "comparison is always %d due to width of bit-field"
#~ msgstr "ni Buri gihe Kuri Ubugari Bya Umwanya"

#, fuzzy
#~ msgid "comparison is always %d"
#~ msgstr "ni Buri gihe"

#, fuzzy
#~ msgid "`or' of unmatched not-equal tests is always 1"
#~ msgstr "`Bya OYA bingana ni Buri gihe 1."

#, fuzzy
#~ msgid "`and' of mutually exclusive equal-tests is always 0"
#~ msgstr "`Bya bingana ni Buri gihe 0"

#, fuzzy
#~ msgid "size of variable `%s' is too large"
#~ msgstr "Ingano Bya IMPINDURAGACIRO ni Binini"

#, fuzzy
#~ msgid "impossible constraint in `asm'"
#~ msgstr "Imbogamizi in"

#, fuzzy
#~ msgid "`%s' might be used uninitialized in this function"
#~ msgstr "`%s'Itatangijwe in iyi Umumaro"

#, fuzzy
#~ msgid "variable `%s' might be clobbered by `longjmp' or `vfork'"
#~ msgstr "IMPINDURAGACIRO ku Cyangwa"

#, fuzzy
#~ msgid "argument `%s' might be clobbered by `longjmp' or `vfork'"
#~ msgstr "ku Cyangwa"

#, fuzzy
#~ msgid "function returns an aggregate"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "unused parameter `%s'"
#~ msgstr "Kidakoreshwa"

#, fuzzy
#~ msgid "ambiguous abbreviation %s"
#~ msgstr "Impine"

#, fuzzy
#~ msgid "incomplete `%s' option"
#~ msgstr "Ihitamo"

#, fuzzy
#~ msgid "missing argument to `%s' option"
#~ msgstr "Ibuze Kuri Ihitamo"

#, fuzzy
#~ msgid "extraneous argument to `%s' option"
#~ msgstr "Kuri Ihitamo"

#, fuzzy
#~ msgid "Using built-in specs.\n"
#~ msgstr "in"

#, fuzzy
#~ msgid ""
#~ "Setting spec %s to '%s'\n"
#~ "\n"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Reading specs from %s\n"
#~ msgstr "Bivuye"

#, fuzzy
#~ msgid "specs %%include syntax malformed after %ld characters"
#~ msgstr "Nyuma Inyuguti"

#, fuzzy
#~ msgid "could not find specs file %s\n"
#~ msgstr "OYA Gushaka IDOSIYE"

#, fuzzy
#~ msgid "specs %%rename syntax malformed after %ld characters"
#~ msgstr "Nyuma Inyuguti"

#, fuzzy
#~ msgid "specs %s spec was not found to be renamed"
#~ msgstr "OYA Byabonetse Kuri"

#, fuzzy
#~ msgid "%s: attempt to rename spec '%s' to already defined spec '%s'"
#~ msgstr "%s:Kuri Guhindura izina Kuri"

#, fuzzy
#~ msgid "rename spec %s to %s\n"
#~ msgstr "Guhindura izina Kuri"

#, fuzzy
#~ msgid ""
#~ "spec is '%s'\n"
#~ "\n"
#~ msgstr "ni"

#, fuzzy
#~ msgid "specs unknown %% command after %ld characters"
#~ msgstr "Kitazwi Komandi: Nyuma Inyuguti"

#, fuzzy
#~ msgid "specs file malformed after %ld characters"
#~ msgstr "IDOSIYE Nyuma Inyuguti"

#, fuzzy
#~ msgid "spec file has no spec for linking"
#~ msgstr "IDOSIYE Oya kugirango Impuza"

#, fuzzy
#~ msgid "-pipe not supported"
#~ msgstr "-OYA"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "Go ahead? (y or n) "
#~ msgstr "Y Cyangwa N"

#, fuzzy
#~ msgid ""
#~ "Internal error: %s (program %s)\n"
#~ "Please submit a full bug report.\n"
#~ "See %s for instructions."
#~ msgstr "Ikosa Porogaramu Tanga a Icyegeranyo kugirango Amabwiriza"

#, fuzzy
#~ msgid "# %s %.2f %.2f\n"
#~ msgstr ""
#~ "#%s%.Project- Id- Version: basctl\n"
#~ "POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
#~ "PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
#~ "Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
#~ "Content- Type: text/ plain; charset= UTF- 8\n"
#~ "Content- Transfer- Encoding: 8bit\n"
#~ "X- Generator: KBabel 1. 0\n"
#~ "."

#, fuzzy
#~ msgid "Usage: %s [options] file...\n"
#~ msgstr "Amahitamo IDOSIYE"

# crashrep/source\all\crashrep.lng:%OPTIONS_BUTTON%.text
#, fuzzy
#~ msgid "Options:\n"
#~ msgstr "Amahitamo..."

#, fuzzy
#~ msgid "  -pass-exit-codes         Exit with highest error code from a phase\n"
#~ msgstr "-Gusohoka Na: kirekire kurusha ibindi Ikosa ITEGEKONGENGA Bivuye a"

#, fuzzy
#~ msgid "  --help                   Display this information\n"
#~ msgstr "--Ifashayobora iyi"

#, fuzzy
#~ msgid "  --target-help            Display target specific command line options\n"
#~ msgstr "--Intego Ifashayobora Intego Komandi: Umurongo"

#, fuzzy
#~ msgid "  (Use '-v --help' to display command line options of sub-processes)\n"
#~ msgstr "(v Kuri Kugaragaza Komandi: Umurongo Amahitamo Bya"

#, fuzzy
#~ msgid "  -dumpspecs               Display all of the built in spec strings\n"
#~ msgstr "-Byose Bya i in"

#, fuzzy
#~ msgid "  -dumpversion             Display the version of the compiler\n"
#~ msgstr "-i Verisiyo Bya i"

#, fuzzy
#~ msgid "  -dumpmachine             Display the compiler's target processor\n"
#~ msgstr "-i Intego"

#, fuzzy
#~ msgid "  -print-search-dirs       Display the directories in the compiler's search path\n"
#~ msgstr "-Gucapa Gushaka i ububiko bw'amaderese in i Gushaka"

#, fuzzy
#~ msgid "  -print-libgcc-file-name  Display the name of the compiler's companion library\n"
#~ msgstr "-Gucapa IDOSIYE Izina: i Izina: Bya i"

#, fuzzy
#~ msgid "  -print-file-name=<lib>   Display the full path to library <lib>\n"
#~ msgstr "-Gucapa IDOSIYE Izina: i Inzira Kuri Isomero"

#, fuzzy
#~ msgid "  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"
#~ msgstr "-Gucapa Izina: i Inzira Kuri"

#, fuzzy
#~ msgid "  -print-multi-directory   Display the root directory for versions of libgcc\n"
#~ msgstr "-Gucapa bushyinguro i Imizi bushyinguro kugirango Uburyo Bya"

#, fuzzy
#~ msgid ""
#~ "  -print-multi-lib         Display the mapping between command line options and\n"
#~ "                           multiple library search directories\n"
#~ msgstr "-Gucapa i Igereranya hagati Komandi: Umurongo Amahitamo Igikubo Isomero Gushaka"

#, fuzzy
#~ msgid "  -print-multi-os-directory Display the relative path to OS libraries\n"
#~ msgstr "-Gucapa bushyinguro i Bifitanye isano Inzira Kuri"

#, fuzzy
#~ msgid "  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"
#~ msgstr "-Amahitamo Akitso Amahitamo ku Kuri i"

#, fuzzy
#~ msgid "  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"
#~ msgstr "-Amahitamo Akitso Amahitamo ku Kuri i"

#, fuzzy
#~ msgid "  -Wl,<options>            Pass comma-separated <options> on to the linker\n"
#~ msgstr "-Amahitamo Akitso Amahitamo ku Kuri i"

#, fuzzy
#~ msgid "  -Xlinker <arg>           Pass <arg> on to the linker\n"
#~ msgstr "-ku Kuri i"

#, fuzzy
#~ msgid "  -save-temps              Do not delete intermediate files\n"
#~ msgstr "-Kubika OYA Gusiba"

#, fuzzy
#~ msgid "  -time                    Time the execution of each subprocess\n"
#~ msgstr "-Igihe i Bya"

#, fuzzy
#~ msgid "  -specs=<file>            Override built-in specs with the contents of <file>\n"
#~ msgstr "-IDOSIYE in Na: i Ibigize Bya IDOSIYE"

#, fuzzy
#~ msgid "  -std=<standard>          Assume that the input sources are for <standard>\n"
#~ msgstr "-STD Bisanzwe i Iyinjiza kugirango Bisanzwe"

#, fuzzy
#~ msgid "  -B <directory>           Add <directory> to the compiler's search paths\n"
#~ msgstr "-bushyinguro bushyinguro Kuri i Gushaka"

#, fuzzy
#~ msgid "  -b <machine>             Run gcc for target <machine>, if installed\n"
#~ msgstr "-B kugirango Intego NIBA"

#, fuzzy
#~ msgid "  -V <version>             Run gcc version number <version>, if installed\n"
#~ msgstr "-V Verisiyo Verisiyo Umubare Verisiyo NIBA"

#, fuzzy
#~ msgid "  -v                       Display the programs invoked by the compiler\n"
#~ msgstr "-v i Porogaramu ku i"

#, fuzzy
#~ msgid "  -###                     Like -v but options quoted and commands not executed\n"
#~ msgstr "-###v Amahitamo Na Amabwiriza OYA"

#, fuzzy
#~ msgid "  -E                       Preprocess only; do not compile, assemble or link\n"
#~ msgstr "-E OYA Gukusanya Cyangwa"

#, fuzzy
#~ msgid "  -S                       Compile only; do not assemble or link\n"
#~ msgstr "-OYA Cyangwa"

#, fuzzy
#~ msgid "  -c                       Compile and assemble, but do not link\n"
#~ msgstr "-C Na OYA"

#, fuzzy
#~ msgid "  -o <file>                Place the output into <file>\n"
#~ msgstr "-o IDOSIYE i Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid ""
#~ "  -x <language>            Specify the language of the following input files\n"
#~ "                           Permissible languages include: c c++ assembler none\n"
#~ "                           'none' means revert to the default behavior of\n"
#~ "                           guessing the language based on the file's extension\n"
#~ msgstr "-X Ururimi i Ururimi Bya i Iyinjiza Indimi Gushyiramo C C Kugaruza Kuri i Mburabuzi imyitwarire i Ururimi ku i"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "Options starting with -g, -f, -m, -O, -W, or --param are automatically\n"
#~ " passed on to the various sub-processes invoked by %s.  In order to pass\n"
#~ " other options on to these processes the -W<letter> options must be used.\n"
#~ msgstr "Na: g F M Cyangwa ku Kuri i ku Itondekanya Kuri Ikindi Amahitamo ku Kuri i Ibaruwa... Amahitamo"

#, fuzzy
#~ msgid "`-%c' option must have argument"
#~ msgstr "`-%c'Ihitamo"

#, fuzzy
#~ msgid "couldn't run `%s': %s"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "Copyright (C) 2003 Free Software Foundation, Inc.\n"
#~ msgstr "C"

#, fuzzy
#~ msgid ""
#~ "This is free software; see the source for copying conditions.  There is NO\n"
#~ "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
#~ "\n"
#~ msgstr "ni Kigenga i Inkomoko kugirango ni OYA ATARIIGIHARWE kugirango Cyangwa A"

#, fuzzy
#~ msgid "argument to `-Xlinker' is missing"
#~ msgstr "Kuri ni Ibuze"

#, fuzzy
#~ msgid "argument to `-l' is missing"
#~ msgstr "Kuri ni Ibuze"

#, fuzzy
#~ msgid "argument to `-specs' is missing"
#~ msgstr "Kuri ni Ibuze"

#, fuzzy
#~ msgid "argument to `-specs=' is missing"
#~ msgstr "Kuri ni Ibuze"

#, fuzzy
#~ msgid "`-%c' must come at the start of the command line"
#~ msgstr "`-%c'ku i Gutangira Bya i Komandi: Umurongo"

#, fuzzy
#~ msgid "argument to `-B' is missing"
#~ msgstr "Kuri ni Ibuze"

#, fuzzy
#~ msgid "cannot specify -o with -c or -S and multiple compilations"
#~ msgstr "o Na: C Cyangwa Na Igikubo"

#, fuzzy
#~ msgid "warning: -pipe ignored because -save-temps specified"
#~ msgstr "Iburira Kubika"

#, fuzzy
#~ msgid "warning: -pipe ignored because -time specified"
#~ msgstr "Iburira Igihe"

#, fuzzy
#~ msgid "argument to `-x' is missing"
#~ msgstr "Kuri ni Ibuze"

#, fuzzy
#~ msgid "argument to `-%s' is missing"
#~ msgstr "Kuri ni Ibuze"

#, fuzzy
#~ msgid "warning: `-x %s' after last input file has no effect"
#~ msgstr "Iburira X Nyuma Iheruka Iyinjiza IDOSIYE Oya INGARUKA"

#, fuzzy
#~ msgid "invalid specification!  Bug in cc"
#~ msgstr "Sibyo in KopiKubandi"

# basctl/source\basicide\basidesh.src:RID_IMGBTN_REMOVEWATCH.text
#, fuzzy
#~ msgid "%s\n"
#~ msgstr "%s"

#, fuzzy
#~ msgid "spec failure: '%%*' has not been initialized by pattern match"
#~ msgstr "OYA ku Ishusho BIHUYE"

#, fuzzy
#~ msgid "warning: use of obsolete %%[ operator in specs"
#~ msgstr "Iburira Gukoresha Bya Mukoresha in"

#, fuzzy
#~ msgid "Processing spec %c%s%c, which is '%s'\n"
#~ msgstr "ni"

#, fuzzy
#~ msgid "spec failure: unrecognized spec option '%c'"
#~ msgstr "Ihitamo"

#, fuzzy
#~ msgid "unknown spec function `%s'"
#~ msgstr "Kitazwi Umumaro"

#, fuzzy
#~ msgid "error in args to spec function `%s'"
#~ msgstr "Ikosa in Kuri Umumaro"

#, fuzzy
#~ msgid "malformed spec function name"
#~ msgstr "Umumaro Izina:"

#, fuzzy
#~ msgid "no arguments for spec function"
#~ msgstr "Oya ingingo kugirango Umumaro"

#, fuzzy
#~ msgid "malformed spec function arguments"
#~ msgstr "Umumaro ingingo"

#, fuzzy
#~ msgid "mismatched braces in specs"
#~ msgstr "Ingirwadusodeko in"

#, fuzzy
#~ msgid "unrecognized option `-%s'"
#~ msgstr "Ihitamo"

# #-#-#-#-#  setup2.pot (PACKAGE VERSION)  #-#-#-#-#
# setup2/source\ui\pages\plang.src:RESID_PAGE_PAGELANGUAGE.STR_PROG.text
# #-#-#-#-#  setup2.pot (PACKAGE VERSION)  #-#-#-#-#
# setup2/source\uibase\agentdlg.src:RC_AGENTDLG.RESID_DLG_AGENT_STR_INSTALL.text
#, fuzzy
#~ msgid "install: %s%s\n"
#~ msgstr "Kwinjiza porogaramu"

#, fuzzy
#~ msgid "programs: %s\n"
#~ msgstr "Porogaramu"

# basctl/source\basicide\moduldlg.src:RID_TD_ORGANIZE.RID_TC_ORGANIZE.RID_TP_LIB.text
#, fuzzy
#~ msgid "libraries: %s\n"
#~ msgstr "Amasomero"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "For bug reporting instructions, please see:\n"
#~ msgstr "Amabwiriza"

#, fuzzy
#~ msgid "Configured with: %s\n"
#~ msgstr "Na:"

#, fuzzy
#~ msgid "Thread model: %s\n"
#~ msgstr "Urugero"

#, fuzzy
#~ msgid "gcc version %s\n"
#~ msgstr "Verisiyo"

#, fuzzy
#~ msgid "gcc driver version %s executing gcc version %s\n"
#~ msgstr "Musomyi: Verisiyo Gukora: %s%s Verisiyo"

#, fuzzy
#~ msgid "no input files"
#~ msgstr "Oya Iyinjiza Idosiye"

#, fuzzy
#~ msgid "%s: %s compiler not installed on this system"
#~ msgstr "%s:%sOYA ku iyi Sisitemu"

#, fuzzy
#~ msgid "%s: linker input file unused because linking not done"
#~ msgstr "%s:Iyinjiza IDOSIYE Kidakoreshwa Impuza OYA Byakozwe"

#, fuzzy
#~ msgid "language %s not recognized"
#~ msgstr "Ururimi OYA"

#, fuzzy
#~ msgid "internal gcc abort"
#~ msgstr "By'imbere Kureka"

#, fuzzy
#~ msgid "Internal gcov abort.\n"
#~ msgstr "Kureka"

#, fuzzy
#~ msgid ""
#~ "Print code coverage information.\n"
#~ "\n"
#~ msgstr "ITEGEKONGENGA Ibisobanuro"

#, fuzzy
#~ msgid "  -h, --help                      Print this help, then exit\n"
#~ msgstr "-h Ifashayobora iyi Ifashayobora Hanyuma"

#, fuzzy
#~ msgid "  -v, --version                   Print version number, then exit\n"
#~ msgstr "-v Verisiyo Verisiyo Umubare Hanyuma"

#, fuzzy
#~ msgid "  -b, --branch-probabilities      Include branch probabilities in output\n"
#~ msgstr "-B in"

#, fuzzy
#~ msgid ""
#~ "  -c, --branch-counts             Given counts of branches taken\n"
#~ "                                    rather than percentages\n"
#~ msgstr "-C Bya"

#, fuzzy
#~ msgid "  -n, --no-output                 Do not create an output file\n"
#~ msgstr "-N Oya Ibisohoka OYA Kurema Ibisohoka"

#, fuzzy
#~ msgid ""
#~ "  -l, --long-file-names           Use long output file names for included\n"
#~ "                                    source files\n"
#~ msgstr "-L IDOSIYE Amazina Ibisohoka IDOSIYE Amazina kugirango Inkomoko"

#, fuzzy
#~ msgid "  -f, --function-summaries        Output summaries for each function\n"
#~ msgstr "-F Umumaro kugirango"

#, fuzzy
#~ msgid "  -o, --object-directory DIR|FILE Search for object files in DIR or called FILE\n"
#~ msgstr "-o Igikoresho bushyinguro kugirango Igikoresho Idosiye in Cyangwa"

#, fuzzy
#~ msgid "  -p, --preserve-paths            Preserve all pathname components\n"
#~ msgstr "-P Inzira Byose"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "For bug reporting instructions, please see:\n"
#~ "%s.\n"
#~ msgstr "Amabwiriza"

#, fuzzy
#~ msgid "Copyright (C) 2001 Free Software Foundation, Inc.\n"
#~ msgstr "C"

#, fuzzy
#~ msgid "Could not open basic block file %s.\n"
#~ msgstr "OYA Gufungura BASIC Funga IDOSIYE"

#, fuzzy
#~ msgid "Could not open program flow graph file %s.\n"
#~ msgstr "OYA Gufungura Porogaramu IDOSIYE"

#, fuzzy
#~ msgid "Could not open data file %s.\n"
#~ msgstr "OYA Gufungura Ibyatanzwe IDOSIYE"

#, fuzzy
#~ msgid "Assuming that all execution counts are zero.\n"
#~ msgstr "Byose Zeru"

#, fuzzy
#~ msgid "No executable code associated with file %s.\n"
#~ msgstr "ITEGEKONGENGA Na: IDOSIYE"

#, fuzzy
#~ msgid "%s of %d lines executed in %s %s\n"
#~ msgstr "%sBya Imirongo in"

#, fuzzy
#~ msgid "No executable lines in %s %s\n"
#~ msgstr "Imirongo in"

#, fuzzy
#~ msgid "%s of %d branches executed in %s %s\n"
#~ msgstr "%sBya in"

#, fuzzy
#~ msgid "%s of %d branches taken at least once in %s %s\n"
#~ msgstr "%sBya ku Rimwe in"

#, fuzzy
#~ msgid "No branches in %s %s\n"
#~ msgstr "in"

#, fuzzy
#~ msgid "%s of %d calls executed in %s %s\n"
#~ msgstr "%sBya Amahamagara: in"

#, fuzzy
#~ msgid "No calls in %s %s\n"
#~ msgstr "Amahamagara: in"

#, fuzzy
#~ msgid "didn't use all bb entries of graph, function %s\n"
#~ msgstr "Gukoresha Byose Ibyinjijwe Bya Umumaro"

#, fuzzy
#~ msgid "ERROR: unexpected line number %ld\n"
#~ msgstr "Umurongo Umubare"

#, fuzzy
#~ msgid "ERROR: too many basic blocks in function %s\n"
#~ msgstr "BASIC in Umumaro"

#, fuzzy
#~ msgid "ERROR: out of range line number in function %s\n"
#~ msgstr "Inyuma Bya Urutonde Umurongo Umubare in Umumaro"

#, fuzzy
#~ msgid "Could not open source file %s.\n"
#~ msgstr "OYA Gufungura Inkomoko IDOSIYE"

#, fuzzy
#~ msgid "Warning: source file %s is newer than %s\n"
#~ msgstr "Inkomoko IDOSIYE ni"

#, fuzzy
#~ msgid "Unexpected EOF while reading source file %s.\n"
#~ msgstr "Inkomoko IDOSIYE"

#, fuzzy
#~ msgid "call   %2d never executed\n"
#~ msgstr "Nta narimwe"

#, fuzzy
#~ msgid "branch %2d never executed\n"
#~ msgstr "Nta narimwe"

#, fuzzy
#~ msgid "Error writing output file %s.\n"
#~ msgstr "Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid "Could not open output file %s.\n"
#~ msgstr "OYA Gufungura Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid "GCSE disabled: %d > 1000 basic blocks and %d >= 20 edges/basic block"
#~ msgstr "Yahagaritswe 1000 BASIC Na 20 BASIC Funga"

#, fuzzy
#~ msgid "GCSE disabled: %d basic blocks and %d registers"
#~ msgstr "Yahagaritswe BASIC Na"

#, fuzzy
#~ msgid "Name `%s' contains quotes"
#~ msgstr "Kirimo"

#, fuzzy
#~ msgid "invalid string `%s' in define_cpu_unit"
#~ msgstr "Sibyo Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid string `%s' in define_query_cpu_unit"
#~ msgstr "Sibyo Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid string `%s' in define_bypass"
#~ msgstr "Sibyo Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid first string `%s' in exclusion_set"
#~ msgstr "Sibyo Itangira Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid second string `%s' in exclusion_set"
#~ msgstr "Sibyo ISEGONDA Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid first string `%s' in presence_set"
#~ msgstr "Sibyo Itangira Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid second string `%s' in presence_set"
#~ msgstr "Sibyo ISEGONDA Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid first string `%s' in absence_set"
#~ msgstr "Sibyo Itangira Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid second string `%s' in absence_set"
#~ msgstr "Sibyo ISEGONDA Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid string `%s' in define_automaton"
#~ msgstr "Sibyo Ikurikiranyanyuguti in"

#, fuzzy
#~ msgid "invalid option `%s' in automata_option"
#~ msgstr "Sibyo Ihitamo in"

#, fuzzy
#~ msgid "garbage after ) in reservation `%s'"
#~ msgstr "Nyuma in"

#, fuzzy
#~ msgid "invalid `%s' in reservation `%s'"
#~ msgstr "Sibyo in"

#, fuzzy
#~ msgid "repetition `%s' <= 1 in reservation `%s'"
#~ msgstr "1. in"

#, fuzzy
#~ msgid "unit `%s' in exclusion is not declared"
#~ msgstr "Igice: in ni OYA"

#, fuzzy
#~ msgid "`%s' in exclusion is not unit"
#~ msgstr "`%s'in ni OYA Igice:"

#, fuzzy
#~ msgid "unit `%s' excludes itself"
#~ msgstr "Igice:"

#, fuzzy
#~ msgid "units `%s' and `%s' in exclusion set belong to different automata"
#~ msgstr "Na in Gushyiraho Kuri"

#, fuzzy
#~ msgid "unit `%s' excludes and requires presence of `%s'"
#~ msgstr "Igice: Na Bya"

#, fuzzy
#~ msgid "unit `%s' requires absence and presence of `%s'"
#~ msgstr "Igice: Na Bya"

#, fuzzy
#~ msgid "repeated declaration of automaton `%s'"
#~ msgstr "byasubiyemo Bya"

#, fuzzy
#~ msgid "define_insn_reservation `%s' has negative latency time"
#~ msgstr "Igihe"

#, fuzzy
#~ msgid "`%s' is already used as insn reservation name"
#~ msgstr "`%s'ni Nka Izina:"

#, fuzzy
#~ msgid "define_bypass `%s - %s' has negative latency time"
#~ msgstr "Igihe"

#, fuzzy
#~ msgid "automaton `%s' is not declared"
#~ msgstr "ni OYA"

#, fuzzy
#~ msgid "define_unit `%s' without automaton when one defined"
#~ msgstr "Ryari:"

#, fuzzy
#~ msgid "`%s' is declared as cpu unit"
#~ msgstr "`%s'ni Nka CPU Igice:"

#, fuzzy
#~ msgid "`%s' is declared as cpu reservation"
#~ msgstr "`%s'ni Nka CPU"

#, fuzzy
#~ msgid "repeated declaration of unit `%s'"
#~ msgstr "byasubiyemo Bya Igice:"

#, fuzzy
#~ msgid "repeated declaration of reservation `%s'"
#~ msgstr "byasubiyemo Bya"

#, fuzzy
#~ msgid "there is no insn reservation `%s'"
#~ msgstr "ni Oya"

#, fuzzy
#~ msgid "the same bypass `%s - %s' is already defined"
#~ msgstr "i ni"

#, fuzzy
#~ msgid "bypass `%s - %s' is already defined"
#~ msgstr "ni"

#, fuzzy
#~ msgid "automaton `%s' is not used"
#~ msgstr "ni OYA"

#, fuzzy
#~ msgid "undeclared unit or reservation `%s'"
#~ msgstr "Igice: Cyangwa"

#, fuzzy
#~ msgid "unit `%s' is not used"
#~ msgstr "Igice: ni OYA"

#, fuzzy
#~ msgid "reservation `%s' is not used"
#~ msgstr "ni OYA"

#, fuzzy
#~ msgid "cycle in definition of reservation `%s'"
#~ msgstr "Uruziga in Insobanuro Bya"

#, fuzzy
#~ msgid "Units `%s' and `%s' should be in the same automaton"
#~ msgstr "Na in i"

#, fuzzy
#~ msgid "-split has no argument."
#~ msgstr "-Gutandukanya Oya"

#, fuzzy
#~ msgid "option `-split' has not been implemented yet\n"
#~ msgstr "Ihitamo OYA"

#, fuzzy
#~ msgid "Automaton `%s': Insn `%s' will never be issued"
#~ msgstr "Nta narimwe Byasohowe"

#, fuzzy
#~ msgid "Insn `%s' will never be issued"
#~ msgstr "Nta narimwe Byasohowe"

#, fuzzy
#~ msgid "Errors in DFA description"
#~ msgstr "in Isobanuramiterere"

#, fuzzy
#~ msgid "Error in writing DFA description file %s"
#~ msgstr "in Isobanuramiterere IDOSIYE"

#, fuzzy
#~ msgid "No input file name."
#~ msgstr "Iyinjiza IDOSIYE Izina:"

#, fuzzy
#~ msgid "can't open %s"
#~ msgstr "Gufungura"

#, fuzzy
#~ msgid "fix_sched_param: unknown param: %s"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "function cannot be inline"
#~ msgstr "Umumaro Mumurongo"

#, fuzzy
#~ msgid "varargs function cannot be inline"
#~ msgstr "Umumaro Mumurongo"

#, fuzzy
#~ msgid "function using alloca cannot be inline"
#~ msgstr "Umumaro ikoresha Mumurongo"

#, fuzzy
#~ msgid "function using setjmp cannot be inline"
#~ msgstr "Umumaro ikoresha Mumurongo"

#, fuzzy
#~ msgid "function uses __builtin_eh_return"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "function with nested functions cannot be inline"
#~ msgstr "Umumaro Na: Imimaro Mumurongo"

#, fuzzy
#~ msgid "function with label addresses used in initializers cannot inline"
#~ msgstr "Umumaro Na: Akarango Amaderesi in Mumurongo"

#, fuzzy
#~ msgid "function too large to be inline"
#~ msgstr "Umumaro Binini Kuri Mumurongo"

#, fuzzy
#~ msgid "no prototype, and parameter address used; cannot be inline"
#~ msgstr "Oya Na Aderesi Mumurongo"

#, fuzzy
#~ msgid "inline functions not supported for this return value type"
#~ msgstr "Mumurongo Imimaro OYA kugirango iyi Garuka Agaciro Ubwoko"

#, fuzzy
#~ msgid "function with varying-size return value cannot be inline"
#~ msgstr "Umumaro Na: Ingano Garuka Agaciro Mumurongo"

#, fuzzy
#~ msgid "function with varying-size parameter cannot be inline"
#~ msgstr "Umumaro Na: Ingano Mumurongo"

#, fuzzy
#~ msgid "function with transparent unit parameter cannot be inline"
#~ msgstr "Umumaro Na: Bibonerana Igice: Mumurongo"

#, fuzzy
#~ msgid "function with computed jump cannot inline"
#~ msgstr "Umumaro Na: Simbuka Mumurongo"

#, fuzzy
#~ msgid "function with nonlocal goto cannot be inline"
#~ msgstr "Umumaro Na: Mumurongo"

#, fuzzy
#~ msgid "function with target specific attribute(s) cannot be inlined"
#~ msgstr "Umumaro Na: Intego Ikiranga S"

#, fuzzy
#~ msgid "invalid parameter `%s'"
#~ msgstr "Ikigenderwaho sicyo"

#, fuzzy
#~ msgid "Profile does not match flowgraph of function %s (out of date?)"
#~ msgstr "OYA BIHUYE Bya Umumaro Inyuma Bya Itariki"

#, fuzzy
#~ msgid ".da file corrupted"
#~ msgstr ""
#~ ".Project- Id- Version: basctl\n"
#~ "POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
#~ "PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
#~ "Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
#~ "Content- Type: text/ plain; charset= UTF- 8\n"
#~ "Content- Transfer- Encoding: 8bit\n"
#~ "X- Generator: KBabel 1. 0\n"
#~ "."

#, fuzzy
#~ msgid "corrupted profile info: prob for %d-%d thought to be %d"
#~ msgstr "Ibijyana Ibisobanuro PROB kugirango Kuri"

#, fuzzy
#~ msgid "file %s not found, execution counts assumed to be zero"
#~ msgstr "IDOSIYE OYA Byabonetse Kuri Zeru"

#, fuzzy
#~ msgid "%s: internal abort\n"
#~ msgstr "%s:By'imbere"

#, fuzzy
#~ msgid "%s: error writing file `%s': %s\n"
#~ msgstr "%s:Ikosa IDOSIYE"

#, fuzzy
#~ msgid "%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n"
#~ msgstr "%s:Ikoresha: i Izina ry'idosiye:"

#, fuzzy
#~ msgid "%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n"
#~ msgstr "%s:Ikoresha: Izina ry'idosiye:"

#, fuzzy
#~ msgid "%s: warning: no read access for file `%s'\n"
#~ msgstr "%s:Iburira Oya Gusoma kugirango IDOSIYE"

#, fuzzy
#~ msgid "%s: warning: no write access for file `%s'\n"
#~ msgstr "%s:Iburira Oya Kwandika kugirango IDOSIYE"

#, fuzzy
#~ msgid "%s: warning: no write access for dir containing `%s'\n"
#~ msgstr "%s:Iburira Oya Kwandika kugirango"

#, fuzzy
#~ msgid "%s: invalid file name: %s\n"
#~ msgstr "%s:Sibyo IDOSIYE Izina:"

#, fuzzy
#~ msgid "%s: %s: can't get status: %s\n"
#~ msgstr "%s:%s:Kubona Imimerere"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "%s: fatal error: aux info file corrupted at line %d\n"
#~ msgstr "%s:Ikosa Ibisobanuro IDOSIYE ku Umurongo"

#, fuzzy
#~ msgid "%s:%d: declaration of function `%s' takes different forms\n"
#~ msgstr "%s:%d:Bya Umumaro"

#, fuzzy
#~ msgid "%s: wait: %s\n"
#~ msgstr "%s:Tegereza"

#, fuzzy
#~ msgid "%s: %s exited with status %d\n"
#~ msgstr "%s:%sNa: Imimerere"

#, fuzzy
#~ msgid "%s: warning: missing SYSCALLS file `%s'\n"
#~ msgstr "%s:Iburira Ibuze IDOSIYE"

#, fuzzy
#~ msgid "%s: can't read aux info file `%s': %s\n"
#~ msgstr "%s:Gusoma Ibisobanuro IDOSIYE"

#, fuzzy
#~ msgid "%s: can't get status of aux info file `%s': %s\n"
#~ msgstr "%s:Kubona Imimerere Bya Ibisobanuro IDOSIYE"

#, fuzzy
#~ msgid "%s: can't open aux info file `%s' for reading: %s\n"
#~ msgstr "%s:Gufungura Ibisobanuro IDOSIYE kugirango"

#, fuzzy
#~ msgid "%s: error reading aux info file `%s': %s\n"
#~ msgstr "%s:Ikosa Ibisobanuro IDOSIYE"

#, fuzzy
#~ msgid "%s: error closing aux info file `%s': %s\n"
#~ msgstr "%s:Ikosa Ibisobanuro IDOSIYE"

#, fuzzy
#~ msgid "%s: can't delete aux info file `%s': %s\n"
#~ msgstr "%s:Gusiba Ibisobanuro IDOSIYE"

#, fuzzy
#~ msgid "%s: can't delete file `%s': %s\n"
#~ msgstr "%s:Gusiba IDOSIYE"

#, fuzzy
#~ msgid "%s: warning: can't rename file `%s' to `%s': %s\n"
#~ msgstr "%s:Iburira Guhindura izina IDOSIYE Kuri"

#, fuzzy
#~ msgid "%s: conflicting extern definitions of '%s'\n"
#~ msgstr "%s:Bya"

#, fuzzy
#~ msgid "%s: declarations of '%s' will not be converted\n"
#~ msgstr "%s:Bya OYA"

#, fuzzy
#~ msgid "%s: conflict list for '%s' follows:\n"
#~ msgstr "%s:Urutonde kugirango"

#, fuzzy
#~ msgid "%s: warning: using formals list from %s(%d) for function `%s'\n"
#~ msgstr "%s:Iburira ikoresha Urutonde Bivuye kugirango Umumaro"

#, fuzzy
#~ msgid "%s: %d: `%s' used but missing from SYSCALLS\n"
#~ msgstr "%s:%d:`%s'Ibuze Bivuye"

#, fuzzy
#~ msgid "%s: %d: warning: no extern definition for `%s'\n"
#~ msgstr "%s:%d:Iburira Oya Insobanuro kugirango"

#, fuzzy
#~ msgid "%s: warning: no static definition for `%s' in file `%s'\n"
#~ msgstr "%s:Iburira Oya Insobanuro kugirango in IDOSIYE"

#, fuzzy
#~ msgid "%s: multiple static defs of `%s' in file `%s'\n"
#~ msgstr "%s:Igikubo Bya in IDOSIYE"

#, fuzzy
#~ msgid "%s: %d: warning: source too confusing\n"
#~ msgstr "%s:%d:Iburira Inkomoko"

#, fuzzy
#~ msgid "%s: %d: warning: varargs function declaration not converted\n"
#~ msgstr "%s:%d:Iburira Umumaro OYA"

#, fuzzy
#~ msgid "%s: declaration of function `%s' not converted\n"
#~ msgstr "%s:Bya Umumaro OYA"

#, fuzzy
#~ msgid "%s: warning: too many parameter lists in declaration of `%s'\n"
#~ msgstr "%s:Iburira Intonde in Bya"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "%s: warning: too few parameter lists in declaration of `%s'\n"
#~ msgstr "%s:Iburira Intonde in Bya"

#, fuzzy
#~ msgid "%s: %d: warning: found `%s' but expected `%s'\n"
#~ msgstr "%s:%d:Iburira Byabonetse Ikitezwe:"

#, fuzzy
#~ msgid "%s: local declaration for function `%s' not inserted\n"
#~ msgstr "%s:kugirango Umumaro OYA"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "%s: %d: warning: can't add declaration of `%s' into macro call\n"
#~ msgstr "%s:%d:Iburira Kongeramo Bya Makoro"

#, fuzzy
#~ msgid "%s: global declarations for file `%s' not inserted\n"
#~ msgstr "%s:kugirango IDOSIYE OYA"

#, fuzzy
#~ msgid "%s: definition of function `%s' not converted\n"
#~ msgstr "%s:Insobanuro Bya Umumaro OYA"

#, fuzzy
#~ msgid "%s: %d: warning: definition of %s not converted\n"
#~ msgstr "%s:%d:Iburira Insobanuro Bya OYA"

#, fuzzy
#~ msgid "%s: found definition of `%s' at %s(%d)\n"
#~ msgstr "%s:Byabonetse Insobanuro Bya ku"

#, fuzzy
#~ msgid "%s: %d: warning: `%s' excluded by preprocessing\n"
#~ msgstr "%s:%d:Iburira ku"

#, fuzzy
#~ msgid "%s: function definition not converted\n"
#~ msgstr "%s:Umumaro Insobanuro OYA"

#, fuzzy
#~ msgid "%s: `%s' not converted\n"
#~ msgstr "%s:`%s'OYA"

#, fuzzy
#~ msgid "%s: would convert file `%s'\n"
#~ msgstr "%s:GUHINDURA IDOSIYE"

#, fuzzy
#~ msgid "%s: converting file `%s'\n"
#~ msgstr "%s:Guhindura.... IDOSIYE"

#, fuzzy
#~ msgid "%s: can't get status for file `%s': %s\n"
#~ msgstr "%s:Kubona Imimerere kugirango IDOSIYE"

#, fuzzy
#~ msgid "%s: can't open file `%s' for reading: %s\n"
#~ msgstr "%s:Gufungura IDOSIYE kugirango"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "%s: error reading input file `%s': %s\n"
#~ msgstr "%s:Ikosa Iyinjiza IDOSIYE"

#, fuzzy
#~ msgid "%s: can't create/open clean file `%s': %s\n"
#~ msgstr "%s:Kurema Gufungura GUSUKURA IDOSIYE"

#, fuzzy
#~ msgid "%s: warning: file `%s' already saved in `%s'\n"
#~ msgstr "%s:Iburira IDOSIYE in"

#, fuzzy
#~ msgid "%s: can't link file `%s' to `%s': %s\n"
#~ msgstr "%s:Ihuza IDOSIYE Kuri"

#, fuzzy
#~ msgid "%s: can't create/open output file `%s': %s\n"
#~ msgstr "%s:Kurema Gufungura Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid "%s: can't change mode of file `%s': %s\n"
#~ msgstr "%s:Guhindura>> Ubwoko Bya IDOSIYE"

#, fuzzy
#~ msgid "%s: cannot get working directory: %s\n"
#~ msgstr "%s:Kubona bushyinguro"

#, fuzzy
#~ msgid "%s: input file names must have .c suffixes: %s\n"
#~ msgstr "%s:Iyinjiza IDOSIYE Amazina C Imigereka"

#, fuzzy
#~ msgid "Didn't find a coloring.\n"
#~ msgstr "Gushaka a"

#, fuzzy
#~ msgid "output constraint %d must specify a single register"
#~ msgstr "Ibisohoka Imbogamizi a UMWE Kwiyandikisha"

#, fuzzy
#~ msgid "output constraint %d cannot be specified together with \"%s\" clobber"
#~ msgstr "Ibisohoka Imbogamizi Na:"

#, fuzzy
#~ msgid "output regs must be grouped at top of stack"
#~ msgstr "Ibisohoka ku Hejuru: Bya"

#, fuzzy
#~ msgid "implicitly popped regs must be grouped at top of stack"
#~ msgstr "ku Hejuru: Bya"

#, fuzzy
#~ msgid "output operand %d must use `&' constraint"
#~ msgstr "Ibisohoka Gukoresha Imbogamizi"

#, fuzzy
#~ msgid "can't use '%s' as a %s register"
#~ msgstr "Gukoresha Nka a Kwiyandikisha"

#, fuzzy
#~ msgid "unknown register name: %s"
#~ msgstr "Kitazwi Kwiyandikisha Izina:"

#, fuzzy
#~ msgid "global register variable follows a function definition"
#~ msgstr "Kwiyandikisha IMPINDURAGACIRO a Umumaro Insobanuro"

#, fuzzy
#~ msgid "register used for two global register variables"
#~ msgstr "Kwiyandikisha kugirango Kwiyandikisha Ibihinduka"

#, fuzzy
#~ msgid "call-clobbered register used for global register variable"
#~ msgstr "Kwiyandikisha kugirango Kwiyandikisha IMPINDURAGACIRO"

#, fuzzy
#~ msgid "validate_value_data: [%u] Bad next_regno for empty chain (%u)"
#~ msgstr "kugirango ubusa"

#, fuzzy
#~ msgid "validate_value_data: Loop in regno chain (%u)"
#~ msgstr "in"

#, fuzzy
#~ msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
#~ msgstr "ubusa in"

#, fuzzy
#~ msgid "cannot reload integer constant operand in `asm'"
#~ msgstr "Kongera Gutangiza Umubare wuzuye in"

#, fuzzy
#~ msgid "impossible register constraint in `asm'"
#~ msgstr "Kwiyandikisha Imbogamizi in"

#, fuzzy
#~ msgid "`&' constraint used with no register class"
#~ msgstr "`&'Imbogamizi Na: Oya Kwiyandikisha ishuri"

#, fuzzy
#~ msgid "unable to generate reloads for:"
#~ msgstr "Kuri kugirango"

#, fuzzy
#~ msgid "inconsistent operand constraints in an `asm'"
#~ msgstr "in"

#, fuzzy
#~ msgid "frame size too large for reliable stack checking"
#~ msgstr "Ikadiri Ingano Binini kugirango"

#, fuzzy
#~ msgid "try reducing the number of local variables"
#~ msgstr "i Umubare Bya Ibihinduka"

#, fuzzy
#~ msgid "can't find a register in class `%s' while reloading `asm'"
#~ msgstr "Gushaka a Kwiyandikisha in ishuri"

#, fuzzy
#~ msgid "unable to find a register to spill in class `%s'"
#~ msgstr "Kuri Gushaka a Kwiyandikisha Kuri in ishuri"

#, fuzzy
#~ msgid "this is the insn:"
#~ msgstr "iyi ni i"

#, fuzzy
#~ msgid "`asm' operand requires impossible reload"
#~ msgstr "`Kongera Gutangiza"

#, fuzzy
#~ msgid "could not find a spill register"
#~ msgstr "OYA Gushaka a Kwiyandikisha"

#, fuzzy
#~ msgid "`asm' operand constraint incompatible with operand size"
#~ msgstr "`Imbogamizi Na: Ingano"

#, fuzzy
#~ msgid "VOIDmode on an output"
#~ msgstr "ku Ibisohoka"

#, fuzzy
#~ msgid "output operand is constant in `asm'"
#~ msgstr "Ibisohoka ni in"

#, fuzzy
#~ msgid "insn does not satisfy its constraints:"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d"
#~ msgstr "Kugenzura... Bya Bya Na: Iheruka in ku"

#, fuzzy
#~ msgid "RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d"
#~ msgstr "Kugenzura... Ikitezwe: Ubwoko in ku"

#, fuzzy
#~ msgid "RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d"
#~ msgstr "Kugenzura... Ikitezwe: Ubwoko Cyangwa in ku"

#, fuzzy
#~ msgid "RTL check: expected code `%s', have `%s' in %s, at %s:%d"
#~ msgstr "Kugenzura... Ikitezwe: ITEGEKONGENGA in ku"

#, fuzzy
#~ msgid "RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d"
#~ msgstr "Kugenzura... Ikitezwe: ITEGEKONGENGA Cyangwa in ku"

#, fuzzy
#~ msgid "RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d"
#~ msgstr "Kugenzura... Bya Bya Na: Iheruka in ku"

#, fuzzy
#~ msgid "RTL flag check: %s used with unexpected rtx code `%s' in %s, at %s:%d"
#~ msgstr "Ibendera Kugenzura... Na: ITEGEKONGENGA in ku"

#, fuzzy
#~ msgid "jump to `%s' invalidly jumps into binding contour"
#~ msgstr "Simbuka Kuri Bifatanya Umuzenguruko"

#, fuzzy
#~ msgid "label `%s' used before containing binding contour"
#~ msgstr "Akarango Mbere Bifatanya Umuzenguruko"

#, fuzzy
#~ msgid "output operand constraint lacks `='"
#~ msgstr "Ibisohoka Imbogamizi"

#, fuzzy
#~ msgid "output constraint `%c' for operand %d is not at the beginning"
#~ msgstr "Ibisohoka Imbogamizi kugirango ni OYA ku i Itangiriro"

#, fuzzy
#~ msgid "operand constraint contains incorrectly positioned '+' or '='"
#~ msgstr "Imbogamizi Kirimo Cyangwa"

#, fuzzy
#~ msgid "`%%' constraint used with last operand"
#~ msgstr "`%%'Imbogamizi Na: Iheruka"

#, fuzzy
#~ msgid "matching constraint not valid in output operand"
#~ msgstr "Imbogamizi OYA Byemewe in Ibisohoka"

#, fuzzy
#~ msgid "input operand constraint contains `%c'"
#~ msgstr "Iyinjiza Imbogamizi Kirimo"

#, fuzzy
#~ msgid "matching constraint references invalid operand number"
#~ msgstr "Imbogamizi Indango Sibyo Umubare"

#, fuzzy
#~ msgid "invalid punctuation `%c' in constraint"
#~ msgstr "Sibyo in Imbogamizi"

#, fuzzy
#~ msgid "asm-specifier for variable `%s' conflicts with asm clobber list"
#~ msgstr "kugirango IMPINDURAGACIRO Na: Urutonde"

#, fuzzy
#~ msgid "unknown register name `%s' in `asm'"
#~ msgstr "Kitazwi Kwiyandikisha Izina: in"

#, fuzzy
#~ msgid "more than %d operands in `asm'"
#~ msgstr "Birenzeho in"

#, fuzzy
#~ msgid "output number %d not directly addressable"
#~ msgstr "Ibisohoka Umubare OYA"

#, fuzzy
#~ msgid "asm operand %d probably doesn't match constraints"
#~ msgstr "BIHUYE"

#, fuzzy
#~ msgid "asm clobber conflict with output operand"
#~ msgstr "Na: Ibisohoka"

#, fuzzy
#~ msgid "asm clobber conflict with input operand"
#~ msgstr "Na: Iyinjiza"

#, fuzzy
#~ msgid "too many alternatives in `asm'"
#~ msgstr "in"

#, fuzzy
#~ msgid "operand constraints for `asm' differ in number of alternatives"
#~ msgstr "kugirango in Umubare Bya"

#, fuzzy
#~ msgid "duplicate asm operand name '%s'"
#~ msgstr "Gusubiramo Izina:"

#, fuzzy
#~ msgid "missing close brace for named operand"
#~ msgstr "Ibuze Gufunga kugirango"

#, fuzzy
#~ msgid "undefined named operand '%s'"
#~ msgstr "kidasobanuye"

#, fuzzy
#~ msgid "unused variable `%s'"
#~ msgstr "Kidakoreshwa IMPINDURAGACIRO"

#, fuzzy
#~ msgid "enumeration value `%s' not handled in switch"
#~ msgstr "Agaciro OYA in Hindura"

#, fuzzy
#~ msgid "case value `%ld' not in enumerated type"
#~ msgstr "Agaciro OYA in Ubwoko"

#, fuzzy
#~ msgid "case value `%ld' not in enumerated type `%s'"
#~ msgstr "Agaciro OYA in Ubwoko"

#, fuzzy
#~ msgid "switch missing default case"
#~ msgstr "Hindura Ibuze Mburabuzi"

#, fuzzy
#~ msgid "type size can't be explicitly evaluated"
#~ msgstr "Ubwoko Ingano"

#, fuzzy
#~ msgid "variable-size type declared outside of any function"
#~ msgstr "IMPINDURAGACIRO Ingano Ubwoko Hanze Bya Umumaro"

#, fuzzy
#~ msgid "size of `%s' is %d bytes"
#~ msgstr "Ingano Bya ni Bayite"

#, fuzzy
#~ msgid "size of `%s' is larger than %d bytes"
#~ msgstr "Ingano Bya ni Kinini Bayite"

#, fuzzy
#~ msgid "packed attribute causes inefficient alignment for `%s'"
#~ msgstr "Ikiranga Itunganya kugirango"

#, fuzzy
#~ msgid "packed attribute is unnecessary for `%s'"
#~ msgstr "Ikiranga ni kugirango"

#, fuzzy
#~ msgid "padding struct to align `%s'"
#~ msgstr "Wuzuza: Kuri Gutondeka"

#, fuzzy
#~ msgid "padding struct size to alignment boundary"
#~ msgstr "Wuzuza: Ingano Kuri Itunganya"

#, fuzzy
#~ msgid "packed attribute causes inefficient alignment"
#~ msgstr "Ikiranga Itunganya"

#, fuzzy
#~ msgid "packed attribute is unnecessary"
#~ msgstr "Ikiranga ni"

#, fuzzy
#~ msgid "cannot timevar_pop '%s' when top of timevars stack is '%s'"
#~ msgstr "Ryari: Hejuru: Bya ni"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "Execution times (seconds)\n"
#~ msgstr "Times amasogonda"

# #-#-#-#-#  sc.pot (PACKAGE VERSION)  #-#-#-#-#
# sc/source\ui\src\autofmt.src:RID_SCDLG_AUTOFORMAT.STR_SUM.text
# #-#-#-#-#  sc.pot (PACKAGE VERSION)  #-#-#-#-#
# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_PIVOT_TOTAL.text
#, fuzzy
#~ msgid " TOTAL                 :"
#~ msgstr "Igiteranyo"

#, fuzzy
#~ msgid "time in %s: %ld.%06ld (%ld%%)\n"
#~ msgstr "Igihe in"

#, fuzzy
#~ msgid "collect: tweaking %s in %s\n"
#~ msgstr "in"

#, fuzzy
#~ msgid "ld returned %d exit status"
#~ msgstr "Gusohoka Imimerere"

#, fuzzy
#~ msgid "Generate debugging info in default format"
#~ msgstr "Ibisobanuro in Mburabuzi Imiterere"

#, fuzzy
#~ msgid "Generate debugging info in default extended format"
#~ msgstr "Ibisobanuro in Mburabuzi Byongerewe... Imiterere"

#, fuzzy
#~ msgid "Generate STABS format debug info"
#~ msgstr "Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate extended STABS format debug info"
#~ msgstr "Byongerewe... Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate DWARF-1 format debug info"
#~ msgstr "1. Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate extended DWARF-1 format debug info"
#~ msgstr "Byongerewe... 1. Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate DWARF-2 debug info"
#~ msgstr "2. Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate XCOFF format debug info"
#~ msgstr "Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate extended XCOFF format debug info"
#~ msgstr "Byongerewe... Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate COFF format debug info"
#~ msgstr "Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Generate VMS format debug info"
#~ msgstr "Imiterere Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "Perform DWARF2 duplicate elimination"
#~ msgstr "Gusubiramo"

#, fuzzy
#~ msgid "Do not store floats in registers"
#~ msgstr "OYA in"

#, fuzzy
#~ msgid "Consider all mem refs through pointers as volatile"
#~ msgstr "Byose mem Gihinguranya Nka"

#, fuzzy
#~ msgid "Consider all mem refs to global data to be volatile"
#~ msgstr "Byose mem Kuri Ibyatanzwe Kuri"

#, fuzzy
#~ msgid "Consider all mem refs to static data to be volatile"
#~ msgstr "Byose mem Kuri Ibyatanzwe Kuri"

#, fuzzy
#~ msgid "Defer popping functions args from stack until later"
#~ msgstr "Imimaro Bivuye"

#, fuzzy
#~ msgid "When possible do not generate stack frames"
#~ msgstr "OYA Amakadiri"

#, fuzzy
#~ msgid "Optimize sibling and tail recursive calls"
#~ msgstr "Na Amahamagara:"

#, fuzzy
#~ msgid "Perform superblock formation via tail duplication"
#~ msgstr "Biturutse"

#, fuzzy
#~ msgid "When running CSE, follow jumps to their targets"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Perform a number of minor, expensive optimizations"
#~ msgstr "a Umubare Bya"

#, fuzzy
#~ msgid "Perform jump threading optimizations"
#~ msgstr "Simbuka"

#, fuzzy
#~ msgid "Perform loop unrolling when iteration count is known"
#~ msgstr "Ryari: IBARA ni"

#, fuzzy
#~ msgid "Perform loop unrolling for all loops"
#~ msgstr "kugirango Byose"

#, fuzzy
#~ msgid "Generate prefetch instructions, if available, for arrays in loops"
#~ msgstr "Amabwiriza NIBA Bihari kugirango in"

#, fuzzy
#~ msgid "Force all loop invariant computations out of loops"
#~ msgstr "Byose Inyuma Bya"

#, fuzzy
#~ msgid "Strength reduce all loop general induction variables"
#~ msgstr "Byose Rusange Ibihinduka"

#, fuzzy
#~ msgid "Store strings in writable data section"
#~ msgstr "Ikurikiranyanyuguti in Ibyatanzwe Icyiciro"

#, fuzzy
#~ msgid "Copy memory operands into registers before using"
#~ msgstr "Ububiko Mbere ikoresha"

#, fuzzy
#~ msgid "Copy memory address constants into regs before using"
#~ msgstr "Ububiko Aderesi Mbere ikoresha"

#, fuzzy
#~ msgid "Allow function addresses to be held in registers"
#~ msgstr "Umumaro Amaderesi Kuri in"

#, fuzzy
#~ msgid "Integrate simple functions into their callers"
#~ msgstr "Byoroheje Imimaro"

#, fuzzy
#~ msgid "Generate code for funcs even if they are fully inlined"
#~ msgstr "ITEGEKONGENGA kugirango ATARIIGIHARWE NIBA"

#, fuzzy
#~ msgid "Pay attention to the 'inline' keyword"
#~ msgstr "Kuri i Ijambo- banze"

#, fuzzy
#~ msgid "Emit static const variables even if they are not used"
#~ msgstr "Ibihinduka ATARIIGIHARWE NIBA OYA"

#, fuzzy
#~ msgid "Check for syntax errors, then stop"
#~ msgstr "kugirango Amakosa Hanyuma Guhagarara"

#, fuzzy
#~ msgid "Mark data as shared rather than private"
#~ msgstr "Ibyatanzwe Nka By'umwihariko"

#, fuzzy
#~ msgid "Enable saving registers around function calls"
#~ msgstr "Mu kubika Umumaro Amahamagara:"

#, fuzzy
#~ msgid "Return 'short' aggregates in memory, not registers"
#~ msgstr "in Ububiko OYA"

#, fuzzy
#~ msgid "Return 'short' aggregates in registers"
#~ msgstr "in"

#, fuzzy
#~ msgid "Attempt to fill delay slots of branch instructions"
#~ msgstr "Kuri Kuzuza Gutinda Siloti Bya Amabwiriza"

#, fuzzy
#~ msgid "Perform the global common subexpression elimination"
#~ msgstr "i"

#, fuzzy
#~ msgid "Perform enhanced load motion during global subexpression elimination"
#~ msgstr "Ibirimo"

#, fuzzy
#~ msgid "Perform store motion after global subexpression elimination"
#~ msgstr "Nyuma"

#, fuzzy
#~ msgid "Perform the loop optimizations"
#~ msgstr "i"

#, fuzzy
#~ msgid "Perform cross-jumping optimization"
#~ msgstr "Kwambukiranya"

#, fuzzy
#~ msgid "Perform conversion of conditional jumps to branchless equivalents"
#~ msgstr "Ihindurangero Bya Kuri"

#, fuzzy
#~ msgid "Perform conversion of conditional jumps to conditional execution"
#~ msgstr "Ihindurangero Bya Kuri"

#, fuzzy
#~ msgid "Run CSE pass after loop optimizations"
#~ msgstr "Nyuma"

#, fuzzy
#~ msgid "Run the loop optimizer twice"
#~ msgstr "i"

#, fuzzy
#~ msgid "Delete useless null pointer checks"
#~ msgstr "NTAGIHARI Mweretsi"

#, fuzzy
#~ msgid "Reschedule instructions before register allocation"
#~ msgstr "Amabwiriza Mbere Kwiyandikisha"

#, fuzzy
#~ msgid "Reschedule instructions after register allocation"
#~ msgstr "Amabwiriza Nyuma Kwiyandikisha"

#, fuzzy
#~ msgid "Enable scheduling across basic blocks"
#~ msgstr "Kwambukiranya BASIC"

#, fuzzy
#~ msgid "Allow speculative motion of non-loads"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "Allow speculative motion of some loads"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "Allow speculative motion of more loads"
#~ msgstr "Bya Birenzeho"

#, fuzzy
#~ msgid "Replace add,compare,branch with branch on count reg"
#~ msgstr "Kongeramo Kugereranya# Na: ku IBARA"

#, fuzzy
#~ msgid "Generate position independent code, if possible"
#~ msgstr "Ibirindiro ITEGEKONGENGA NIBA"

#, fuzzy
#~ msgid "Enable exception handling"
#~ msgstr "Irengayobora(-)"

#, fuzzy
#~ msgid "Just generate unwind tables for exception handling"
#~ msgstr "Imbonerahamwe kugirango Irengayobora(-)"

#, fuzzy
#~ msgid "Generate unwind tables exact at each instruction boundary"
#~ msgstr "Imbonerahamwe NYACYO ku"

#, fuzzy
#~ msgid "Support synchronous non-call exceptions"
#~ msgstr "Amarengayobora"

#, fuzzy
#~ msgid "Insert arc based program profiling code"
#~ msgstr "Agaheto Porogaramu ITEGEKONGENGA"

#, fuzzy
#~ msgid "Create data files needed by gcov"
#~ msgstr "Ibyatanzwe Idosiye ku"

#, fuzzy
#~ msgid "Use profiling information for branch probabilities"
#~ msgstr "Ibisobanuro kugirango"

#, fuzzy
#~ msgid "Enable basic program profiling code"
#~ msgstr "BASIC Porogaramu ITEGEKONGENGA"

#, fuzzy
#~ msgid "Reorder basic blocks to improve code placement"
#~ msgstr "BASIC Kuri ITEGEKONGENGA Ishyira mu mwanya"

#, fuzzy
#~ msgid "Reorder functions to improve code placement"
#~ msgstr "Imimaro Kuri ITEGEKONGENGA Ishyira mu mwanya"

#, fuzzy
#~ msgid "Do the register renaming optimization pass"
#~ msgstr "i Kwiyandikisha"

#, fuzzy
#~ msgid "Do the register copy-propagation optimization pass"
#~ msgstr "i Kwiyandikisha Gukoporora"

#, fuzzy
#~ msgid "Do not put uninitialized globals in the common section"
#~ msgstr "OYA Gushyira Itatangijwe in i Icyiciro"

#, fuzzy
#~ msgid "Do not generate .size directives"
#~ msgstr "OYA Ingano"

#, fuzzy
#~ msgid "place each function into its own section"
#~ msgstr "Umumaro Icyiciro"

#, fuzzy
#~ msgid "place data items into their own section"
#~ msgstr "Ibyatanzwe Icyiciro"

#, fuzzy
#~ msgid "Add extra commentary to assembler output"
#~ msgstr "Birenga Kuri Ibisohoka"

#, fuzzy
#~ msgid "Output GNU ld formatted global initializers"
#~ msgstr "Byahanaguwe"

#, fuzzy
#~ msgid "Enables a register move optimization"
#~ msgstr "a Kwiyandikisha Kwimura"

#, fuzzy
#~ msgid "Do the full regmove optimization pass"
#~ msgstr "i"

#, fuzzy
#~ msgid "Pack structure members together without holes"
#~ msgstr "Imiterere"

#, fuzzy
#~ msgid "Insert stack checking code into the program"
#~ msgstr "ITEGEKONGENGA i Porogaramu"

#, fuzzy
#~ msgid "Specify that arguments may alias each other & globals"
#~ msgstr "ingingo Gicurasi Irihimbano Ikindi"

#, fuzzy
#~ msgid "Assume arguments may alias globals but not each other"
#~ msgstr "ingingo Gicurasi Irihimbano OYA Ikindi"

#, fuzzy
#~ msgid "Assume arguments do not alias each other or globals"
#~ msgstr "ingingo OYA Irihimbano Ikindi Cyangwa"

#, fuzzy
#~ msgid "Assume strict aliasing rules apply"
#~ msgstr "Gukurikiza"

#, fuzzy
#~ msgid "Align the start of loops"
#~ msgstr "i Gutangira Bya"

#, fuzzy
#~ msgid "Align labels which are only reached by jumping"
#~ msgstr "Uturango... ku"

#, fuzzy
#~ msgid "Align all labels"
#~ msgstr "Byose Uturango..."

#, fuzzy
#~ msgid "Align the start of functions"
#~ msgstr "i Gutangira Bya Imimaro"

#, fuzzy
#~ msgid "Attempt to merge identical constants across compilation units"
#~ msgstr "Kuri Gukomatanya birasa Kwambukiranya"

#, fuzzy
#~ msgid "Attempt to merge identical constants and constant variables"
#~ msgstr "Kuri Gukomatanya birasa Na Ibihinduka"

#, fuzzy
#~ msgid "Suppress output of instruction numbers and line number notes in debugging dumps"
#~ msgstr "Ibisohoka Bya Imibare Na Umurongo Umubare Ibisobanuro in"

#, fuzzy
#~ msgid "Instrument function entry/exit with profiling calls"
#~ msgstr "Umumaro Icyinjijwe Gusohoka Na: Amahamagara:"

#, fuzzy
#~ msgid "Put zero initialized data in the bss section"
#~ msgstr "Zeru Ibyatanzwe in i Icyiciro"

#, fuzzy
#~ msgid "Enable aggressive SSA dead code elimination"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "External symbols have a leading underscore"
#~ msgstr "Ibimenyetso a Nyobora"

#, fuzzy
#~ msgid "Enables an rtl peephole pass run before sched2"
#~ msgstr "Gukoresha Mbere"

#, fuzzy
#~ msgid "Assume no NaNs or +-Infs are generated"
#~ msgstr "Oya Cyangwa"

#, fuzzy
#~ msgid "Enables guessing of branch probabilities"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "Set errno after built-in math functions"
#~ msgstr "Nyuma in Imibare Imimaro"

#, fuzzy
#~ msgid "Floating-point operations can trap"
#~ msgstr "Akadomo Ibikorwa:"

#, fuzzy
#~ msgid "Allow math optimizations that may violate IEEE or ANSI standards"
#~ msgstr "Imibare Gicurasi Cyangwa"

#, fuzzy
#~ msgid "Disable optimizations observable by IEEE signaling NaNs"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Generate code to check bounds before indexing arrays"
#~ msgstr "ITEGEKONGENGA Kuri Kugenzura... Mbere gushyiraho umugereka"

#, fuzzy
#~ msgid "Convert floating point constant to single precision constant"
#~ msgstr "Bihindagurika Akadomo Kuri UMWE"

#, fuzzy
#~ msgid "Report time taken by each compiler pass at end of run"
#~ msgstr "Igihe ku ku Impera Bya Gukoresha"

#, fuzzy
#~ msgid "Report on permanent memory allocation at end of run"
#~ msgstr "ku Ububiko ku Impera Bya Gukoresha"

#, fuzzy
#~ msgid "Trap for signed overflow in addition / subtraction / multiplication"
#~ msgstr "kugirango Byarenze urugero in Guteranya+ Gukuramo Gukuba(*)"

#, fuzzy
#~ msgid "Use graph coloring register allocation."
#~ msgstr "Kwiyandikisha"

#, fuzzy
#~ msgid "Compile just for ISO C90"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Determine language standard"
#~ msgstr "Ururimi Bisanzwe"

#, fuzzy
#~ msgid "Make bit-fields by unsigned by default"
#~ msgstr "Imyanya ku Bitashizweho umukono ku Mburabuzi"

#, fuzzy
#~ msgid "Make 'char' be signed by default"
#~ msgstr "ku Mburabuzi"

#, fuzzy
#~ msgid "Make 'char' be unsigned by default"
#~ msgstr "Bitashizweho umukono ku Mburabuzi"

#, fuzzy
#~ msgid "Do not recognize the 'asm' keyword"
#~ msgstr "OYA i Ijambo- banze"

#, fuzzy
#~ msgid "Do not recognize any built in functions"
#~ msgstr "OYA in Imimaro"

#, fuzzy
#~ msgid "Assume normal C execution environment"
#~ msgstr "Bisanzwe C"

#, fuzzy
#~ msgid "Assume that standard libraries & main might not exist"
#~ msgstr "Bisanzwe Amasomero OYA"

#, fuzzy
#~ msgid "Allow different types as args of ? operator"
#~ msgstr "Nka Bya Mukoresha"

#, fuzzy
#~ msgid "Allow the use of $ inside identifiers"
#~ msgstr "i Gukoresha Bya Mo Imbere"

#, fuzzy
#~ msgid "Use the same size for double as for float"
#~ msgstr "i Ingano kugirango MAHARAKUBIRI Nka kugirango Kureremba"

#, fuzzy
#~ msgid "Use the smallest fitting integer to hold enums"
#~ msgstr "i Gitoya Umubare wuzuye Kuri"

#, fuzzy
#~ msgid "Override the underlying type for wchar_t to `unsigned short'"
#~ msgstr "i Ubwoko kugirango Kuri Bitashizweho umukono"

#, fuzzy
#~ msgid "Enable most warning messages"
#~ msgstr "Iburira Ubutumwa"

#, fuzzy
#~ msgid "Warn about casting functions to incompatible types"
#~ msgstr "Ibyerekeye Imimaro Kuri"

#, fuzzy
#~ msgid "Warn about functions which might be candidates for format attributes"
#~ msgstr "Ibyerekeye Imimaro kugirango Imiterere Ibiranga"

#, fuzzy
#~ msgid "Warn about casts which discard qualifiers"
#~ msgstr "Ibyerekeye Kwanga"

#, fuzzy
#~ msgid "Warn about subscripts whose type is 'char'"
#~ msgstr "Ibyerekeye bya Ubwoko ni"

#, fuzzy
#~ msgid "Warn if nested comments are detected"
#~ msgstr "NIBA Ibisobanuro"

#, fuzzy
#~ msgid "Warn about possibly confusing type conversions"
#~ msgstr "Ibyerekeye Ubwoko"

#, fuzzy
#~ msgid "Do not warn about compile-time integer division by zero"
#~ msgstr "OYA Ibyerekeye Gukusanya Igihe Umubare wuzuye ku Zeru"

#, fuzzy
#~ msgid "Warn about testing equality of floating point numbers"
#~ msgstr "Ibyerekeye Bya Bihindagurika Akadomo Imibare"

#, fuzzy
#~ msgid "Warn about printf/scanf/strftime/strfmon format anomalies"
#~ msgstr "Ibyerekeye Imiterere"

#, fuzzy
#~ msgid "Don't warn about too many arguments to format functions"
#~ msgstr "Ibyerekeye ingingo Kuri Imiterere Imimaro"

#, fuzzy
#~ msgid "Warn about non-string-literal format strings"
#~ msgstr "Ibyerekeye Ikurikiranyanyuguti Imiterere Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "Warn about possible security problems with format functions"
#~ msgstr "Ibyerekeye Umutekano Na: Imiterere Imimaro"

#, fuzzy
#~ msgid "Don't warn about strftime formats yielding 2 digit years"
#~ msgstr "Ibyerekeye Imiterere 2. IMYAKA"

#, fuzzy
#~ msgid "Warn about implicit function declarations"
#~ msgstr "Ibyerekeye Umumaro"

#, fuzzy
#~ msgid "Warn when a declaration does not specify a type"
#~ msgstr "Ryari: a OYA a Ubwoko"

#, fuzzy
#~ msgid "Warn about the use of the #import directive"
#~ msgstr "Ibyerekeye i Gukoresha Bya i Kuzana"

#, fuzzy
#~ msgid "Do not warn about using 'long long' when -pedantic"
#~ msgstr "OYA Ibyerekeye ikoresha Ryari:"

#, fuzzy
#~ msgid "Warn about suspicious declarations of main"
#~ msgstr "Ibyerekeye Bya"

#, fuzzy
#~ msgid "Warn about possibly missing braces around initializers"
#~ msgstr "Ibyerekeye Ibuze Ingirwadusodeko"

#, fuzzy
#~ msgid "Warn about global funcs without previous declarations"
#~ msgstr "Ibyerekeye Ibanjirije"

#, fuzzy
#~ msgid "Warn about global funcs without prototypes"
#~ msgstr "Ibyerekeye"

#, fuzzy
#~ msgid "Warn about use of multicharacter literals"
#~ msgstr "Ibyerekeye Gukoresha Bya"

#, fuzzy
#~ msgid "Warn about externs not at file scope level"
#~ msgstr "Ibyerekeye OYA ku IDOSIYE Ingano: urwego"

#, fuzzy
#~ msgid "Warn about possible missing parentheses"
#~ msgstr "Ibyerekeye Ibuze"

#, fuzzy
#~ msgid "Warn about function pointer arithmetic"
#~ msgstr "Ibyerekeye Umumaro Mweretsi"

#, fuzzy
#~ msgid "Warn about multiple declarations of the same object"
#~ msgstr "Ibyerekeye Igikubo Bya i Igikoresho"

#, fuzzy
#~ msgid "Warn whenever a function's return-type defaults to int"
#~ msgstr "a Garuka Ubwoko Kuri INT"

#, fuzzy
#~ msgid "Warn about possible violations of sequence point rules"
#~ msgstr "Ibyerekeye Bya Akadomo"

#, fuzzy
#~ msgid "Warn about signed/unsigned comparisons"
#~ msgstr "Ibyerekeye Bitashizweho umukono"

#, fuzzy
#~ msgid "Warn about non-prototyped function decls"
#~ msgstr "Ibyerekeye Umumaro"

#, fuzzy
#~ msgid "Warn about constructs whose meanings change in ISO C"
#~ msgstr "Ibyerekeye bya Guhindura>> in C"

#, fuzzy
#~ msgid "Warn when trigraphs are encountered"
#~ msgstr "Ryari:"

#, fuzzy
#~ msgid "Warn about unrecognized pragmas"
#~ msgstr "Ibyerekeye"

#, fuzzy
#~ msgid "Mark strings as 'const char *'"
#~ msgstr "Ikurikiranyanyuguti Nka INYUGUTI"

#, fuzzy
#~ msgid "Warn when a function is unused"
#~ msgstr "Ryari: a Umumaro ni Kidakoreshwa"

#, fuzzy
#~ msgid "Warn when a label is unused"
#~ msgstr "Ryari: a Akarango ni Kidakoreshwa"

#, fuzzy
#~ msgid "Warn when a function parameter is unused"
#~ msgstr "Ryari: a Umumaro ni Kidakoreshwa"

#, fuzzy
#~ msgid "Warn when a variable is unused"
#~ msgstr "Ryari: a IMPINDURAGACIRO ni Kidakoreshwa"

#, fuzzy
#~ msgid "Warn when an expression value is unused"
#~ msgstr "Ryari: imvugo Agaciro ni Kidakoreshwa"

#, fuzzy
#~ msgid "Do not suppress warnings from system headers"
#~ msgstr "OYA Iburira Bivuye Sisitemu Imitwe"

#, fuzzy
#~ msgid "Treat all warnings as errors"
#~ msgstr "Byose Iburira Nka Amakosa"

#, fuzzy
#~ msgid "Warn when one local variable shadows another"
#~ msgstr "Ryari: IMPINDURAGACIRO"

#, fuzzy
#~ msgid "Warn about enumerated switches, with no default, missing a case"
#~ msgstr "Ibyerekeye Na: Oya Mburabuzi Ibuze a"

#, fuzzy
#~ msgid "Warn about enumerated switches missing a default case"
#~ msgstr "Ibyerekeye Ibuze a Mburabuzi"

#, fuzzy
#~ msgid "Warn about all enumerated switches missing a specific case"
#~ msgstr "Ibyerekeye Byose Ibuze a"

#, fuzzy
#~ msgid "Warn about returning structures, unions or arrays"
#~ msgstr "Ibyerekeye Cyangwa"

#, fuzzy
#~ msgid "Warn about pointer casts which increase alignment"
#~ msgstr "Ibyerekeye Mweretsi Itunganya"

#, fuzzy
#~ msgid "Warn about code that will never be executed"
#~ msgstr "Ibyerekeye ITEGEKONGENGA Nta narimwe"

#, fuzzy
#~ msgid "Warn about uninitialized automatic variables"
#~ msgstr "Ibyerekeye Itatangijwe Byikoresha Ibihinduka"

#, fuzzy
#~ msgid "Warn when an inlined function cannot be inlined"
#~ msgstr "Ryari: Umumaro"

#, fuzzy
#~ msgid "Warn when the packed attribute has no effect on struct layout"
#~ msgstr "Ryari: i Ikiranga Oya INGARUKA ku Imigaragarire"

#, fuzzy
#~ msgid "Warn when padding is required to align struct members"
#~ msgstr "Ryari: Wuzuza: ni Bya ngombwa Kuri Gutondeka"

#, fuzzy
#~ msgid "Warn when an optimization pass is disabled"
#~ msgstr "Ryari: ni Yahagaritswe"

#, fuzzy
#~ msgid "Warn about uses of __attribute__((deprecated)) declarations"
#~ msgstr "Ibyerekeye Bya Ikiranga Bitemewe."

#, fuzzy
#~ msgid "Warn about functions which might be candidates for attribute noreturn"
#~ msgstr "Ibyerekeye Imimaro kugirango Ikiranga"

#, fuzzy
#~ msgid "Warn about code which might break the strict aliasing rules"
#~ msgstr "Ibyerekeye ITEGEKONGENGA itandukanya i"

#, fuzzy
#~ msgid "invalid option `%s'"
#~ msgstr "Sibyo Ihitamo"

#, fuzzy
#~ msgid "`%s' declared `static' but never defined"
#~ msgstr "`%s'Nta narimwe"

#, fuzzy
#~ msgid "`%s' defined but not used"
#~ msgstr "`%s'OYA"

#, fuzzy
#~ msgid "invalid register name `%s' for register variable"
#~ msgstr "Sibyo Kwiyandikisha Izina: kugirango Kwiyandikisha IMPINDURAGACIRO"

#, fuzzy
#~ msgid "  -ffixed-<register>      Mark <register> as being unavailable to the compiler\n"
#~ msgstr "-Kwiyandikisha Kwiyandikisha Nka Kuri i"

#, fuzzy
#~ msgid "  -fcall-used-<register>  Mark <register> as being corrupted by function calls\n"
#~ msgstr "-Kwiyandikisha Kwiyandikisha Nka ku Umumaro"

#, fuzzy
#~ msgid "  -fcall-saved-<register> Mark <register> as being preserved across functions\n"
#~ msgstr "-Kwiyandikisha Kwiyandikisha Nka Kwambukiranya"

#, fuzzy
#~ msgid "  -finline-limit=<number> Limits the size of inlined functions to <number>\n"
#~ msgstr "-Umubare i Ingano Bya Imimaro Kuri Umubare"

#, fuzzy
#~ msgid "  -fmessage-length=<number> Limits diagnostics messages lengths to <number> characters per line.  0 suppresses line-wrapping\n"
#~ msgstr "-Uburebure Umubare Ubutumwa Kuri Umubare Inyuguti Umurongo 0 Umurongo"

#, fuzzy
#~ msgid "  -fdiagnostics-show-location=[once | every-line] Indicates how often source location information should be emitted, as prefix, at the beginning of diagnostics when line-wrapping\n"
#~ msgstr "-Garagaza Ahantu Rimwe buri Umurongo Inkomoko Ahantu Ibisobanuro Nka Imbanziriza ku i Itangiriro Bya Ryari: Umurongo"

#, fuzzy
#~ msgid "  -ftls-model=[global-dynamic | local-dynamic | initial-exec | local-exec] Indicates the default thread-local storage code generation model\n"
#~ msgstr "-Urugero i Mburabuzi Urudodo ITEGEKONGENGA"

#, fuzzy
#~ msgid "  -O[number]              Set optimization level to [number]\n"
#~ msgstr "-Umubare urwego Kuri Umubare"

#, fuzzy
#~ msgid "  -Os                     Optimize for space rather than speed\n"
#~ msgstr "-kugirango Umwanya"

#, fuzzy
#~ msgid "  -pedantic               Issue warnings needed by strict compliance to ISO C\n"
#~ msgstr "-Iburira ku Kuri"

#, fuzzy
#~ msgid "  -pedantic-errors        Like -pedantic except that errors are produced\n"
#~ msgstr "-Amakosa Amakosa"

#, fuzzy
#~ msgid "  -w                      Suppress warnings\n"
#~ msgstr "-W"

#, fuzzy
#~ msgid "  -W                      Enable extra warnings\n"
#~ msgstr "-Birenga"

#, fuzzy
#~ msgid "  -Wunused                Enable unused warnings\n"
#~ msgstr "-Kidakoreshwa"

#, fuzzy
#~ msgid "  -Wlarger-than-<number>  Warn if an object is larger than <number> bytes\n"
#~ msgstr "-Umubare NIBA Igikoresho ni Kinini Umubare"

#, fuzzy
#~ msgid "  -p                      Enable function profiling\n"
#~ msgstr "-P Umumaro"

#, fuzzy
#~ msgid "  -o <file>               Place output into <file> \n"
#~ msgstr "-o IDOSIYE Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid ""
#~ "  -G <number>             Put global and static data smaller than <number>\n"
#~ "                          bytes into a special section (on some targets)\n"
#~ msgstr "-Umubare Na Ibyatanzwe Gitoya Umubare Bayite a Bidasanzwe Icyiciro ku"

#, fuzzy
#~ msgid "  -aux-info <file>        Emit declaration info into <file>\n"
#~ msgstr "-Ibisobanuro IDOSIYE Ibisobanuro IDOSIYE"

#, fuzzy
#~ msgid "  -quiet                  Do not display functions compiled or elapsed time\n"
#~ msgstr "-OYA Kugaragaza Imimaro Cyangwa"

#, fuzzy
#~ msgid "  -version                Display the compiler's version\n"
#~ msgstr "-Verisiyo i"

#, fuzzy
#~ msgid "  -d[letters]             Enable dumps from specific passes of the compiler\n"
#~ msgstr "-D Bivuye Bya i"

#, fuzzy
#~ msgid "  -dumpbase <file>        Base name to be used for dumps from specific passes\n"
#~ msgstr "-IDOSIYE Base Izina: Kuri kugirango Bivuye"

#, fuzzy
#~ msgid "  -fsched-verbose=<number> Set the verbosity level of the scheduler\n"
#~ msgstr "-Umubare i urwego Bya i"

#, fuzzy
#~ msgid "  --help                  Display this information\n"
#~ msgstr "--Ifashayobora iyi"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "Language specific options:\n"
#~ msgstr "Amahitamo"

#, fuzzy
#~ msgid "  %-23.23s [undocumented]\n"
#~ msgstr ""
#~ "%-23.Project- Id- Version: basctl\n"
#~ "POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
#~ "PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
#~ "Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
#~ "Content- Type: text/ plain; charset= UTF- 8\n"
#~ "Content- Transfer- Encoding: 8bit\n"
#~ "X- Generator: KBabel 1. 0\n"
#~ "."

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "There are undocumented %s specific options as well.\n"
#~ msgstr "Amahitamo Nka"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ " Options for %s:\n"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "Target specific options:\n"
#~ msgstr "Amahitamo"

#, fuzzy
#~ msgid "  -m%-23.23s [undocumented]\n"
#~ msgstr "-M."

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "There are undocumented target specific options as well.\n"
#~ msgstr "Intego Amahitamo Nka"

#, fuzzy
#~ msgid "  They exist, but they are not documented.\n"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "unrecognized gcc debugging option: %c"
#~ msgstr "Ihitamo"

#, fuzzy
#~ msgid "`%s': unknown tls-model option"
#~ msgstr "`%s':Kitazwi TLS Urugero Ihitamo"

#, fuzzy
#~ msgid "unrecognized register name `%s'"
#~ msgstr "Kwiyandikisha Izina:"

#, fuzzy
#~ msgid "unrecognized option `%s'"
#~ msgstr "Ihitamo"

#, fuzzy
#~ msgid "-Wid-clash-LEN is no longer supported"
#~ msgstr "-ni Oya"

#, fuzzy
#~ msgid "use -gdwarf -g%d for DWARF v1, level %d"
#~ msgstr "Gukoresha g kugirango urwego"

#, fuzzy
#~ msgid "use -gdwarf-2   for DWARF v2"
#~ msgstr "Gukoresha 2. kugirango"

#, fuzzy
#~ msgid "ignoring option `%s' due to invalid debug level specification"
#~ msgstr "Ihitamo Kuri Sibyo Kosora amakosa urwego"

#, fuzzy
#~ msgid "`%s': unknown or unsupported -g option"
#~ msgstr "`%s':Kitazwi Cyangwa g Ihitamo"

#, fuzzy
#~ msgid "`%s' ignored, conflicts with `-g%s'"
#~ msgstr "`%s'Na: g"

#, fuzzy
#~ msgid "-param option missing argument"
#~ msgstr "-Ihitamo Ibuze"

#, fuzzy
#~ msgid "invalid --param option: %s"
#~ msgstr "Sibyo Ihitamo"

#, fuzzy
#~ msgid "invalid parameter value `%s'"
#~ msgstr "Sibyo Agaciro"

#, fuzzy
#~ msgid ""
#~ "%s%s%s version %s (%s)\n"
#~ "%s\tcompiled by GNU C version %s.\n"
#~ "%s%s%s version %s (%s) compiled by CC.\n"
#~ msgstr "%s%s%sVerisiyo ku C Verisiyo Verisiyo ku"

#, fuzzy
#~ msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"
#~ msgstr "%s%sGGCGITO Kwagura GITO"

#, fuzzy
#~ msgid "options passed: "
#~ msgstr "Amahitamo"

#, fuzzy
#~ msgid "options enabled: "
#~ msgstr "Amahitamo Bikora"

#, fuzzy
#~ msgid "can't open %s for writing"
#~ msgstr "Gufungura kugirango"

#, fuzzy
#~ msgid "ignoring command line option '%s'"
#~ msgstr "Komandi: Umurongo Ihitamo"

#, fuzzy
#~ msgid "(it is valid for %s but not the selected language)"
#~ msgstr "(ni Byemewe kugirango OYA i Byahiswemo Ururimi"

#, fuzzy
#~ msgid "-Wuninitialized is not supported without -O"
#~ msgstr "-ni OYA"

#, fuzzy
#~ msgid "instruction scheduling not supported on this target machine"
#~ msgstr "OYA ku iyi Intego"

#, fuzzy
#~ msgid "this target machine does not have delayed branches"
#~ msgstr "iyi Intego OYA"

#, fuzzy
#~ msgid "-f%sleading-underscore not supported on this target machine"
#~ msgstr "-F OYA ku iyi Intego"

#, fuzzy
#~ msgid "-ffunction-sections not supported for this target"
#~ msgstr "-Ibyatoranyijwe OYA kugirango iyi Intego"

#, fuzzy
#~ msgid "-fdata-sections not supported for this target"
#~ msgstr "-Ibyatoranyijwe OYA kugirango iyi Intego"

#, fuzzy
#~ msgid "-ffunction-sections disabled; it makes profiling impossible"
#~ msgstr "-Ibyatoranyijwe Yahagaritswe"

#, fuzzy
#~ msgid "-fprefetch-loop-arrays not supported for this target"
#~ msgstr "-OYA kugirango iyi Intego"

#, fuzzy
#~ msgid "-fprefetch-loop-arrays not supported for this target (try -march switches)"
#~ msgstr "-OYA kugirango iyi Intego Werurwe"

#, fuzzy
#~ msgid "-fprefetch-loop-arrays is not supported with -Os"
#~ msgstr "-ni OYA Na:"

#, fuzzy
#~ msgid "-ffunction-sections may affect debugging on some targets"
#~ msgstr "-Ibyatoranyijwe Gicurasi ku"

#, fuzzy
#~ msgid "error writing to %s"
#~ msgstr "Ikosa Kuri"

#, fuzzy
#~ msgid "error closing %s"
#~ msgstr "Ikosa"

#, fuzzy
#~ msgid "could not open dump file `%s'"
#~ msgstr "OYA Gufungura IDOSIYE"

#, fuzzy
#~ msgid "ignoring unknown option `%.*s' in `-f%s'"
#~ msgstr "Kitazwi Ihitamo in F"

#, fuzzy
#~ msgid "arrays of functions are not meaningful"
#~ msgstr "Bya Imimaro OYA"

#, fuzzy
#~ msgid "function return type cannot be function"
#~ msgstr "Umumaro Garuka Ubwoko Umumaro"

#, fuzzy
#~ msgid "invalid initializer for bit string"
#~ msgstr "Sibyo kugirango Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "tree check: expected %s, have %s in %s, at %s:%d"
#~ msgstr "Kugenzura... Ikitezwe: in ku"

#, fuzzy
#~ msgid "tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d"
#~ msgstr "Kugenzura... Ikitezwe: ishuri in ku"

#, fuzzy
#~ msgid "tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d"
#~ msgstr "Kugenzura... birabonetse Bya Na: in ku"

#, fuzzy
#~ msgid "%s causes a section type conflict"
#~ msgstr "%sa Icyiciro Ubwoko"

#, fuzzy
#~ msgid "register name not specified for `%s'"
#~ msgstr "Kwiyandikisha Izina: OYA kugirango"

#, fuzzy
#~ msgid "invalid register name for `%s'"
#~ msgstr "Sibyo Kwiyandikisha Izina: kugirango"

#, fuzzy
#~ msgid "data type of `%s' isn't suitable for a register"
#~ msgstr "Ibyatanzwe Ubwoko Bya si kugirango a Kwiyandikisha"

#, fuzzy
#~ msgid "register specified for `%s' isn't suitable for data type"
#~ msgstr "Kwiyandikisha kugirango si kugirango Ibyatanzwe Ubwoko"

#, fuzzy
#~ msgid "global register variable has initial value"
#~ msgstr "Kwiyandikisha IMPINDURAGACIRO Agaciro"

#, fuzzy
#~ msgid "volatile register variables don't work as you might wish"
#~ msgstr "Kwiyandikisha Ibihinduka Akazi Nka"

#, fuzzy
#~ msgid "register name given for non-register variable `%s'"
#~ msgstr "Kwiyandikisha Izina: kugirango Kwiyandikisha IMPINDURAGACIRO"

#, fuzzy
#~ msgid "alignment of `%s' is greater than maximum object file alignment. Using %d"
#~ msgstr "Itunganya Bya ni Biruta Kinini Igikoresho IDOSIYE Itunganya"

#, fuzzy
#~ msgid "thread-local COMMON data not implemented"
#~ msgstr "Urudodo Ibyatanzwe OYA"

#, fuzzy
#~ msgid "requested alignment for %s is greater than implemented alignment of %d"
#~ msgstr "Itunganya kugirango ni Biruta Itunganya Bya"

#, fuzzy
#~ msgid "initializer for integer value is too complicated"
#~ msgstr "kugirango Umubare wuzuye Agaciro ni"

#, fuzzy
#~ msgid "initializer for floating value is not a floating constant"
#~ msgstr "kugirango Bihindagurika Agaciro ni OYA a Bihindagurika"

#, fuzzy
#~ msgid "unknown set constructor type"
#~ msgstr "Kitazwi Gushyiraho Ubwoko"

#, fuzzy
#~ msgid "invalid initial value for member `%s'"
#~ msgstr "Sibyo Agaciro kugirango"

#, fuzzy
#~ msgid "weak declaration of `%s' must precede definition"
#~ msgstr "Bya Insobanuro"

#, fuzzy
#~ msgid "weak declaration of `%s' after first use results in unspecified behavior"
#~ msgstr "Bya Nyuma Itangira Gukoresha Ibisubizo ku in imyitwarire"

#, fuzzy
#~ msgid "weak declaration of `%s' must be public"
#~ msgstr "Bya Rusange"

#, fuzzy
#~ msgid "weak declaration of `%s' not supported"
#~ msgstr "Bya OYA"

#, fuzzy
#~ msgid "only weak aliases are supported in this configuration"
#~ msgstr "Irihimbano in iyi Iboneza"

#, fuzzy
#~ msgid "alias definitions not supported in this configuration; ignored"
#~ msgstr "Irihimbano OYA in iyi Iboneza"

#, fuzzy
#~ msgid "visibility attribute not supported in this configuration; ignored"
#~ msgstr "Ukugaragara Ikiranga OYA in iyi Iboneza"

#, fuzzy
#~ msgid "virtual array %s[%lu]: element %lu out of bounds in %s, at %s:%d"
#~ msgstr "Kitaboneka Imbonerahamwe Ikigize: Inyuma Bya in ku"

#, fuzzy
#~ msgid "no sclass for %s stab (0x%x)\n"
#~ msgstr "Oya kugirango"

#, fuzzy
#~ msgid "#`%s' not supported by %s#"
#~ msgstr "#`%s'OYA ku"

#, fuzzy
#~ msgid "The maximum number of instructions in a single function eligible for inlining"
#~ msgstr "Kinini Umubare Bya Amabwiriza in a UMWE Umumaro kugirango"

#, fuzzy
#~ msgid "The maximum number of instructions when automatically inlining"
#~ msgstr "Kinini Umubare Bya Amabwiriza Ryari: ku buryo bwikora"

#, fuzzy
#~ msgid "The maximum number of instructions by repeated inlining before gcc starts to throttle inlining"
#~ msgstr "Kinini Umubare Bya Amabwiriza ku byasubiyemo Mbere Kuri"

#, fuzzy
#~ msgid "The slope of the linear function throttling inlining after the recursive inlining limit has been reached is given by the negative reciprocal value of this parameter"
#~ msgstr "IMANURA Bya i By'umurongo Umumaro Nyuma i ni ku i Agaciro Bya iyi"

#, fuzzy
#~ msgid "The number of instructions in a single functions still eligible to inlining after a lot recursive inlining"
#~ msgstr "Umubare Bya Amabwiriza in a UMWE Imimaro Kuri Nyuma a"

#, fuzzy
#~ msgid "The maximum number of instructions for the RTL inliner"
#~ msgstr "Kinini Umubare Bya Amabwiriza kugirango i"

#, fuzzy
#~ msgid "The maximum number of instructions to consider to fill a delay slot"
#~ msgstr "Kinini Umubare Bya Amabwiriza Kuri Kuri Kuzuza a Gutinda"

#, fuzzy
#~ msgid "The maximum number of instructions to consider to find accurate live register information"
#~ msgstr "Kinini Umubare Bya Amabwiriza Kuri Kuri Gushaka Kwiyandikisha Ibisobanuro"

#, fuzzy
#~ msgid "The maximum length of scheduling's pending operations list"
#~ msgstr "Kinini Uburebure Bya Ibikorwa: Urutonde"

#, fuzzy
#~ msgid "The maximum amount of memory to be allocated by GCSE"
#~ msgstr "Kinini Igiteranyo Bya Ububiko Kuri ku"

#, fuzzy
#~ msgid "The maximum number of passes to make when doing GCSE"
#~ msgstr "Kinini Umubare Bya Kuri Ubwoko Ryari:"

#, fuzzy
#~ msgid "The maximum number of instructions to consider to unroll in a loop"
#~ msgstr "Kinini Umubare Bya Amabwiriza Kuri Kuri in a"

#, fuzzy
#~ msgid "Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot"
#~ msgstr "Imigabane Bya i IBARA Bya Bya BASIC Funga in Porogaramu BASIC Funga Kuri Kuri"

#, fuzzy
#~ msgid "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot"
#~ msgstr "Imigabane Bya i Ubwisubire Bya Bya BASIC Funga in Umumaro BASIC Funga Kuri Kuri"

#, fuzzy
#~ msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available"
#~ msgstr "Ijanisha Bya Umumaro ku Ubwisubire ku Ryari: Ibijyana ni Bihari"

#, fuzzy
#~ msgid "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available"
#~ msgstr "Ijanisha Bya Umumaro ku Ubwisubire ku Ryari: Ibijyana ni OYA Bihari"

#, fuzzy
#~ msgid "Maximal code growth caused by tail duplication (in percents)"
#~ msgstr "ITEGEKONGENGA IKURA ku in"

#, fuzzy
#~ msgid "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percents)"
#~ msgstr "Ihindurakerekezo IKURA NIBA i Ihindurakerekezo Imishobokere Bya ni Birutwa iyi in"

#, fuzzy
#~ msgid "Stop forward growth if the probability of best edge is less than this threshold (in percents). Used when profile feedback is available"
#~ msgstr "Imbere IKURA NIBA i Imishobokere Bya ni Birutwa iyi in Ryari: Ibijyana ni Bihari"

#, fuzzy
#~ msgid "Stop forward growth if the probability of best edge is less than this threshold (in percents). Used when profile feedback is not available"
#~ msgstr "Imbere IKURA NIBA i Imishobokere Bya ni Birutwa iyi in Ryari: Ibijyana ni OYA Bihari"

#, fuzzy
#~ msgid "The maximum number of incoming edges to consider for crossjumping"
#~ msgstr "Kinini Umubare Bya Kuri kugirango"

#, fuzzy
#~ msgid "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap."
#~ msgstr "Kuri Imbarutso Nka a Ijanisha Bya i Igiteranyo Ingano Bya i"

#, fuzzy
#~ msgid "Minimum heap size before we start collecting garbage, in kilobytes."
#~ msgstr "Ingano Mbere Twebwe Gutangira in"

#, fuzzy
#~ msgid "too many #pragma options align=reset"
#~ msgstr "Amahitamo Gutondeka Kugarura"

#, fuzzy
#~ msgid "junk at end of '#pragma options'"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "malformed '#pragma options align={mac68k|power|reset}', ignoring"
#~ msgstr "Amahitamo Gutondeka UMWIKUBE Kugarura"

#, fuzzy
#~ msgid "missing '(' after '#pragma unused', ignoring"
#~ msgstr "Ibuze Nyuma"

#, fuzzy
#~ msgid "missing ')' after '#pragma unused', ignoring"
#~ msgstr "Ibuze Nyuma"

#, fuzzy
#~ msgid "junk at end of '#pragma unused'"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "-msystem-v and -p are incompatible"
#~ msgstr "-v Na P"

#, fuzzy
#~ msgid "-msystem-v and -mthreads are incompatible"
#~ msgstr "-v Na"

#, fuzzy
#~ msgid "-f%s ignored for Unicos/Mk (not supported)"
#~ msgstr "-F kugirango OYA"

#, fuzzy
#~ msgid "-mieee not supported on Unicos/Mk"
#~ msgstr "-OYA ku"

#, fuzzy
#~ msgid "-mieee-with-inexact not supported on Unicos/Mk"
#~ msgstr "-Na: OYA ku"

#, fuzzy
#~ msgid "bad value `%s' for -mtrap-precision switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "bad value `%s' for -mfp-rounding-mode switch"
#~ msgstr "Agaciro kugirango Ubwoko Hindura"

#, fuzzy
#~ msgid "bad value `%s' for -mfp-trap-mode switch"
#~ msgstr "Agaciro kugirango Ubwoko Hindura"

#, fuzzy
#~ msgid "bad value `%s' for -mtls-size switch"
#~ msgstr "Agaciro kugirango Ingano Hindura"

#, fuzzy
#~ msgid "bad value `%s' for -mcpu switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "trap mode not supported on Unicos/Mk"
#~ msgstr "Ubwoko OYA ku"

#, fuzzy
#~ msgid "fp software completion requires -mtrap-precision=i"
#~ msgstr "i"

#, fuzzy
#~ msgid "rounding mode not supported for VAX floats"
#~ msgstr "Ubwoko OYA kugirango"

#, fuzzy
#~ msgid "trap mode not supported for VAX floats"
#~ msgstr "Ubwoko OYA kugirango"

#, fuzzy
#~ msgid "L%d cache latency unknown for %s"
#~ msgstr "Ubwihisho Kitazwi kugirango"

#, fuzzy
#~ msgid "bad value `%s' for -mmemory-latency"
#~ msgstr "Agaciro kugirango"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%H value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%J value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%r value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%R value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%N value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%P value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%h value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%L value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%m value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%M value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%U value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%s value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%C value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%E value"
#~ msgstr "Agaciro siko"

#, fuzzy
#~ msgid "unknown relocation unspec"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "invalid %%xn code"
#~ msgstr "Sibyo ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not use hardware fp"
#~ msgstr "OYA Gukoresha"

#, fuzzy
#~ msgid "Do not use fp registers"
#~ msgstr "OYA Gukoresha"

#, fuzzy
#~ msgid "Do not assume GAS"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Request IEEE-conformant math library routines (OSF/1)"
#~ msgstr "Imibare Isomero 1."

#, fuzzy
#~ msgid "Emit IEEE-conformant code, without inexact exceptions"
#~ msgstr "ITEGEKONGENGA Amarengayobora"

#, fuzzy
#~ msgid "Emit IEEE-conformant code, with inexact exceptions"
#~ msgstr "ITEGEKONGENGA Na: Amarengayobora"

#, fuzzy
#~ msgid "Do not emit complex integer constants to read-only memory"
#~ msgstr "OYA ITSINDA RY'IMIBARE C Umubare wuzuye Kuri Gusoma Ububiko"

#, fuzzy
#~ msgid "Do not use VAX fp"
#~ msgstr "OYA Gukoresha"

#, fuzzy
#~ msgid "Emit code for the byte/word ISA extension"
#~ msgstr "ITEGEKONGENGA kugirango i Bayite ijambo Umugereka"

#, fuzzy
#~ msgid "Emit code for the motion video ISA extension"
#~ msgstr "ITEGEKONGENGA kugirango i Videwo... Umugereka"

#, fuzzy
#~ msgid "Emit code for the fp move and sqrt ISA extension"
#~ msgstr "ITEGEKONGENGA kugirango i Kwimura Na SQRT Umugereka"

#, fuzzy
#~ msgid "Emit code for the counting ISA extension"
#~ msgstr "ITEGEKONGENGA kugirango i Kubara Umugereka"

#, fuzzy
#~ msgid "Emit code using explicit relocation directives"
#~ msgstr "ITEGEKONGENGA ikoresha"

#, fuzzy
#~ msgid "Emit 16-bit relocations to the small data areas"
#~ msgstr "Kuri i Gitoya Ibyatanzwe Ubuso"

#, fuzzy
#~ msgid "Emit 32-bit relocations to the small data areas"
#~ msgstr "Kuri i Gitoya Ibyatanzwe Ubuso"

#, fuzzy
#~ msgid "Emit rdval instead of rduniq for thread pointer"
#~ msgstr "Bya kugirango Urudodo Mweretsi"

#, fuzzy
#~ msgid "Use features of and schedule given CPU"
#~ msgstr "Ibiranga Bya Na Igenabihe"

#, fuzzy
#~ msgid "Control the generated fp rounding mode"
#~ msgstr "i Ubwoko"

#, fuzzy
#~ msgid "Control the IEEE trap mode"
#~ msgstr "i Ubwoko"

#, fuzzy
#~ msgid "Control the precision given to fp exceptions"
#~ msgstr "i Kuri Amarengayobora"

#, fuzzy
#~ msgid "Tune expected memory latency"
#~ msgstr "Ikitezwe: Ububiko"

#, fuzzy
#~ msgid "Specify bit size of immediate TLS offsets"
#~ msgstr "Ingano Bya"

#, fuzzy
#~ msgid "bad value (%s) for -mcpu switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "argument of `%s' attribute is not a string constant"
#~ msgstr "Bya Ikiranga ni OYA a Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "argument of `%s' attribute is not \"ilink1\" or \"ilink2\""
#~ msgstr "Bya Ikiranga ni OYA Cyangwa"

#, fuzzy
#~ msgid "invalid operand to %%R code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid operand to %%H/%%L code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid operand to %%U code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid operand to %%V code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid operand output code"
#~ msgstr "Sibyo Ibisohoka ITEGEKONGENGA"

#, fuzzy
#~ msgid "switch -mcpu=%s conflicts with -march= switch"
#~ msgstr "Hindura Na: Werurwe Hindura"

#, fuzzy
#~ msgid "bad value (%s) for %s switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "target CPU does not support APCS-32"
#~ msgstr "Intego OYA Gushigikira"

#, fuzzy
#~ msgid "target CPU does not support APCS-26"
#~ msgstr "Intego OYA Gushigikira"

#, fuzzy
#~ msgid "target CPU does not support interworking"
#~ msgstr "Intego OYA Gushigikira"

#, fuzzy
#~ msgid "target CPU does not support THUMB instructions"
#~ msgstr "Intego OYA Gushigikira Amabwiriza"

#, fuzzy
#~ msgid "enabling backtrace support is only meaningful when compiling for the Thumb"
#~ msgstr "Gushigikira ni Ryari: kugirango i"

#, fuzzy
#~ msgid "enabling callee interworking support is only meaningful when compiling for the Thumb"
#~ msgstr "Gushigikira ni Ryari: kugirango i"

#, fuzzy
#~ msgid "enabling caller interworking support is only meaningful when compiling for the Thumb"
#~ msgstr "Gushigikira ni Ryari: kugirango i"

#, fuzzy
#~ msgid "interworking forces APCS-32 to be used"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "-mapcs-stack-check incompatible with -mno-apcs-frame"
#~ msgstr "-Kugenzura... Na: Ikadiri"

#, fuzzy
#~ msgid "-fpic and -mapcs-reent are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "APCS reentrant code not supported.  Ignored"
#~ msgstr "ITEGEKONGENGA OYA"

#, fuzzy
#~ msgid "-g with -mno-apcs-frame may not give sensible debugging"
#~ msgstr "-g Na: Ikadiri Gicurasi OYA"

#, fuzzy
#~ msgid "passing floating point arguments in fp regs not yet supported"
#~ msgstr "Bihindagurika Akadomo ingingo in OYA"

#, fuzzy
#~ msgid "invalid floating point emulation option: -mfpe-%s"
#~ msgstr "Sibyo Bihindagurika Akadomo Ihitamo"

#, fuzzy
#~ msgid "structure size boundary can only be set to 8 or 32"
#~ msgstr "Imiterere Ingano Gushyiraho Kuri 8 Cyangwa"

#, fuzzy
#~ msgid "-mpic-register= is useless without -fpic"
#~ msgstr "-Kwiyandikisha ni"

#, fuzzy
#~ msgid "unable to use '%s' for PIC register"
#~ msgstr "Kuri Gukoresha kugirango Kwiyandikisha"

#, fuzzy
#~ msgid "`%s' attribute only applies to functions"
#~ msgstr "`%s'Ikiranga Kuri Imimaro"

#, fuzzy
#~ msgid "unable to compute real location of stacked parameter"
#~ msgstr "Kuri Ahantu Bya Birunze"

#, fuzzy
#~ msgid "no low registers available for popping high registers"
#~ msgstr "Oya Byo hasi Bihari kugirango kirekire"

#, fuzzy
#~ msgid "interrupt Service Routines cannot be coded in Thumb mode"
#~ msgstr "Hagarikira aho in Ubwoko"

#, fuzzy
#~ msgid "initialized variable `%s' is marked dllimport"
#~ msgstr "IMPINDURAGACIRO ni cy/ byagarajwe"

#, fuzzy
#~ msgid "static variable `%s' is marked dllimport"
#~ msgstr "IMPINDURAGACIRO ni cy/ byagarajwe"

#, fuzzy
#~ msgid "Generate APCS conformant stack frames"
#~ msgstr "Amakadiri"

#, fuzzy
#~ msgid "Store function names in object code"
#~ msgstr "Umumaro Amazina in Igikoresho ITEGEKONGENGA"

#, fuzzy
#~ msgid "Use the 32-bit version of the APCS"
#~ msgstr "i Verisiyo Bya i"

#, fuzzy
#~ msgid "Use the 26-bit version of the APCS"
#~ msgstr "i Verisiyo Bya i"

#, fuzzy
#~ msgid "Pass FP arguments in FP registers"
#~ msgstr "ingingo in"

#, fuzzy
#~ msgid "Generate re-entrant, PIC code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "The MMU will trap on unaligned accesses"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Use library calls to perform FP operations"
#~ msgstr "Isomero Amahamagara: Kuri Ibikorwa:"

#, fuzzy
#~ msgid "Use hardware floating point instructions"
#~ msgstr "Bihindagurika Akadomo Amabwiriza"

#, fuzzy
#~ msgid "Assume target CPU is configured as big endian"
#~ msgstr "Intego ni Nka"

#, fuzzy
#~ msgid "Assume target CPU is configured as little endian"
#~ msgstr "Intego ni Nka"

#, fuzzy
#~ msgid "Assume big endian bytes, little endian words"
#~ msgstr "Bayite Amagambo"

#, fuzzy
#~ msgid "Support calls between Thumb and ARM instruction sets"
#~ msgstr "Amahamagara: hagati Na"

#, fuzzy
#~ msgid "Generate a call to abort if a noreturn function returns"
#~ msgstr "a Kuri Kureka NIBA a Umumaro"

#, fuzzy
#~ msgid "Do not move instructions into a function's prologue"
#~ msgstr "OYA Kwimura Amabwiriza a"

#, fuzzy
#~ msgid "Do not load the PIC register in function prologues"
#~ msgstr "OYA Ibirimo i Kwiyandikisha in Umumaro"

#, fuzzy
#~ msgid "Generate call insns as indirect calls, if necessary"
#~ msgstr "Nka BUZIGUYE Amahamagara: NIBA"

#, fuzzy
#~ msgid "Compile for the Thumb not the ARM"
#~ msgstr "kugirango i OYA i"

#, fuzzy
#~ msgid "Thumb: Generate (non-leaf) stack frames even if not needed"
#~ msgstr "Amakadiri ATARIIGIHARWE NIBA OYA"

#, fuzzy
#~ msgid "Thumb: Generate (leaf) stack frames even if not needed"
#~ msgstr "Amakadiri ATARIIGIHARWE NIBA OYA"

#, fuzzy
#~ msgid "Thumb: Assume non-static functions may be called from ARM code"
#~ msgstr "Imimaro Gicurasi Bivuye ITEGEKONGENGA"

#, fuzzy
#~ msgid "Thumb: Assume function pointers may go to non-Thumb aware code"
#~ msgstr "Umumaro Gicurasi Gyayo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "Specify the name of the target CPU"
#~ msgstr "i Izina: Bya i Intego"

#, fuzzy
#~ msgid "Specify the name of the target architecture"
#~ msgstr "i Izina: Bya i Intego"

#, fuzzy
#~ msgid "Specify the version of the floating point emulator"
#~ msgstr "i Verisiyo Bya i Bihindagurika Akadomo"

#, fuzzy
#~ msgid "Specify the minimum bit alignment of structures"
#~ msgstr "i Gito Itunganya Bya"

#, fuzzy
#~ msgid "Specify the register to be used for PIC addressing"
#~ msgstr "i Kwiyandikisha Kuri kugirango Kwohereza"

#, fuzzy
#~ msgid "Ignore dllimport attribute for functions"
#~ msgstr "Ikiranga kugirango Imimaro"

#, fuzzy
#~ msgid "large frame pointer change (%d) with -mtiny-stack"
#~ msgstr "Binini Ikadiri Mweretsi Guhindura>> Na:"

#, fuzzy
#~ msgid "bad address, not (reg+disp):"
#~ msgstr "Aderesi OYA"

#, fuzzy
#~ msgid "internal compiler error.  Bad address:"
#~ msgstr "By'imbere Ikosa Aderesi"

#, fuzzy
#~ msgid "internal compiler error.  Unknown mode:"
#~ msgstr "By'imbere Ikosa Ubwoko"

#, fuzzy
#~ msgid "invalid insn:"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "unknown move insn:"
#~ msgstr "Kitazwi Kwimura"

#, fuzzy
#~ msgid "bad shift insn:"
#~ msgstr "Gusunika"

#, fuzzy
#~ msgid "internal compiler error.  Incorrect shift:"
#~ msgstr "By'imbere Ikosa Gusunika"

#, fuzzy
#~ msgid "only initialized variables can be placed into program memory area"
#~ msgstr "Ibihinduka Porogaramu Ububiko Ubuso"

#, fuzzy
#~ msgid "only uninitialized variables can be placed in the .noinit section"
#~ msgstr "Itatangijwe Ibihinduka in i Icyiciro"

#, fuzzy
#~ msgid "MCU `%s' supported for assembler only"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Assume int to be 8 bit integer"
#~ msgstr "INT Kuri 8 Umubare wuzuye"

#, fuzzy
#~ msgid "Change the stack pointer without disabling interrupts"
#~ msgstr "i Mweretsi"

#, fuzzy
#~ msgid "Use subroutines for function prologue/epilogue"
#~ msgstr "kugirango Umumaro"

#, fuzzy
#~ msgid "Change only the low 8 bits of the stack pointer"
#~ msgstr "i Byo hasi 8 Bya i Mweretsi"

#, fuzzy
#~ msgid "Do not generate tablejump insns"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Use rjmp/rcall (limited range) on >8K devices"
#~ msgstr "Urutonde ku"

#, fuzzy
#~ msgid "Output instruction sizes to the asm file"
#~ msgstr "Kuri i IDOSIYE"

#, fuzzy
#~ msgid "Specify the initial stack address"
#~ msgstr "i Aderesi"

#, fuzzy
#~ msgid "Specify the MCU name"
#~ msgstr "i Izina:"

#, fuzzy
#~ msgid "trampolines not supported"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "missing '(' after '#pragma %s' - ignored"
#~ msgstr "Ibuze Nyuma"

#, fuzzy
#~ msgid "missing function name in '#pragma %s' - ignored"
#~ msgstr "Ibuze Umumaro Izina: in"

#, fuzzy
#~ msgid "missing section name in '#pragma %s' - ignored"
#~ msgstr "Ibuze Icyiciro Izina: in"

#, fuzzy
#~ msgid "missing ')' for '#pragma %s' - ignored"
#~ msgstr "Ibuze kugirango"

#, fuzzy
#~ msgid "junk at end of '#pragma %s'"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "unknown CPU version %d, using 40.\n"
#~ msgstr "Kitazwi Verisiyo ikoresha"

#, fuzzy
#~ msgid "ISR %s requires %d words of local vars, max is 32767"
#~ msgstr "Amagambo Bya KININI ni"

#, fuzzy
#~ msgid "using CONST_DOUBLE for address"
#~ msgstr "ikoresha kugirango Aderesi"

#, fuzzy
#~ msgid "c4x_address_cost: Invalid addressing mode"
#~ msgstr "Kwohereza Ubwoko"

#, fuzzy
#~ msgid "c4x_rptb_insert: Cannot find start label"
#~ msgstr "Gushaka Gutangira Akarango"

#, fuzzy
#~ msgid "mode not QImode"
#~ msgstr "Ubwoko OYA"

#, fuzzy
#~ msgid "invalid indirect memory address"
#~ msgstr "Sibyo BUZIGUYE Ububiko Aderesi"

#, fuzzy
#~ msgid "invalid indirect (S) memory address"
#~ msgstr "Sibyo BUZIGUYE Ububiko Aderesi"

#, fuzzy
#~ msgid "c4x_valid_operands: Internal error"
#~ msgstr "Ikosa"

#, fuzzy
#~ msgid "c4x_operand_subword: invalid mode"
#~ msgstr "Sibyo Ubwoko"

#, fuzzy
#~ msgid "c4x_operand_subword: invalid operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "c4x_operand_subword: invalid autoincrement"
#~ msgstr "Sibyo nyamwiyongera"

#, fuzzy
#~ msgid "c4x_operand_subword: invalid address"
#~ msgstr "Sibyo Aderesi"

#, fuzzy
#~ msgid "c4x_operand_subword: address not offsettable"
#~ msgstr "Aderesi OYA"

#, fuzzy
#~ msgid "c4x_rptb_rpts_p: Repeat block top label moved\n"
#~ msgstr "Funga Hejuru: Akarango"

#, fuzzy
#~ msgid "Small memory model"
#~ msgstr "Ububiko Urugero"

#, fuzzy
#~ msgid "Big memory model"
#~ msgstr "Ububiko Urugero"

#, fuzzy
#~ msgid "Use MPYI instruction for C3x"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Do not use MPYI instruction for C3x"
#~ msgstr "OYA Gukoresha kugirango"

#, fuzzy
#~ msgid "Use fast but approximate float to integer conversion"
#~ msgstr "Byihuta Kureremba Kuri Umubare wuzuye Ihindurangero"

#, fuzzy
#~ msgid "Use slow but accurate float to integer conversion"
#~ msgstr "Buhoro Kureremba Kuri Umubare wuzuye Ihindurangero"

#, fuzzy
#~ msgid "Enable use of RTPS instruction"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Disable use of RTPS instruction"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Enable use of RTPB instruction"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Disable use of RTPB instruction"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Generate code for C30 CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for C31 CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for C32 CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for C33 CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for C40 CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for C44 CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Emit code compatible with TI tools"
#~ msgstr "ITEGEKONGENGA Na: Ibikoresho"

#, fuzzy
#~ msgid "Emit code to use GAS extensions"
#~ msgstr "ITEGEKONGENGA Kuri Gukoresha Umigereka"

#, fuzzy
#~ msgid "Save DP across ISR in small memory model"
#~ msgstr "Kubika Kwambukiranya in Gitoya Ububiko Urugero"

#, fuzzy
#~ msgid "Don't save DP across ISR in small memory model"
#~ msgstr "Kubika Kwambukiranya in Gitoya Ububiko Urugero"

#, fuzzy
#~ msgid "Pass arguments on the stack"
#~ msgstr "ingingo ku i"

#, fuzzy
#~ msgid "Pass arguments in registers"
#~ msgstr "ingingo in"

#, fuzzy
#~ msgid "Enable new features under development"
#~ msgstr "Gishya Ibiranga"

#, fuzzy
#~ msgid "Disable new features under development"
#~ msgstr "Gishya Ibiranga"

#, fuzzy
#~ msgid "Use the BK register as a general purpose register"
#~ msgstr "i Kwiyandikisha Nka a Rusange Intego Kwiyandikisha"

#, fuzzy
#~ msgid "Do not allocate BK register"
#~ msgstr "OYA Kwiyandikisha"

#, fuzzy
#~ msgid "Enable use of DB instruction"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Disable use of DB instruction"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Force constants into registers to improve hoisting"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Force RTL generation to emit valid 3 operand insns"
#~ msgstr "Kuri Byemewe 3."

#, fuzzy
#~ msgid "Allow RTL generation to emit invalid 3 operand insns"
#~ msgstr "Kuri Sibyo 3."

#, fuzzy
#~ msgid "Allow unsigned iteration counts for RPTB/DB"
#~ msgstr "Bitashizweho umukono kugirango"

#, fuzzy
#~ msgid "Disallow unsigned iteration counts for RPTB/DB"
#~ msgstr "Bitashizweho umukono kugirango"

#, fuzzy
#~ msgid "Preserve all 40 bits of FP reg across call"
#~ msgstr "Byose Bya Kwambukiranya"

#, fuzzy
#~ msgid "Only preserve 32 bits of FP reg across call"
#~ msgstr "Bya Kwambukiranya"

#, fuzzy
#~ msgid "Enable parallel instructions"
#~ msgstr "Biteganye Amabwiriza"

#, fuzzy
#~ msgid "Disable parallel instructions"
#~ msgstr "Biteganye Amabwiriza"

#, fuzzy
#~ msgid "Enable MPY||ADD and MPY||SUB instructions"
#~ msgstr "Na Amabwiriza"

#, fuzzy
#~ msgid "Disable MPY||ADD and MPY||SUB instructions"
#~ msgstr "Na Amabwiriza"

#, fuzzy
#~ msgid "Assume that pointers may be aliased"
#~ msgstr "Gicurasi"

#, fuzzy
#~ msgid "Assume that pointers not aliased"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Specify maximum number of iterations for RPTS"
#~ msgstr "Kinini Umubare Bya Amasubiramo kugirango"

#, fuzzy
#~ msgid "Select CPU to generate code for"
#~ msgstr "Kuri ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "unexpected index-type in cris_print_index"
#~ msgstr "Umubarendanga Ubwoko in"

#, fuzzy
#~ msgid "unexpected base-type in cris_print_base"
#~ msgstr "SHINGIRO Ubwoko in"

#, fuzzy
#~ msgid "stackframe too big: %d bytes"
#~ msgstr "Bayite"

#, fuzzy
#~ msgid "allocated but unused delay list in epilogue"
#~ msgstr "Kidakoreshwa Gutinda Urutonde in"

#, fuzzy
#~ msgid "unexpected function type needing stack adjustment for __builtin_eh_return"
#~ msgstr "Umumaro Ubwoko kugirango"

#, fuzzy
#~ msgid "invalid operand for 'b' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'v' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'P' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'p' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'z' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'H' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "bad register"
#~ msgstr "Kwiyandikisha"

#, fuzzy
#~ msgid "invalid operand for 'e' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'm' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'A' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'D' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand for 'T' modifier"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "invalid operand modifier letter"
#~ msgstr "Sibyo Ibaruwa..."

#, fuzzy
#~ msgid "internal error: bad register: %d"
#~ msgstr "By'imbere Ikosa Kwiyandikisha"

#, fuzzy
#~ msgid "unrecognized address"
#~ msgstr "Aderesi"

#, fuzzy
#~ msgid "internal error: sideeffect-insn affecting main effect"
#~ msgstr "By'imbere Ikosa INGARUKA"

#, fuzzy
#~ msgid "internal error: cris_side_effect_mode_ok with bad operands"
#~ msgstr "By'imbere Ikosa Na:"

#, fuzzy
#~ msgid "unrecognized supposed constant in cris_global_pic_symbol"
#~ msgstr "in"

#, fuzzy
#~ msgid "-max-stackframe=%d is not usable, not between 0 and %d"
#~ msgstr "-KININI ni OYA OYA hagati 0 Na"

#, fuzzy
#~ msgid "unknown CRIS version specification in -march= or -mcpu= : %s"
#~ msgstr "Kitazwi Verisiyo in Werurwe Cyangwa"

#, fuzzy
#~ msgid "unknown CRIS cpu version specification in -mtune= : %s"
#~ msgstr "Kitazwi CPU Verisiyo in"

#, fuzzy
#~ msgid "-fPIC and -fpic are not supported in this configuration"
#~ msgstr "-Na OYA in iyi Iboneza"

#, fuzzy
#~ msgid "that particular -g option is invalid with -maout and -melinux"
#~ msgstr "g Ihitamo ni Sibyo Na: Na"

#, fuzzy
#~ msgid "unexpected side-effects in address"
#~ msgstr "Ingaruka in Aderesi"

#, fuzzy
#~ msgid "unexpected PIC symbol"
#~ msgstr "IKIMENYETSO"

#, fuzzy
#~ msgid "PIC register isn't set up"
#~ msgstr "Kwiyandikisha si Gushyiraho Hejuru"

#, fuzzy
#~ msgid "unexpected address expression"
#~ msgstr "Aderesi imvugo"

#, fuzzy
#~ msgid "emitting PIC operand, but PIC register isn't set up"
#~ msgstr "Kwiyandikisha si Gushyiraho Hejuru"

#, fuzzy
#~ msgid "unexpected NOTE as addr_const:"
#~ msgstr "Nka"

#, fuzzy
#~ msgid "Compile for the MMU-less Etrax 100-based elinux system"
#~ msgstr "kugirango i Birutwa 100 Sisitemu"

#, fuzzy
#~ msgid "For elinux, request a specified stack-size for this program"
#~ msgstr "Kubaza... a Ingano kugirango iyi Porogaramu"

#, fuzzy
#~ msgid "Compile for ETRAX 4 (CRIS v3)"
#~ msgstr "kugirango 4."

#, fuzzy
#~ msgid "Compile for ETRAX 100 (CRIS v8)"
#~ msgstr "kugirango 100"

#, fuzzy
#~ msgid "Emit verbose debug information in assembly code"
#~ msgstr "Kosora amakosa Ibisobanuro in ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not use condition codes from normal instructions"
#~ msgstr "OYA Gukoresha Ibisabwa Bivuye Bisanzwe Amabwiriza"

#, fuzzy
#~ msgid "Do not emit addressing modes with side-effect assignment"
#~ msgstr "OYA Kwohereza Na: INGARUKA Igenera"

#, fuzzy
#~ msgid "Do not tune stack alignment"
#~ msgstr "OYA Itunganya"

#, fuzzy
#~ msgid "Do not tune writable data alignment"
#~ msgstr "OYA Ibyatanzwe Itunganya"

#, fuzzy
#~ msgid "Do not tune code and read-only data alignment"
#~ msgstr "OYA ITEGEKONGENGA Na Gusoma Ibyatanzwe Itunganya"

#, fuzzy
#~ msgid "Align code and data to 32 bits"
#~ msgstr "ITEGEKONGENGA Na Ibyatanzwe Kuri"

#, fuzzy
#~ msgid "Don't align items in code or data"
#~ msgstr "Gutondeka in ITEGEKONGENGA Cyangwa Ibyatanzwe"

#, fuzzy
#~ msgid "Do not emit function prologue or epilogue"
#~ msgstr "OYA Umumaro Cyangwa"

#, fuzzy
#~ msgid "Use the most feature-enabling options allowed by other options"
#~ msgstr "i Amahitamo ku Ikindi Amahitamo"

#, fuzzy
#~ msgid "Override -mbest-lib-options"
#~ msgstr "Amahitamo"

#, fuzzy
#~ msgid "Generate code for the specified chip or CPU version"
#~ msgstr "ITEGEKONGENGA kugirango i Cyangwa Verisiyo"

#, fuzzy
#~ msgid "Tune alignment for the specified chip or CPU version"
#~ msgstr "Itunganya kugirango i Cyangwa Verisiyo"

#, fuzzy
#~ msgid "Warn when a stackframe is larger than the specified size"
#~ msgstr "Ryari: a ni Kinini i Ingano"

#, fuzzy
#~ msgid "no FUNCTION_PROFILER for CRIS"
#~ msgstr "Oya kugirango"

#, fuzzy
#~ msgid "Together with -fpic and -fPIC, do not use GOTPLT references"
#~ msgstr "Na: Na OYA Gukoresha Indango"

#, fuzzy
#~ msgid "bad modes_tieable_p for register %s, mode1 %s, mode2 %s"
#~ msgstr "kugirango Kwiyandikisha"

#, fuzzy
#~ msgid "bad insn to d30v_print_operand_address:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to d30v_print_operand_memory_reference:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to d30v_print_operand, 'f' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to d30v_print_operand, 'A' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to d30v_print_operand, 'M' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to print_operand, 'F' or 'T' modifier:"
#~ msgstr "Kuri Cyangwa"

#, fuzzy
#~ msgid "bad insn to print_operand, 'B' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to print_operand, 'E' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to print_operand, 'R' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn to print_operand, 's' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "bad insn in d30v_print_operand, 0 case"
#~ msgstr "in 0"

#, fuzzy
#~ msgid "bad call to d30v_move_2words"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Enable use of conditional move instructions"
#~ msgstr "Gukoresha Bya Kwimura Amabwiriza"

#, fuzzy
#~ msgid "Disable use of conditional move instructions"
#~ msgstr "Gukoresha Bya Kwimura Amabwiriza"

#, fuzzy
#~ msgid "Debug argument support in compiler"
#~ msgstr "Gushigikira in"

#, fuzzy
#~ msgid "Debug stack support in compiler"
#~ msgstr "Gushigikira in"

#, fuzzy
#~ msgid "Debug memory address support in compiler"
#~ msgstr "Ububiko Aderesi Gushigikira in"

#, fuzzy
#~ msgid "Make adjacent short instructions parallel if possible"
#~ msgstr "Amabwiriza Biteganye NIBA"

#, fuzzy
#~ msgid "Do not make adjacent short instructions parallel"
#~ msgstr "OYA Ubwoko Amabwiriza Biteganye"

#, fuzzy
#~ msgid "Link programs/data to be in external memory by default"
#~ msgstr "Porogaramu Ibyatanzwe Kuri in external Ububiko ku Mburabuzi"

#, fuzzy
#~ msgid "Link programs/data to be in onchip memory by default"
#~ msgstr "Porogaramu Ibyatanzwe Kuri in Ububiko ku Mburabuzi"

#, fuzzy
#~ msgid "Change the branch costs within the compiler"
#~ msgstr "i muri i"

#, fuzzy
#~ msgid "Change the threshold for conversion to conditional execution"
#~ msgstr "i kugirango Ihindurangero Kuri"

#, fuzzy
#~ msgid "stack size > 32k"
#~ msgstr "Ingano"

#, fuzzy
#~ msgid "invalid addressing mode"
#~ msgstr "Sibyo Kwohereza Ubwoko"

#, fuzzy
#~ msgid "bad register extension code"
#~ msgstr "Kwiyandikisha Umugereka ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid offset in ybase addressing"
#~ msgstr "Sibyo Nta- boneza in Kwohereza"

#, fuzzy
#~ msgid "invalid register in ybase addressing"
#~ msgstr "Sibyo Kwiyandikisha in Kwohereza"

#, fuzzy
#~ msgid "invalid shift operator in emit_1600_core_shift"
#~ msgstr "Sibyo Gusunika Mukoresha in"

#, fuzzy
#~ msgid "invalid mode for gen_tst_reg"
#~ msgstr "Sibyo Ubwoko kugirango"

#, fuzzy
#~ msgid "invalid mode for integer comparison in gen_compare_reg"
#~ msgstr "Sibyo Ubwoko kugirango Umubare wuzuye in"

#, fuzzy
#~ msgid "Pass parameters in registers (default)"
#~ msgstr "Ibigenga in Mburabuzi"

#, fuzzy
#~ msgid "Don't pass parameters in registers"
#~ msgstr "Ibigenga in"

#, fuzzy
#~ msgid "Generate code for near calls"
#~ msgstr "ITEGEKONGENGA kugirango Amahamagara:"

#, fuzzy
#~ msgid "Don't generate code for near calls"
#~ msgstr "ITEGEKONGENGA kugirango Amahamagara:"

#, fuzzy
#~ msgid "Generate code for near jumps"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Don't generate code for near jumps"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for a bit-manipulation unit"
#~ msgstr "ITEGEKONGENGA kugirango a Igice:"

#, fuzzy
#~ msgid "Don't generate code for a bit-manipulation unit"
#~ msgstr "ITEGEKONGENGA kugirango a Igice:"

#, fuzzy
#~ msgid "Generate code for memory map1"
#~ msgstr "ITEGEKONGENGA kugirango Ububiko"

#, fuzzy
#~ msgid "Generate code for memory map2"
#~ msgstr "ITEGEKONGENGA kugirango Ububiko"

#, fuzzy
#~ msgid "Generate code for memory map3"
#~ msgstr "ITEGEKONGENGA kugirango Ububiko"

#, fuzzy
#~ msgid "Generate code for memory map4"
#~ msgstr "ITEGEKONGENGA kugirango Ububiko"

#, fuzzy
#~ msgid "Ouput extra code for initialized data"
#~ msgstr "Birenga ITEGEKONGENGA kugirango Ibyatanzwe"

#, fuzzy
#~ msgid "Don't let reg. allocator use ybase registers"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "Output extra debug info in Luxworks environment"
#~ msgstr "Birenga Kosora amakosa Ibisobanuro in"

#, fuzzy
#~ msgid "Save temp. files in Luxworks environment"
#~ msgstr "Kubika Idosiye in"

#, fuzzy
#~ msgid "Specify alternate name for text section"
#~ msgstr "Izina: kugirango Umwandiko Icyiciro"

#, fuzzy
#~ msgid "Specify alternate name for data section"
#~ msgstr "Izina: kugirango Ibyatanzwe Icyiciro"

#, fuzzy
#~ msgid "Specify alternate name for bss section"
#~ msgstr "Izina: kugirango Icyiciro"

#, fuzzy
#~ msgid "Specify alternate name for constant section"
#~ msgstr "Izina: kugirango Icyiciro"

#, fuzzy
#~ msgid "Specify alternate name for dsp16xx chip"
#~ msgstr "Izina: kugirango"

#, fuzzy
#~ msgid "profiling not implemented yet"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "trampolines not yet implemented"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "fr30_print_operand_address: unhandled address"
#~ msgstr "Aderesi"

#, fuzzy
#~ msgid "fr30_print_operand: unrecognized %%p code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "fr30_print_operand: unrecognized %%b code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "fr30_print_operand: unrecognized %%B code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "fr30_print_operand: invalid operand to %%A code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "fr30_print_operand: invalid %%x code"
#~ msgstr "Sibyo ITEGEKONGENGA"

#, fuzzy
#~ msgid "fr30_print_operand: invalid %%F code"
#~ msgstr "Sibyo ITEGEKONGENGA"

#, fuzzy
#~ msgid "fr30_print_operand: unknown code"
#~ msgstr "Kitazwi ITEGEKONGENGA"

#, fuzzy
#~ msgid "Assume small address space"
#~ msgstr "Gitoya Aderesi Umwanya"

#, fuzzy
#~ msgid "Unknown cpu: -mcpu=%s"
#~ msgstr "CPU"

#, fuzzy
#~ msgid "-fpic and -gdwarf are incompatible (-fpic and -g/-gdwarf-2 are fine)"
#~ msgstr "-Na Na g 2."

#, fuzzy
#~ msgid "Bad insn to frv_print_operand_address:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad register to frv_print_operand_memory_reference_reg:"
#~ msgstr "Kwiyandikisha Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand_memory_reference:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn in frv_print_operand, bad const_double"
#~ msgstr "in"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'C' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'c' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'e' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'F' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'f' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'L' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'M/N' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, 'O' modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn to frv_print_operand, P modifier:"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "Bad insn in frv_print_operand, z case"
#~ msgstr "in Z"

#, fuzzy
#~ msgid "Bad insn in frv_print_operand, 0 case"
#~ msgstr "in 0"

#, fuzzy
#~ msgid "frv_print_operand: unknown code"
#~ msgstr "Kitazwi ITEGEKONGENGA"

#, fuzzy
#~ msgid "accumulator is not a constant integer"
#~ msgstr "ni OYA a Umubare wuzuye"

#, fuzzy
#~ msgid "accumulator number is out of bounds"
#~ msgstr "Umubare ni Inyuma Bya"

#, fuzzy
#~ msgid "inappropriate accumulator for `%s'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "`%s' expects a constant argument"
#~ msgstr "`%s'a"

#, fuzzy
#~ msgid "constant argument out of range for `%s'"
#~ msgstr "Inyuma Bya Urutonde kugirango"

#, fuzzy
#~ msgid "media functions are not available unless -mmedia is used"
#~ msgstr "Ibitangazamakuru Imimaro OYA Bihari ni"

#, fuzzy
#~ msgid "this media function is only available on the fr500"
#~ msgstr "iyi Ibitangazamakuru Umumaro ni Bihari ku i"

#, fuzzy
#~ msgid "this media function is only available on the fr400"
#~ msgstr "iyi Ibitangazamakuru Umumaro ni Bihari ku i"

#, fuzzy
#~ msgid "-ms2600 is used without -ms"
#~ msgstr "-ni"

#, fuzzy
#~ msgid "-mn is used without -mh or -ms"
#~ msgstr "-ni Cyangwa"

#, fuzzy
#~ msgid "Generate H8S code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not generate H8S code"
#~ msgstr "OYA ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate H8S/2600 code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not generate H8S/2600 code"
#~ msgstr "OYA ITEGEKONGENGA"

#, fuzzy
#~ msgid "Use registers for argument passing"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Do not use registers for argument passing"
#~ msgstr "OYA Gukoresha kugirango"

#, fuzzy
#~ msgid "Consider access to byte sized memory slow"
#~ msgstr "Kuri Bayite Ububiko Buhoro"

#, fuzzy
#~ msgid "Generate H8/300H code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Enable the normal mode"
#~ msgstr "i Bisanzwe Ubwoko"

#, fuzzy
#~ msgid "Do not generate H8/300H code"
#~ msgstr "OYA ITEGEKONGENGA"

#, fuzzy
#~ msgid "Use H8/300 alignment rules"
#~ msgstr "300 Itunganya"

#, fuzzy
#~ msgid "junk at end of #pragma map"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "real name is too long - alias ignored"
#~ msgstr "Izina: ni Irihimbano"

#, fuzzy
#~ msgid "alias name is too long - alias ignored"
#~ msgstr "Irihimbano Izina: ni Irihimbano"

#, fuzzy
#~ msgid "internal error--no jump follows compare:"
#~ msgstr "By'imbere Ikosa Oya Simbuka Kugereranya#"

#, fuzzy
#~ msgid "Generate char instructions"
#~ msgstr "INYUGUTI Amabwiriza"

#, fuzzy
#~ msgid "Do not generate char instructions"
#~ msgstr "OYA INYUGUTI Amabwiriza"

#, fuzzy
#~ msgid "code model %s not supported in PIC mode"
#~ msgstr "ITEGEKONGENGA Urugero OYA in Ubwoko"

#, fuzzy
#~ msgid "bad value (%s) for -mcmodel= switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "bad value (%s) for -masm= switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "code model `%s' not supported in the %s bit mode"
#~ msgstr "ITEGEKONGENGA Urugero OYA in i Ubwoko"

#, fuzzy
#~ msgid "code model `large' not supported yet"
#~ msgstr "ITEGEKONGENGA Urugero OYA"

#, fuzzy
#~ msgid "%i-bit mode not compiled in"
#~ msgstr "%i-bitUbwoko OYA in"

#, fuzzy
#~ msgid "bad value (%s) for -march= switch"
#~ msgstr "Agaciro kugirango Werurwe Hindura"

#, fuzzy
#~ msgid "bad value (%s) for -mcpu= switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "-mregparm=%d is not between 0 and %d"
#~ msgstr "-ni OYA hagati 0 Na"

#, fuzzy
#~ msgid "-malign-loops is obsolete, use -falign-loops"
#~ msgstr "-ni Gukoresha"

#, fuzzy
#~ msgid "-malign-loops=%d is not between 0 and %d"
#~ msgstr "-ni OYA hagati 0 Na"

#, fuzzy
#~ msgid "-malign-jumps is obsolete, use -falign-jumps"
#~ msgstr "-ni Gukoresha"

#, fuzzy
#~ msgid "-malign-functions is obsolete, use -falign-functions"
#~ msgstr "-Imimaro ni Gukoresha Imimaro"

#, fuzzy
#~ msgid "-mpreferred-stack-boundary=%d is not between %d and 12"
#~ msgstr "-ni OYA hagati Na 12"

#, fuzzy
#~ msgid "-mbranch-cost=%d is not between 0 and 5"
#~ msgstr "-Ikiguzi ni OYA hagati 0 Na 5"

#, fuzzy
#~ msgid "bad value (%s) for -mtls-dialect= switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "-malign-double makes no sense in the 64bit mode"
#~ msgstr "-MAHARAKUBIRI Oya in i Ubwoko"

#, fuzzy
#~ msgid "-mrtd calling convention not supported in the 64bit mode"
#~ msgstr "-OYA in i Ubwoko"

#, fuzzy
#~ msgid "SSE instruction set disabled, using 387 arithmetics"
#~ msgstr "Gushyiraho Yahagaritswe ikoresha"

#, fuzzy
#~ msgid "387 instruction set disabled, using SSE arithmetics"
#~ msgstr "Gushyiraho Yahagaritswe ikoresha"

#, fuzzy
#~ msgid "bad value (%s) for -mfpmath= switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "`%s' attribute requires an integer constant argument"
#~ msgstr "`%s'Ikiranga Umubare wuzuye"

#, fuzzy
#~ msgid "argument to `%s' attribute larger than %d"
#~ msgstr "Kuri Ikiranga Kinini"

#, fuzzy
#~ msgid "invalid UNSPEC as operand"
#~ msgstr "Sibyo Nka"

#, fuzzy
#~ msgid "extended registers have no high halves"
#~ msgstr "Byongerewe... Oya kirekire"

#, fuzzy
#~ msgid "unsupported operand size for extended register"
#~ msgstr "Ingano kugirango Byongerewe... Kwiyandikisha"

#, fuzzy
#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
#~ msgstr "ni a a Ibisabwa ITEGEKONGENGA Sibyo ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid operand code `%c'"
#~ msgstr "Sibyo ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid constraints for operand"
#~ msgstr "Sibyo kugirango"

#, fuzzy
#~ msgid "unknown insn mode"
#~ msgstr "Kitazwi Ubwoko"

#, fuzzy
#~ msgid "shift must be an immediate"
#~ msgstr "Gusunika"

#, fuzzy
#~ msgid "`%s' attribute only applies to variables"
#~ msgstr "`%s'Ikiranga Kuri Ibihinduka"

#, fuzzy
#~ msgid "`%s' declared as both exported to and imported from a DLL"
#~ msgstr "`%s'Nka Byombi Kuri Na cyavuye ahandi/ cyatumijwe Bivuye a"

#, fuzzy
#~ msgid "Use the Cygwin interface"
#~ msgstr "i"

#, fuzzy
#~ msgid "Use the Mingw32 interface"
#~ msgstr "i"

#, fuzzy
#~ msgid "Create GUI application"
#~ msgstr "Porogaramu"

#, fuzzy
#~ msgid "Don't set Windows defines"
#~ msgstr "Gushyiraho"

#, fuzzy
#~ msgid "Create console application"
#~ msgstr "Porogaramu"

#, fuzzy
#~ msgid "Generate code for a DLL"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Ignore dllimport for functions"
#~ msgstr "kugirango Imimaro"

#, fuzzy
#~ msgid "Use Mingw-specific thread support"
#~ msgstr "Urudodo Gushigikira"

#, fuzzy
#~ msgid "-f%s ignored for target (all code is position independent)"
#~ msgstr "-F kugirango Intego Byose ITEGEKONGENGA ni Ibirindiro"

#, fuzzy
#~ msgid "-mbnu210 is ignored (option is obsolete)"
#~ msgstr "-ni Ihitamo ni"

#, fuzzy
#~ msgid "Use normal calling convention"
#~ msgstr "Bisanzwe"

#, fuzzy
#~ msgid "Align some doubles on dword boundary"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Align doubles on word boundary"
#~ msgstr "ku ijambo"

#, fuzzy
#~ msgid "Uninitialized locals in .bss"
#~ msgstr "in"

#, fuzzy
#~ msgid "Uninitialized locals in .data"
#~ msgstr "in Ibyatanzwe"

#, fuzzy
#~ msgid "Use IEEE math for fp comparisons"
#~ msgstr "Imibare kugirango"

#, fuzzy
#~ msgid "Do not use IEEE math for fp comparisons"
#~ msgstr "OYA Gukoresha Imibare kugirango"

#, fuzzy
#~ msgid "Return values of functions in FPU registers"
#~ msgstr "Uduciro Bya Imimaro in"

#, fuzzy
#~ msgid "Do not return values of functions in FPU registers"
#~ msgstr "OYA Garuka Uduciro Bya Imimaro in"

#, fuzzy
#~ msgid "Do not generate sin, cos, sqrt for FPU"
#~ msgstr "OYA SIN COS SQRT kugirango"

#, fuzzy
#~ msgid "Generate sin, cos, sqrt for FPU"
#~ msgstr "SIN COS SQRT kugirango"

#, fuzzy
#~ msgid "Omit the frame pointer in leaf functions"
#~ msgstr "i Ikadiri Mweretsi in Imimaro"

#, fuzzy
#~ msgid "Align destination of the string operations"
#~ msgstr "Ishyika Bya i Ikurikiranyanyuguti Ibikorwa:"

#, fuzzy
#~ msgid "Do not align destination of the string operations"
#~ msgstr "OYA Gutondeka Ishyika Bya i Ikurikiranyanyuguti Ibikorwa:"

#, fuzzy
#~ msgid "Inline all known string operations"
#~ msgstr "Byose Ikurikiranyanyuguti Ibikorwa:"

#, fuzzy
#~ msgid "Do not inline all known string operations"
#~ msgstr "OYA Mumurongo Byose Ikurikiranyanyuguti Ibikorwa:"

#, fuzzy
#~ msgid "Use push instructions to save outgoing arguments"
#~ msgstr "Amabwiriza Kuri Kubika ingingo"

#, fuzzy
#~ msgid "Do not use push instructions to save outgoing arguments"
#~ msgstr "OYA Gukoresha Amabwiriza Kuri Kubika ingingo"

#, fuzzy
#~ msgid "Support MMX built-in functions"
#~ msgstr "in Imimaro"

#, fuzzy
#~ msgid "Do not support MMX built-in functions"
#~ msgstr "OYA Gushigikira in Imimaro"

#, fuzzy
#~ msgid "Support 3DNow! built-in functions"
#~ msgstr "in Imimaro"

#, fuzzy
#~ msgid "Do not support 3DNow! built-in functions"
#~ msgstr "OYA Gushigikira in Imimaro"

#, fuzzy
#~ msgid "Support MMX and SSE built-in functions and code generation"
#~ msgstr "Na in Imimaro Na ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not support MMX and SSE built-in functions and code generation"
#~ msgstr "OYA Gushigikira Na in Imimaro Na ITEGEKONGENGA"

#, fuzzy
#~ msgid "Support MMX, SSE and SSE2 built-in functions and code generation"
#~ msgstr "Na in Imimaro Na ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not support MMX, SSE and SSE2 built-in functions and code generation"
#~ msgstr "OYA Gushigikira Na in Imimaro Na ITEGEKONGENGA"

#, fuzzy
#~ msgid "sizeof(long double) is 16"
#~ msgstr "MAHARAKUBIRI ni"

#, fuzzy
#~ msgid "sizeof(long double) is 12"
#~ msgstr "MAHARAKUBIRI ni 12"

#, fuzzy
#~ msgid "Generate 64bit x86-64 code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate 32bit i386 code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Use red-zone in the x86-64 code"
#~ msgstr "Umutuku in i ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not use red-zone in the x86-64 code"
#~ msgstr "OYA Gukoresha Umutuku in i ITEGEKONGENGA"

#, fuzzy
#~ msgid "Schedule code for given CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate floating point mathematics using given instruction set"
#~ msgstr "Bihindagurika Akadomo ikoresha Gushyiraho"

#, fuzzy
#~ msgid "Generate code for given CPU"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Number of registers used to pass integer arguments"
#~ msgstr "Bya Kuri Umubare wuzuye ingingo"

#, fuzzy
#~ msgid "Loop code aligned to this power of 2"
#~ msgstr "ITEGEKONGENGA Kuri iyi UMWIKUBE Bya 2."

#, fuzzy
#~ msgid "Jump targets are aligned to this power of 2"
#~ msgstr "Kuri iyi UMWIKUBE Bya 2."

#, fuzzy
#~ msgid "Function starts are aligned to this power of 2"
#~ msgstr "Kuri iyi UMWIKUBE Bya 2."

#, fuzzy
#~ msgid "Attempt to keep stack aligned to this power of 2"
#~ msgstr "Kuri Gumana: Kuri iyi UMWIKUBE Bya 2."

#, fuzzy
#~ msgid "Branches are this expensive (1-5, arbitrary units)"
#~ msgstr "iyi 1. 5"

#, fuzzy
#~ msgid "Use given x86-64 code model"
#~ msgstr "ITEGEKONGENGA Urugero"

#, fuzzy
#~ msgid "Use given thread-local storage dialect"
#~ msgstr "Urudodo"

#, fuzzy
#~ msgid "Generate ELF output"
#~ msgstr "Ibisohoka"

#, fuzzy
#~ msgid "environment variable DJGPP not defined"
#~ msgstr "IMPINDURAGACIRO OYA"

#, fuzzy
#~ msgid "environment variable DJGPP points to missing file '%s'"
#~ msgstr "IMPINDURAGACIRO Utudomo Kuri Ibuze IDOSIYE"

#, fuzzy
#~ msgid "environment variable DJGPP points to corrupt file '%s'"
#~ msgstr "IMPINDURAGACIRO Utudomo Kuri IDOSIYE"

#, fuzzy
#~ msgid "sorry, not implemented: #pragma align NAME=SIZE"
#~ msgstr "OYA Gutondeka"

#, fuzzy
#~ msgid "malformed #pragma align - ignored"
#~ msgstr "Gutondeka"

#, fuzzy
#~ msgid "sorry, not implemented: #pragma noalign NAME"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "conflicting architectures defined - using C series"
#~ msgstr "ikoresha C Ibyiciro"

#, fuzzy
#~ msgid "conflicting architectures defined - using K series"
#~ msgstr "ikoresha Ibyiciro"

#, fuzzy
#~ msgid "iC2.0 and iC3.0 are incompatible - using iC3.0"
#~ msgstr "0 Na 0 ikoresha 0"

#, fuzzy
#~ msgid "stack limit expression is not supported"
#~ msgstr "imvugo ni OYA"

#, fuzzy
#~ msgid "Generate SA code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate SB code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate KA code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate KB code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate JA code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate JD code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate JF code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "generate RP code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate MC code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate CA code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate CF code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Use software floating point"
#~ msgstr "Bihindagurika Akadomo"

#, fuzzy
#~ msgid "Use alternate leaf function entries"
#~ msgstr "Umumaro Ibyinjijwe"

#, fuzzy
#~ msgid "Do not use alternate leaf function entries"
#~ msgstr "OYA Gukoresha Umumaro Ibyinjijwe"

#, fuzzy
#~ msgid "Do not perform tail call optimization"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Use complex addressing modes"
#~ msgstr "ITSINDA RY'IMIBARE C Kwohereza"

#, fuzzy
#~ msgid "Do not use complex addressing modes"
#~ msgstr "OYA Gukoresha ITSINDA RY'IMIBARE C Kwohereza"

#, fuzzy
#~ msgid "Align code to 8 byte boundary"
#~ msgstr "ITEGEKONGENGA Kuri 8 Bayite"

#, fuzzy
#~ msgid "Do not align code to 8 byte boundary"
#~ msgstr "OYA Gutondeka ITEGEKONGENGA Kuri 8 Bayite"

#, fuzzy
#~ msgid "Enable compatibility with iC960 v2.0"
#~ msgstr "Bihuye neza Na: 0"

#, fuzzy
#~ msgid "Enable compatibility with iC960 v3.0"
#~ msgstr "Bihuye neza Na: 0"

#, fuzzy
#~ msgid "Enable compatibility with ic960 assembler"
#~ msgstr "Bihuye neza Na:"

#, fuzzy
#~ msgid "Do not permit unaligned accesses"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Layout types like Intel's v1.3 gcc"
#~ msgstr "nka 3."

#, fuzzy
#~ msgid "Do not layout types like Intel's v1.3 gcc"
#~ msgstr "OYA Imigaragarire nka 3."

#, fuzzy
#~ msgid "Do not enable linker relaxation"
#~ msgstr "OYA Gushoboza"

#, fuzzy
#~ msgid "ia64_print_operand: unknown code"
#~ msgstr "Kitazwi ITEGEKONGENGA"

#, fuzzy
#~ msgid "value of -mfixed-range must have form REG1-REG2"
#~ msgstr "Agaciro Bya Urutonde Ifishi"

#, fuzzy
#~ msgid "%s-%s is an empty range"
#~ msgstr "%s-%sni ubusa Urutonde"

#, fuzzy
#~ msgid "cannot optimize floating point division for both latency and throughput"
#~ msgstr "Kugeza ku ndunduro Bihindagurika Akadomo kugirango Byombi Na"

#, fuzzy
#~ msgid "cannot optimize integer division for both latency and throughput"
#~ msgstr "Kugeza ku ndunduro Umubare wuzuye kugirango Byombi Na"

#, fuzzy
#~ msgid "bad value (%s) for -mtls-size= switch"
#~ msgstr "Agaciro kugirango Ingano Hindura"

#, fuzzy
#~ msgid "Generate big endian code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate little endian code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate code for GNU as"
#~ msgstr "ITEGEKONGENGA kugirango Nka"

#, fuzzy
#~ msgid "Generate code for Intel as"
#~ msgstr "ITEGEKONGENGA kugirango Nka"

#, fuzzy
#~ msgid "Generate code for GNU ld"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for Intel ld"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code without GP reg"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Emit stop bits before and after volatile extended asms"
#~ msgstr "Guhagarara Mbere Na Nyuma Byongerewe..."

#, fuzzy
#~ msgid "Don't emit stop bits before and after volatile extended asms"
#~ msgstr "Guhagarara Mbere Na Nyuma Byongerewe..."

#, fuzzy
#~ msgid "Emit code for Itanium (TM) processor B step"
#~ msgstr "ITEGEKONGENGA kugirango Intera"

#, fuzzy
#~ msgid "Use in/loc/out register names"
#~ msgstr "in Inyuma Kwiyandikisha Amazina"

#, fuzzy
#~ msgid "Disable use of sdata/scommon/sbss"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Enable use of sdata/scommon/sbss"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "gp is constant (but save/restore gp on indirect calls)"
#~ msgstr "ni Kubika Kugarura ku BUZIGUYE Amahamagara:"

#, fuzzy
#~ msgid "Generate self-relocatable code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate inline floating point division, optimize for latency"
#~ msgstr "Mumurongo Bihindagurika Akadomo Kugeza ku ndunduro kugirango"

#, fuzzy
#~ msgid "Generate inline floating point division, optimize for throughput"
#~ msgstr "Mumurongo Bihindagurika Akadomo Kugeza ku ndunduro kugirango"

#, fuzzy
#~ msgid "Generate inline integer division, optimize for latency"
#~ msgstr "Mumurongo Umubare wuzuye Kugeza ku ndunduro kugirango"

#, fuzzy
#~ msgid "Generate inline integer division, optimize for throughput"
#~ msgstr "Mumurongo Umubare wuzuye Kugeza ku ndunduro kugirango"

#, fuzzy
#~ msgid "Enable Dwarf 2 line debug info via GNU as"
#~ msgstr "2. Umurongo Kosora amakosa Ibisobanuro Biturutse Nka"

#, fuzzy
#~ msgid "Disable Dwarf 2 line debug info via GNU as"
#~ msgstr "2. Umurongo Kosora amakosa Ibisobanuro Biturutse Nka"

#, fuzzy
#~ msgid "Specify range of registers to make fixed"
#~ msgstr "Urutonde Bya Kuri Ubwoko BIHAMYE"

#, fuzzy
#~ msgid "bad value (%s) for -mmodel switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "bad value (%s) for -msdata switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "invalid argument of `%s' attribute"
#~ msgstr "Sibyo Bya Ikiranga"

#, fuzzy
#~ msgid "const objects cannot go in .sdata/.sbss"
#~ msgstr "Ibintu Gyayo in"

#, fuzzy
#~ msgid "invalid operand to %%s code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid operand to %%p code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "bad insn for 'A'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "invalid operand to %%T/%%B code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid operand to %%N code"
#~ msgstr "Sibyo Kuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "pre-increment address is not a register"
#~ msgstr "Byahawe imiterere mbere Iyongeragaciro Aderesi ni OYA a Kwiyandikisha"

#, fuzzy
#~ msgid "pre-decrement address is not a register"
#~ msgstr "Byahawe imiterere mbere Aderesi ni OYA a Kwiyandikisha"

#, fuzzy
#~ msgid "post-increment address is not a register"
#~ msgstr "Iposita Iyongeragaciro Aderesi ni OYA a Kwiyandikisha"

#, fuzzy
#~ msgid "bad address"
#~ msgstr "Aderesi"

#, fuzzy
#~ msgid "lo_sum not of register"
#~ msgstr "OYA Bya Kwiyandikisha"

#, fuzzy
#~ msgid "Display compile time statistics"
#~ msgstr "Gukusanya Igihe Sitatisitiki"

#, fuzzy
#~ msgid "Align all loops to 32 byte boundary"
#~ msgstr "Byose Kuri Bayite"

#, fuzzy
#~ msgid "Only issue one instruction per cycle"
#~ msgstr "Itangwa Uruziga"

#, fuzzy
#~ msgid "Prefer branches over conditional execution"
#~ msgstr "KURI"

#, fuzzy
#~ msgid "Code size: small, medium or large"
#~ msgstr "Ingano Gitoya biringaniye Cyangwa Binini"

#, fuzzy
#~ msgid "Small data area: none, sdata, use"
#~ msgstr "Ibyatanzwe Ubuso Ntacyo Gukoresha"

#, fuzzy
#~ msgid "-f%s ignored for 68HC11/68HC12 (not supported)"
#~ msgstr "-F kugirango OYA"

#, fuzzy
#~ msgid "`trap' and `far' attributes are not compatible, ignoring `far'"
#~ msgstr "`Na Ibiranga OYA"

#, fuzzy
#~ msgid "`trap' attribute is already used"
#~ msgstr "`Ikiranga ni"

#, fuzzy
#~ msgid "move insn not handled"
#~ msgstr "Kwimura OYA"

#, fuzzy
#~ msgid "invalid register in the move instruction"
#~ msgstr "Sibyo Kwiyandikisha in i Kwimura"

#, fuzzy
#~ msgid "invalid operand in the instruction"
#~ msgstr "Sibyo in i"

#, fuzzy
#~ msgid "invalid register in the instruction"
#~ msgstr "Sibyo Kwiyandikisha in i"

#, fuzzy
#~ msgid "operand 1 must be a hard register"
#~ msgstr "1. a Ikomeye Kwiyandikisha"

#, fuzzy
#~ msgid "invalid rotate insn"
#~ msgstr "Sibyo Kuzerutsa"

#, fuzzy
#~ msgid "registers IX, IY and Z used in the same INSN"
#~ msgstr "Na in i"

#, fuzzy
#~ msgid "cannot do z-register replacement"
#~ msgstr "Z Kwiyandikisha"

#, fuzzy
#~ msgid "invalid Z register replacement for insn"
#~ msgstr "Sibyo Kwiyandikisha kugirango"

#, fuzzy
#~ msgid "Compile with 16-bit integer mode"
#~ msgstr "Na: Umubare wuzuye Ubwoko"

#, fuzzy
#~ msgid "Compile with 32-bit integer mode"
#~ msgstr "Na: Umubare wuzuye Ubwoko"

#, fuzzy
#~ msgid "Auto pre/post decrement increment allowed"
#~ msgstr "Byahawe imiterere mbere Iposita Iyongeragaciro"

#, fuzzy
#~ msgid "Auto pre/post decrement increment not allowed"
#~ msgstr "Byahawe imiterere mbere Iposita Iyongeragaciro OYA"

#, fuzzy
#~ msgid "Min/max instructions allowed"
#~ msgstr "KININI Amabwiriza"

#, fuzzy
#~ msgid "Min/max instructions not allowed"
#~ msgstr "KININI Amabwiriza OYA"

#, fuzzy
#~ msgid "Use call and rtc for function calls and returns"
#~ msgstr "Na kugirango Umumaro Amahamagara: Na"

#, fuzzy
#~ msgid "Use jsr and rts for function calls and returns"
#~ msgstr "Na kugirango Umumaro Amahamagara: Na"

#, fuzzy
#~ msgid "Do not use direct addressing mode for soft registers"
#~ msgstr "OYA Gukoresha Kwohereza Ubwoko kugirango Yoroshe"

#, fuzzy
#~ msgid "Use direct addressing mode for soft registers"
#~ msgstr "Kwohereza Ubwoko kugirango Yoroshe"

#, fuzzy
#~ msgid "Compile for a 68HC11"
#~ msgstr "kugirango a"

#, fuzzy
#~ msgid "Compile for a 68HC12"
#~ msgstr "kugirango a"

#, fuzzy
#~ msgid "Compile for a 68HCS12"
#~ msgstr "kugirango a"

#, fuzzy
#~ msgid "Specify the register allocation order"
#~ msgstr "i Kwiyandikisha Itondekanya"

#, fuzzy
#~ msgid "Indicate the number of soft registers available"
#~ msgstr "i Umubare Bya Yoroshe Bihari"

#, fuzzy
#~ msgid "-malign-loops=%d is not between 1 and %d"
#~ msgstr "-ni OYA hagati 1. Na"

#, fuzzy
#~ msgid "-malign-jumps=%d is not between 1 and %d"
#~ msgstr "-ni OYA hagati 1. Na"

#, fuzzy
#~ msgid "-malign-functions=%d is not between 1 and %d"
#~ msgstr "-Imimaro ni OYA hagati 1. Na"

#, fuzzy
#~ msgid "-fPIC is not currently supported on the 68000 or 68010\n"
#~ msgstr "-ni OYA ku i Cyangwa"

#, fuzzy
#~ msgid "Generate code for a 68020"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a 68000"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Use the bit-field instructions"
#~ msgstr "i Umwanya Amabwiriza"

#, fuzzy
#~ msgid "Do not use the bit-field instructions"
#~ msgstr "OYA Gukoresha i Umwanya Amabwiriza"

#, fuzzy
#~ msgid "Use different calling convention using 'rtd'"
#~ msgstr "ikoresha"

#, fuzzy
#~ msgid "Consider type `int' to be 16 bits wide"
#~ msgstr "Ubwoko Kuri"

#, fuzzy
#~ msgid "Consider type `int' to be 32 bits wide"
#~ msgstr "Ubwoko Kuri"

#, fuzzy
#~ msgid "Generate code for a Sun FPA"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Do not generate code for a Sun FPA"
#~ msgstr "OYA ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a Sun Sky board"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Do not use Sky linkage convention"
#~ msgstr "OYA Gukoresha"

#, fuzzy
#~ msgid "Generate code for a 68881"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code with library calls for floating point"
#~ msgstr "ITEGEKONGENGA Na: Isomero Amahamagara: kugirango Bihindagurika Akadomo"

#, fuzzy
#~ msgid "Generate code for a 68040, without any new instructions"
#~ msgstr "ITEGEKONGENGA kugirango a Gishya Amabwiriza"

#, fuzzy
#~ msgid "Generate code for a 68060, without any new instructions"
#~ msgstr "ITEGEKONGENGA kugirango a Gishya Amabwiriza"

#, fuzzy
#~ msgid "Generate code for a 68030"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a 68040"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a 68060"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a 520X"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a 68851"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Do no generate code for a 68851"
#~ msgstr "Oya ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a 68302"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a 68332"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Generate code for a cpu32"
#~ msgstr "ITEGEKONGENGA kugirango a"

#, fuzzy
#~ msgid "Align variables on a 32-bit boundary"
#~ msgstr "Ibihinduka ku a"

#, fuzzy
#~ msgid "Align variables on a 16-bit boundary"
#~ msgstr "Ibihinduka ku a"

#, fuzzy
#~ msgid "Generate pc-relative code"
#~ msgstr "Bifitanye isano ITEGEKONGENGA"

#, fuzzy
#~ msgid "Do not use unaligned memory references"
#~ msgstr "OYA Gukoresha Ububiko Indango"

#, fuzzy
#~ msgid "Use unaligned memory references"
#~ msgstr "Ububiko Indango"

#, fuzzy
#~ msgid "internal gcc monitor: short-branch(%x)"
#~ msgstr "By'imbere"

#, fuzzy
#~ msgid "internal gcc error: Can't express symbolic location"
#~ msgstr "By'imbere Ikosa Ahantu"

#, fuzzy
#~ msgid "argument #%d is a structure"
#~ msgstr "ni a Imiterere"

#, fuzzy
#~ msgid "%%R not followed by %%B/C/D/E"
#~ msgstr "%%ROYA ku C E"

#, fuzzy
#~ msgid "invalid %%x/X value"
#~ msgstr "Sibyo Agaciro"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%Q value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%q value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%o value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%p value"
#~ msgstr "Agaciro siko"

#, fuzzy
#~ msgid "invalid %%s/S value"
#~ msgstr "Sibyo Agaciro"

#, fuzzy
#~ msgid "invalid %%P operand"
#~ msgstr "Sibyo"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%B value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%D value"
#~ msgstr "Agaciro siko"

#, fuzzy
#~ msgid "`%%d' operand isn't a register"
#~ msgstr "`%%d'si a Kwiyandikisha"

#, fuzzy
#~ msgid "operand is r0"
#~ msgstr "ni"

#, fuzzy
#~ msgid "operand is const_double"
#~ msgstr "ni"

#, fuzzy
#~ msgid "invalid code"
#~ msgstr "Sibyo ITEGEKONGENGA"

#, fuzzy
#~ msgid "-mtrap-large-shift and -mhandle-large-shift are incompatible"
#~ msgstr "-Binini Gusunika Na Binini Gusunika"

#, fuzzy
#~ msgid "invalid option `-mshort-data-%s'"
#~ msgstr "Sibyo Ihitamo Ibyatanzwe"

#, fuzzy
#~ msgid "-mshort-data-%s is too large "
#~ msgstr "-Ibyatanzwe ni Binini"

#, fuzzy
#~ msgid "-mshort-data-%s and PIC are incompatible"
#~ msgstr "-Ibyatanzwe Na"

#, fuzzy
#~ msgid "invalid option `-mstack-increment=%s'"
#~ msgstr "Sibyo Ihitamo Iyongeragaciro"

#, fuzzy
#~ msgid "Inline constants if it can be done in 2 insns or less"
#~ msgstr "NIBA Byakozwe in 2. Cyangwa Birutwa"

#, fuzzy
#~ msgid "Inline constants if it only takes 1 instruction"
#~ msgstr "NIBA 1."

#, fuzzy
#~ msgid "Set maximum alignment to 4"
#~ msgstr "Kinini Itunganya Kuri 4."

#, fuzzy
#~ msgid "Set maximum alignment to 8"
#~ msgstr "Kinini Itunganya Kuri 8"

#, fuzzy
#~ msgid "Do not use the divide instruction"
#~ msgstr "OYA Gukoresha i Kugabanya"

#, fuzzy
#~ msgid "Do not arbitrary sized immediates in bit operations"
#~ msgstr "OYA in Ibikorwa:"

#, fuzzy
#~ msgid "Always treat bit-field as int-sized"
#~ msgstr "Umwanya Nka INT"

#, fuzzy
#~ msgid "Force functions to be aligned to a 4 byte boundary"
#~ msgstr "Imimaro Kuri Kuri a 4. Bayite"

#, fuzzy
#~ msgid "Force functions to be aligned to a 2 byte boundary"
#~ msgstr "Imimaro Kuri Kuri a 2. Bayite"

#, fuzzy
#~ msgid "Emit call graph information"
#~ msgstr "Ibisobanuro"

#, fuzzy
#~ msgid "Prefer word accesses over byte accesses"
#~ msgstr "ijambo KURI Bayite"

#, fuzzy
#~ msgid "Generate code for the M*Core M340"
#~ msgstr "ITEGEKONGENGA kugirango i"

#, fuzzy
#~ msgid "Maximum amount for a single stack increment operation"
#~ msgstr "Igiteranyo kugirango a UMWE Iyongeragaciro"

#, fuzzy
#~ msgid "bad value (%s) for -mabi= switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "-mips%d conflicts with the other architecture options, which specify a MIPS%d processor"
#~ msgstr "-Na: i Ikindi Amahitamo a"

#, fuzzy
#~ msgid "bad value (%s) for -mips switch"
#~ msgstr "Agaciro kugirango Hindura"

#, fuzzy
#~ msgid "-march=%s is not compatible with the selected ABI"
#~ msgstr "-Werurwe ni OYA Na: i Byahiswemo"

#, fuzzy
#~ msgid "-mgp64 used with a 32-bit processor"
#~ msgstr "-Na: a"

#, fuzzy
#~ msgid "-mgp32 used with a 64-bit ABI"
#~ msgstr "-Na: a"

#, fuzzy
#~ msgid "-mgp64 used with a 32-bit ABI"
#~ msgstr "-Na: a"

#, fuzzy
#~ msgid "unsupported combination: %s"
#~ msgstr "Ivanga"

#, fuzzy
#~ msgid "generation of Branch Likely instructions enabled, but not supported by architecture"
#~ msgstr "Bya Amabwiriza Bikora OYA ku"

#, fuzzy
#~ msgid "-G is incompatible with PIC code which is the default"
#~ msgstr "-ni Na: ITEGEKONGENGA ni i Mburabuzi"

#, fuzzy
#~ msgid "-membedded-pic and -mabicalls are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "-G and -membedded-pic are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "invalid option `entry%s'"
#~ msgstr "Sibyo Ihitamo Icyinjijwe"

#, fuzzy
#~ msgid "-mentry is only meaningful with -mips-16"
#~ msgstr "-ni Na:"

#, fuzzy
#~ msgid "internal error: %%) found without a %%( in assembler pattern"
#~ msgstr "By'imbere Ikosa Byabonetse a in Ishusho"

#, fuzzy
#~ msgid "internal error: %%] found without a %%[ in assembler pattern"
#~ msgstr "By'imbere Ikosa Byabonetse a in Ishusho"

#, fuzzy
#~ msgid "internal error: %%> found without a %%< in assembler pattern"
#~ msgstr "By'imbere Ikosa Byabonetse a in Ishusho"

#, fuzzy
#~ msgid "internal error: %%} found without a %%{ in assembler pattern"
#~ msgstr "By'imbere Ikosa Byabonetse a in Ishusho"

#, fuzzy
#~ msgid "PRINT_OPERAND: unknown punctuation '%c'"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "PRINT_OPERAND null pointer"
#~ msgstr "NTAGIHARI Mweretsi"

#, fuzzy
#~ msgid "invalid use of %%d, %%x, or %%X"
#~ msgstr "Sibyo Gukoresha Bya Cyangwa"

#, fuzzy
#~ msgid "PRINT_OPERAND_ADDRESS, null pointer"
#~ msgstr "NTAGIHARI Mweretsi"

#, fuzzy
#~ msgid "MIPS ECOFF format does not allow changing filenames within functions with #line"
#~ msgstr "Imiterere OYA Kwemerera muri Imimaro Na: Umurongo"

#, fuzzy
#~ msgid "can't rewind temp file"
#~ msgstr "IDOSIYE"

#, fuzzy
#~ msgid "can't write to output file"
#~ msgstr "Kwandika Kuri Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid "can't read from temp file"
#~ msgstr "Gusoma Bivuye IDOSIYE"

#, fuzzy
#~ msgid "can't close temp file"
#~ msgstr "Gufunga IDOSIYE"

#, fuzzy
#~ msgid "gp_offset (%ld) or end_offset (%ld) is less than zero"
#~ msgstr "Cyangwa ni Birutwa Zeru"

#, fuzzy
#~ msgid "fp_offset (%ld) or end_offset (%ld) is less than zero"
#~ msgstr "Cyangwa ni Birutwa Zeru"

#, fuzzy
#~ msgid "can not handle inconsistent calls to `%s'"
#~ msgstr "OYA Amahamagara: Kuri"

#, fuzzy
#~ msgid "the cpu name must be lower case"
#~ msgstr "i CPU Izina: Ntoya"

#, fuzzy
#~ msgid "bad value (%s) for %s"
#~ msgstr "Agaciro kugirango"

#, fuzzy
#~ msgid "No default crt0.o"
#~ msgstr "Mburabuzi o"

#, fuzzy
#~ msgid "Use 64-bit int type"
#~ msgstr "INT Ubwoko"

#, fuzzy
#~ msgid "Use 64-bit long type"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "Use 32-bit long type"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "Optimize lui/addiu address loads"
#~ msgstr "Aderesi"

#, fuzzy
#~ msgid "Don't optimize lui/addiu address loads"
#~ msgstr "Kugeza ku ndunduro Aderesi"

#, fuzzy
#~ msgid "Use MIPS as"
#~ msgstr "Nka"

#, fuzzy
#~ msgid "Use GNU as"
#~ msgstr "Nka"

#, fuzzy
#~ msgid "Use symbolic register names"
#~ msgstr "Kwiyandikisha Amazina"

#, fuzzy
#~ msgid "Don't use symbolic register names"
#~ msgstr "Gukoresha Kwiyandikisha Amazina"

#, fuzzy
#~ msgid "Use GP relative sdata/sbss sections"
#~ msgstr "Bifitanye isano Ibyatoranyijwe"

#, fuzzy
#~ msgid "Don't use GP relative sdata/sbss sections"
#~ msgstr "Gukoresha Bifitanye isano Ibyatoranyijwe"

#, fuzzy
#~ msgid "Output compiler statistics"
#~ msgstr "Sitatisitiki"

#, fuzzy
#~ msgid "Don't output compiler statistics"
#~ msgstr "Ibisohoka Sitatisitiki"

#, fuzzy
#~ msgid "Don't optimize block moves"
#~ msgstr "Kugeza ku ndunduro Funga"

#, fuzzy
#~ msgid "Optimize block moves"
#~ msgstr "Funga"

#, fuzzy
#~ msgid "Don't use mips-tfile asm postpass"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "Use hardware floating point"
#~ msgstr "Bihindagurika Akadomo"

#, fuzzy
#~ msgid "Use 64-bit general registers"
#~ msgstr "Rusange"

#, fuzzy
#~ msgid "Use 32-bit general registers"
#~ msgstr "Rusange"

#, fuzzy
#~ msgid "Don't use Irix PIC"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "Use indirect calls"
#~ msgstr "BUZIGUYE Amahamagara:"

#, fuzzy
#~ msgid "Don't use indirect calls"
#~ msgstr "Gukoresha BUZIGUYE Amahamagara:"

#, fuzzy
#~ msgid "Use embedded PIC"
#~ msgstr "Gitsindiye"

#, fuzzy
#~ msgid "Don't use embedded PIC"
#~ msgstr "Gukoresha Gitsindiye"

#, fuzzy
#~ msgid "Use ROM instead of RAM"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "Don't use ROM instead of RAM"
#~ msgstr "Gukoresha Bya"

#, fuzzy
#~ msgid "Put uninitialized constants in ROM (needs -membedded-data)"
#~ msgstr "Itatangijwe in Ibyatanzwe"

#, fuzzy
#~ msgid "Don't put uninitialized constants in ROM"
#~ msgstr "Gushyira Itatangijwe in"

#, fuzzy
#~ msgid "Use big-endian byte order"
#~ msgstr "Bayite Itondekanya"

#, fuzzy
#~ msgid "Use little-endian byte order"
#~ msgstr "Bayite Itondekanya"

#, fuzzy
#~ msgid "Use single (32-bit) FP only"
#~ msgstr "UMWE"

#, fuzzy
#~ msgid "Don't use single (32-bit) FP only"
#~ msgstr "Gukoresha UMWE"

#, fuzzy
#~ msgid "Use multiply accumulate"
#~ msgstr "Gukuba"

#, fuzzy
#~ msgid "Don't use multiply accumulate"
#~ msgstr "Gukoresha Gukuba"

#, fuzzy
#~ msgid "Don't generate fused multiply/add instructions"
#~ msgstr "Gukuba Kongeramo Amabwiriza"

#, fuzzy
#~ msgid "Generate fused multiply/add instructions"
#~ msgstr "Gukuba Kongeramo Amabwiriza"

#, fuzzy
#~ msgid "Don't work around early 4300 hardware bug"
#~ msgstr "Akazi"

#, fuzzy
#~ msgid "Trap on integer divide by zero"
#~ msgstr "ku Umubare wuzuye Kugabanya ku Zeru"

#, fuzzy
#~ msgid "Don't trap on integer divide by zero"
#~ msgstr "ku Umubare wuzuye Kugabanya ku Zeru"

#, fuzzy
#~ msgid "Trap on integer divide overflow"
#~ msgstr "ku Umubare wuzuye Kugabanya Byarenze urugero"

#, fuzzy
#~ msgid "Don't trap on integer divide overflow"
#~ msgstr "ku Umubare wuzuye Kugabanya Byarenze urugero"

#, fuzzy
#~ msgid "Use Branch Likely instructions, overriding default for arch"
#~ msgstr "Amabwiriza Mburabuzi kugirango"

#, fuzzy
#~ msgid "Don't use Branch Likely instructions, overriding default for arch"
#~ msgstr "Gukoresha Amabwiriza Mburabuzi kugirango"

#, fuzzy
#~ msgid "Specify CPU for scheduling purposes"
#~ msgstr "kugirango Impamvu"

#, fuzzy
#~ msgid "Specify CPU for code generation purposes"
#~ msgstr "kugirango ITEGEKONGENGA Impamvu"

#, fuzzy
#~ msgid "Specify a Standard MIPS ISA"
#~ msgstr "a"

#, fuzzy
#~ msgid "Use mips16 entry/exit psuedo ops"
#~ msgstr "Icyinjijwe Gusohoka"

#, fuzzy
#~ msgid "Don't use MIPS16 instructions"
#~ msgstr "Gukoresha Amabwiriza"

#, fuzzy
#~ msgid "Don't call any cache flush functions"
#~ msgstr "Ubwihisho Imimaro"

#, fuzzy
#~ msgid "Specify cache flush function"
#~ msgstr "Ubwihisho Umumaro"

#, fuzzy
#~ msgid "mips16 function profiling"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "-f%s not supported: ignored"
#~ msgstr "-F OYA"

#, fuzzy
#~ msgid "too large function value type, needs %d registers, have only %d registers for this"
#~ msgstr "Binini Umumaro Agaciro Ubwoko kugirango iyi"

#, fuzzy
#~ msgid "function_profiler support for MMIX"
#~ msgstr "Gushigikira kugirango"

#, fuzzy
#~ msgid "MMIX Internal: Last named vararg would not fit in a register"
#~ msgstr "OYA in a Kwiyandikisha"

#, fuzzy
#~ msgid "MMIX Internal: Expected a CONST_INT, not this"
#~ msgstr "Itegerejwe a OYA iyi"

#, fuzzy
#~ msgid "MMIX Internal: Bad register: %d"
#~ msgstr "Kwiyandikisha"

#, fuzzy
#~ msgid "MMIX Internal: Bad value for 'm', not a CONST_INT"
#~ msgstr "Agaciro kugirango OYA a"

#, fuzzy
#~ msgid "MMIX Internal: Expected a register, not this"
#~ msgstr "Itegerejwe a Kwiyandikisha OYA iyi"

#, fuzzy
#~ msgid "MMIX Internal: Expected a constant, not this"
#~ msgstr "Itegerejwe a OYA iyi"

#, fuzzy
#~ msgid "MMIX Internal: Missing `%c' case in mmix_print_operand"
#~ msgstr "in"

#, fuzzy
#~ msgid "MMIX Internal: Cannot decode this operand"
#~ msgstr "iyi"

#, fuzzy
#~ msgid "MMIX Internal: This is not a recognized address"
#~ msgstr "ni OYA a Aderesi"

#, fuzzy
#~ msgid "stack frame not a multiple of 8 bytes: %d"
#~ msgstr "Ikadiri OYA a Igikubo Bya 8 Bayite"

#, fuzzy
#~ msgid "stack frame not a multiple of octabyte: %d"
#~ msgstr "Ikadiri OYA a Igikubo Bya"

#, fuzzy
#~ msgid "MMIX Internal: %s is not a shiftable int"
#~ msgstr "ni OYA a INT"

#, fuzzy
#~ msgid "MMIX Internal: Trying to output invalidly reversed condition:"
#~ msgstr "Kuri Ibisohoka Bicuritswe Ibisabwa"

#, fuzzy
#~ msgid "MMIX Internal: What's the CC of this?"
#~ msgstr "i Bya iyi"

#, fuzzy
#~ msgid "MMIX Internal: What is the CC of this?"
#~ msgstr "ni i Bya iyi"

#, fuzzy
#~ msgid "MMIX Internal: This is not a constant:"
#~ msgstr "ni OYA a"

#, fuzzy
#~ msgid "Set start-address of the program"
#~ msgstr "Gutangira Aderesi Bya i Porogaramu"

#, fuzzy
#~ msgid "Set start-address of data"
#~ msgstr "Gutangira Aderesi Bya Ibyatanzwe"

#, fuzzy
#~ msgid "For intrinsics library: pass all parameters in registers"
#~ msgstr "Isomero Byose Ibigenga in"

#, fuzzy
#~ msgid "Use register stack for parameters and return value"
#~ msgstr "Kwiyandikisha kugirango Ibigenga Na Garuka Agaciro"

#, fuzzy
#~ msgid "Use call-clobbered registers for parameters and return value"
#~ msgstr "kugirango Ibigenga Na Garuka Agaciro"

#, fuzzy
#~ msgid "Use epsilon-respecting floating point compare instructions"
#~ msgstr "ebusiloni Bihindagurika Akadomo Kugereranya# Amabwiriza"

#, fuzzy
#~ msgid "Use zero-extending memory loads, not sign-extending ones"
#~ msgstr "Zeru Ububiko OYA IKIMENYETSO"

#, fuzzy
#~ msgid "Generate divide results with reminder having the same sign as the divisor (not the dividend)"
#~ msgstr "Kugabanya Ibisubizo ku Na: Mwibutsa i IKIMENYETSO Nka i Ikigabanya OYA i Ikigabanywa"

#, fuzzy
#~ msgid "Prepend global symbols with \":\" (for use with PREFIX)"
#~ msgstr "Ibimenyetso Na: kugirango Gukoresha Na:"

#, fuzzy
#~ msgid "Do not provide a default start-address 0x100 of the program"
#~ msgstr "OYA a Mburabuzi Gutangira Aderesi Bya i Porogaramu"

#, fuzzy
#~ msgid "Link to emit program in ELF format (rather than mmo)"
#~ msgstr "Kuri Porogaramu in Imiterere"

#, fuzzy
#~ msgid "Use P-mnemonics for branches statically predicted as taken"
#~ msgstr "kugirango Nka"

#, fuzzy
#~ msgid "Don't use P-mnemonics for branches"
#~ msgstr "Gukoresha kugirango"

#, fuzzy
#~ msgid "Use addresses that allocate global registers"
#~ msgstr "Amaderesi"

#, fuzzy
#~ msgid "Do not use addresses that allocate global registers"
#~ msgstr "OYA Gukoresha Amaderesi"

#, fuzzy
#~ msgid "Generate a single exit point for each function"
#~ msgstr "a UMWE Gusohoka Akadomo kugirango Umumaro"

#, fuzzy
#~ msgid "Do not generate a single exit point for each function"
#~ msgstr "OYA a UMWE Gusohoka Akadomo kugirango Umumaro"

#, fuzzy
#~ msgid "Work around hardware multiply bug"
#~ msgstr "Gukuba"

#, fuzzy
#~ msgid "Do not work around hardware multiply bug"
#~ msgstr "OYA Akazi Gukuba"

#, fuzzy
#~ msgid "Target the AM33 processor"
#~ msgstr "i"

#, fuzzy
#~ msgid "Don't use hardware fp"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "Pass some arguments in registers"
#~ msgstr "ingingo in"

#, fuzzy
#~ msgid "Pass all arguments on stack"
#~ msgstr "Byose ingingo ku"

#, fuzzy
#~ msgid "Optimize for 32532 cpu"
#~ msgstr "kugirango CPU"

#, fuzzy
#~ msgid "Optimize for 32332 cpu"
#~ msgstr "kugirango CPU"

#, fuzzy
#~ msgid "Optimize for 32032"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Register sb is zero. Use for absolute addressing"
#~ msgstr "ni Zeru kugirango Kwohereza"

#, fuzzy
#~ msgid "Do not use register sb"
#~ msgstr "OYA Gukoresha Kwiyandikisha"

#, fuzzy
#~ msgid "Use bit-field instructions"
#~ msgstr "Umwanya Amabwiriza"

#, fuzzy
#~ msgid "Do not use bit-field instructions"
#~ msgstr "OYA Gukoresha Umwanya Amabwiriza"

#, fuzzy
#~ msgid "Generate code for high memory"
#~ msgstr "ITEGEKONGENGA kugirango kirekire Ububiko"

#, fuzzy
#~ msgid "Generate code for low memory"
#~ msgstr "ITEGEKONGENGA kugirango Byo hasi Ububiko"

#, fuzzy
#~ msgid "Use multiply-accumulate fp instructions"
#~ msgstr "Gukuba Amabwiriza"

#, fuzzy
#~ msgid "Do not use multiply-accumulate fp instructions"
#~ msgstr "OYA Gukoresha Gukuba Amabwiriza"

#, fuzzy
#~ msgid "\"Small register classes\" kludge"
#~ msgstr "\"Kwiyandikisha Inzego"

#, fuzzy
#~ msgid "No \"Small register classes\" kludge"
#~ msgstr "Kwiyandikisha Inzego"

#, fuzzy
#~ msgid ""
#~ "unknown -mschedule= option (%s).\n"
#~ "Valid options are 700, 7100, 7100LC, 7200, 7300, and 8000\n"
#~ msgstr "Kitazwi Ihitamo Amahitamo Na"

#, fuzzy
#~ msgid ""
#~ "unknown -march= option (%s).\n"
#~ "Valid options are 1.0, 1.1, and 2.0\n"
#~ msgstr "01. 1na2."

#, fuzzy
#~ msgid "PIC code generation is not supported in the portable runtime model\n"
#~ msgstr "ITEGEKONGENGA ni OYA in i"

#, fuzzy
#~ msgid "PIC code generation is not compatible with fast indirect calls\n"
#~ msgstr "ITEGEKONGENGA ni OYA Na: Byihuta BUZIGUYE"

#, fuzzy
#~ msgid "-g is only supported when using GAS on this processor,"
#~ msgstr "-g ni Ryari: ikoresha ku iyi"

#, fuzzy
#~ msgid "-g option disabled"
#~ msgstr "-g Ihitamo Yahagaritswe"

#, fuzzy
#~ msgid "Generate cpp defines for server IO"
#~ msgstr "kugirango Seriveri"

#, fuzzy
#~ msgid "Generate cpp defines for workstation IO"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Generate PA1.1 code"
#~ msgstr "1. ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate PA1.0 code"
#~ msgstr "0 ITEGEKONGENGA"

#, fuzzy
#~ msgid "Generate PA2.0 code (requires binutils 2.10 or later)"
#~ msgstr "0 ITEGEKONGENGA 2. 10 Cyangwa"

#, fuzzy
#~ msgid "Do not disable FP regs"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Disable space regs"
#~ msgstr "Umwanya"

#, fuzzy
#~ msgid "Do not disable space regs"
#~ msgstr "OYA Umwanya"

#, fuzzy
#~ msgid "Put jumps in call delay slots"
#~ msgstr "in Gutinda Siloti"

#, fuzzy
#~ msgid "Do not put jumps in call delay slots"
#~ msgstr "OYA Gushyira in Gutinda Siloti"

#, fuzzy
#~ msgid "Disable indexed addressing"
#~ msgstr "Kwohereza"

#, fuzzy
#~ msgid "Do not disable indexed addressing"
#~ msgstr "OYA Kwohereza"

#, fuzzy
#~ msgid "Do not use portable calling conventions"
#~ msgstr "OYA Gukoresha"

#, fuzzy
#~ msgid "Assume code will be assembled by GAS"
#~ msgstr "ITEGEKONGENGA ku"

#, fuzzy
#~ msgid "Do not assume code will be assembled by GAS"
#~ msgstr "OYA ITEGEKONGENGA ku"

#, fuzzy
#~ msgid "Do not use software floating point"
#~ msgstr "OYA Gukoresha Bihindagurika Akadomo"

#, fuzzy
#~ msgid "Emit long load/store sequences"
#~ msgstr "Ibirimo"

#, fuzzy
#~ msgid "Do not emit long load/store sequences"
#~ msgstr "OYA Ibirimo"

#, fuzzy
#~ msgid "Generate fast indirect calls"
#~ msgstr "Byihuta BUZIGUYE Amahamagara:"

#, fuzzy
#~ msgid "Do not generate fast indirect calls"
#~ msgstr "OYA Byihuta BUZIGUYE Amahamagara:"

#, fuzzy
#~ msgid "Generate code for huge switch statements"
#~ msgstr "ITEGEKONGENGA kugirango Hindura"

#, fuzzy
#~ msgid "Do not generate code for huge switch statements"
#~ msgstr "OYA ITEGEKONGENGA kugirango Hindura"

#, fuzzy
#~ msgid "Always generate long calls"
#~ msgstr "Amahamagara:"

#, fuzzy
#~ msgid "Generate long calls only when needed"
#~ msgstr "Amahamagara: Ryari:"

#, fuzzy
#~ msgid "Specify architecture for code generation.  Values are 1.0, 1.1, and 2.0.  2.0 requires gas snapshot 19990413 or later."
#~ msgstr "01. 1na2. 0. 2.."

#, fuzzy
#~ msgid "Assume code will be linked by GNU ld"
#~ msgstr "ITEGEKONGENGA ku"

#, fuzzy
#~ msgid "Assume code will be linked by HP ld"
#~ msgstr "ITEGEKONGENGA ku"

#, fuzzy
#~ msgid "Do not use hardware floating point"
#~ msgstr "OYA Gukoresha Bihindagurika Akadomo"

#, fuzzy
#~ msgid "Return floating point results in ac0"
#~ msgstr "Bihindagurika Akadomo Ibisubizo ku in"

#, fuzzy
#~ msgid "Return floating point results in memory"
#~ msgstr "Bihindagurika Akadomo Ibisubizo ku in Ububiko"

#, fuzzy
#~ msgid "Generate code for an 11/40"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for an 11/45"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for an 11/10"
#~ msgstr "ITEGEKONGENGA kugirango 10"

#, fuzzy
#~ msgid "Use 32 bit int"
#~ msgstr "INT"

#, fuzzy
#~ msgid "Use 16 bit int"
#~ msgstr "INT"

#, fuzzy
#~ msgid "Use 32 bit float"
#~ msgstr "Kureremba"

#, fuzzy
#~ msgid "Use 64 bit float"
#~ msgstr "Kureremba"

#, fuzzy
#~ msgid "Target has split I&D"
#~ msgstr "Gutandukanya"

#, fuzzy
#~ msgid "Target does not have split I&D"
#~ msgstr "OYA Gutandukanya"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%S value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%b value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%z value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%Z value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%k value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%j value"
#~ msgstr "Agaciro siko"

#, fuzzy
#~ msgid "can't have varargs with -mfp-arg-in-fp-regs"
#~ msgstr "Na: in"

#, fuzzy
#~ msgid "missing open paren"
#~ msgstr "Ibuze Gufungura"

#, fuzzy
#~ msgid "missing number"
#~ msgstr "Ibuze Umubare"

#, fuzzy
#~ msgid "missing close paren"
#~ msgstr "Ibuze Gufunga"

#, fuzzy
#~ msgid "number must be 0 or 1"
#~ msgstr "Umubare 0 Cyangwa 1."

#, fuzzy
#~ msgid "junk at end of #pragma longcall"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "-mmultiple is not supported on little endian systems"
#~ msgstr "-ni OYA ku"

#, fuzzy
#~ msgid "-mstring is not supported on little endian systems"
#~ msgstr "-ni OYA ku"

#, fuzzy
#~ msgid "unknown -mdebug-%s switch"
#~ msgstr "Kitazwi Hindura"

#, fuzzy
#~ msgid "unknown -mtraceback arg `%s'; expecting `full', `partial' or `none'"
#~ msgstr "Kitazwi Cyangwa"

#, fuzzy
#~ msgid "Unknown switch -mlong-double-%s"
#~ msgstr "Hindura MAHARAKUBIRI"

#, fuzzy
#~ msgid "unknown -misel= option specified: '%s'"
#~ msgstr "Kitazwi Ihitamo"

#, fuzzy
#~ msgid "unknown -mvrsave= option specified: '%s'"
#~ msgstr "Kitazwi Ihitamo"

#, fuzzy
#~ msgid "unknown ABI specified: '%s'"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "argument 1 must be a 5-bit signed literal"
#~ msgstr "1. a 5"

#, fuzzy
#~ msgid "argument 2 must be a 5-bit unsigned literal"
#~ msgstr "2. a 5 Bitashizweho umukono"

#, fuzzy
#~ msgid "argument 1 of __builtin_altivec_predicate must be a constant"
#~ msgstr "1. Bya a"

#, fuzzy
#~ msgid "argument 1 of __builtin_altivec_predicate is out of range"
#~ msgstr "1. Bya ni Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "argument 3 must be a 4-bit unsigned literal"
#~ msgstr "3. a 4. Bitashizweho umukono"

#, fuzzy
#~ msgid "argument to `%s' must be a 2-bit unsigned literal"
#~ msgstr "Kuri a 2. Bitashizweho umukono"

#, fuzzy
#~ msgid "argument to dss must be a 2-bit unsigned literal"
#~ msgstr "Kuri a 2. Bitashizweho umukono"

#, fuzzy
#~ msgid "argument 1 of __builtin_spe_predicate must be a constant"
#~ msgstr "1. Bya a"

#, fuzzy
#~ msgid "argument 1 of __builtin_spe_predicate is out of range"
#~ msgstr "1. Bya ni Inyuma Bya Urutonde"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%f value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%F value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%G value"
#~ msgstr "Agaciro siko"

#, fuzzy
#~ msgid "invalid %%j code"
#~ msgstr "Sibyo ITEGEKONGENGA"

#, fuzzy
#~ msgid "invalid %%J code"
#~ msgstr "Sibyo ITEGEKONGENGA"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%K value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%O value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%T value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%u value"
#~ msgstr "Agaciro siko"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_VALID_DEFERROR.text
#, fuzzy
#~ msgid "invalid %%v value"
#~ msgstr "Agaciro siko"

#, fuzzy
#~ msgid "no profiling of 64-bit code for this ABI"
#~ msgstr "Oya Bya ITEGEKONGENGA kugirango iyi"

#, fuzzy
#~ msgid "Always pass floating-point arguments in memory"
#~ msgstr "Bihindagurika Akadomo ingingo in Ububiko"

#, fuzzy
#~ msgid "Don't always pass floating-point arguments in memory"
#~ msgstr "Buri gihe Bihindagurika Akadomo ingingo in Ububiko"

#, fuzzy
#~ msgid "Support message passing with the Parallel Environment"
#~ msgstr "Ubutumwa Na: i"

#, fuzzy
#~ msgid "Compile for 64-bit pointers"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Compile for 32-bit pointers"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "-maix64 and POWER architecture are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "-maix64 requires PowerPC64 architecture remain enabled"
#~ msgstr "-Bikora"

#, fuzzy
#~ msgid "-maix64 required: 64-bit computation with 32-bit addressing not yet supported"
#~ msgstr "-Bya ngombwa Na: Kwohereza OYA"

#, fuzzy
#~ msgid "Use POWER instruction set"
#~ msgstr "Gushyiraho"

#, fuzzy
#~ msgid "Use POWER2 instruction set"
#~ msgstr "Gushyiraho"

#, fuzzy
#~ msgid "Do not use POWER2 instruction set"
#~ msgstr "OYA Gukoresha Gushyiraho"

#, fuzzy
#~ msgid "Do not use POWER instruction set"
#~ msgstr "OYA Gukoresha Gushyiraho"

#, fuzzy
#~ msgid "Use PowerPC instruction set"
#~ msgstr "Gushyiraho"

#, fuzzy
#~ msgid "Do not use PowerPC instruction set"
#~ msgstr "OYA Gukoresha Gushyiraho"

#, fuzzy
#~ msgid "Use PowerPC General Purpose group optional instructions"
#~ msgstr "Itsinda Bitari ngombwa Amabwiriza"

#, fuzzy
#~ msgid "Don't use PowerPC General Purpose group optional instructions"
#~ msgstr "Gukoresha Itsinda Bitari ngombwa Amabwiriza"

#, fuzzy
#~ msgid "Use PowerPC Graphics group optional instructions"
#~ msgstr "Itsinda Bitari ngombwa Amabwiriza"

#, fuzzy
#~ msgid "Don't use PowerPC Graphics group optional instructions"
#~ msgstr "Gukoresha Itsinda Bitari ngombwa Amabwiriza"

#, fuzzy
#~ msgid "Use PowerPC-64 instruction set"
#~ msgstr "Gushyiraho"

#, fuzzy
#~ msgid "Don't use PowerPC-64 instruction set"
#~ msgstr "Gukoresha Gushyiraho"

#, fuzzy
#~ msgid "Use AltiVec instructions"
#~ msgstr "Amabwiriza"

#, fuzzy
#~ msgid "Don't use AltiVec instructions"
#~ msgstr "Gukoresha Amabwiriza"

#, fuzzy
#~ msgid "Use new mnemonics for PowerPC architecture"
#~ msgstr "Gishya kugirango"

#, fuzzy
#~ msgid "Use old mnemonics for PowerPC architecture"
#~ msgstr "ki/ bishaje kugirango"

#, fuzzy
#~ msgid "Put everything in the regular TOC"
#~ msgstr "in i Ibisanzwe"

#, fuzzy
#~ msgid "Place floating point constants in TOC"
#~ msgstr "Bihindagurika Akadomo in"

#, fuzzy
#~ msgid "Don't place floating point constants in TOC"
#~ msgstr "Bihindagurika Akadomo in"

#, fuzzy
#~ msgid "Place symbol+offset constants in TOC"
#~ msgstr "IKIMENYETSO Nta- boneza in"

#, fuzzy
#~ msgid "Don't place symbol+offset constants in TOC"
#~ msgstr "IKIMENYETSO Nta- boneza in"

#, fuzzy
#~ msgid "Place variable addresses in the regular TOC"
#~ msgstr "IMPINDURAGACIRO Amaderesi in i Ibisanzwe"

#, fuzzy
#~ msgid "Generate load/store multiple instructions"
#~ msgstr "Ibirimo Igikubo Amabwiriza"

#, fuzzy
#~ msgid "Do not generate load/store multiple instructions"
#~ msgstr "OYA Ibirimo Igikubo Amabwiriza"

#, fuzzy
#~ msgid "Generate string instructions for block moves"
#~ msgstr "Ikurikiranyanyuguti Amabwiriza kugirango Funga"

#, fuzzy
#~ msgid "Do not generate string instructions for block moves"
#~ msgstr "OYA Ikurikiranyanyuguti Amabwiriza kugirango Funga"

#, fuzzy
#~ msgid "Generate load/store with update instructions"
#~ msgstr "Ibirimo Na: Kuvugurura Amabwiriza"

#, fuzzy
#~ msgid "Do not generate load/store with update instructions"
#~ msgstr "OYA Ibirimo Na: Kuvugurura Amabwiriza"

#, fuzzy
#~ msgid "Don't schedule the start and end of the procedure"
#~ msgstr "Igenabihe i Gutangira Na Impera Bya i"

#, fuzzy
#~ msgid "Return all structures in memory (AIX default)"
#~ msgstr "Byose in Ububiko Mburabuzi"

#, fuzzy
#~ msgid "Return small structures in registers (SVR4 default)"
#~ msgstr "Gitoya in Mburabuzi"

#, fuzzy
#~ msgid "Use features of and schedule code for given CPU"
#~ msgstr "Ibiranga Bya Na Igenabihe ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Enable debug output"
#~ msgstr "Kosora amakosa Ibisohoka"

#, fuzzy
#~ msgid "Select full, part, or no traceback table"
#~ msgstr "Cyangwa Oya imbonerahamwe#"

#, fuzzy
#~ msgid "Specify ABI to use"
#~ msgstr "Kuri Gukoresha"

#, fuzzy
#~ msgid "Specify size of long double (64 or 128 bits)"
#~ msgstr "Ingano Bya MAHARAKUBIRI Cyangwa"

#, fuzzy
#~ msgid "Specify yes/no if isel instructions should be generated"
#~ msgstr "Yego Oya NIBA Amabwiriza"

#, fuzzy
#~ msgid "Specify yes/no if VRSAVE instructions should be generated for AltiVec"
#~ msgstr "Yego Oya NIBA Amabwiriza kugirango"

#, fuzzy
#~ msgid "Avoid all range limits on call instructions"
#~ msgstr "Byose Urutonde Imbibi ku Amabwiriza"

#, fuzzy
#~ msgid "RETURN_ADDRESS_OFFSET not supported"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Select method for sdata handling"
#~ msgstr "Uburyo kugirango"

#, fuzzy
#~ msgid "Align to the base type of the bit-field"
#~ msgstr "Kuri i SHINGIRO Ubwoko Bya i Umwanya"

#, fuzzy
#~ msgid "Don't align to the base type of the bit-field"
#~ msgstr "Gutondeka Kuri i SHINGIRO Ubwoko Bya i Umwanya"

#, fuzzy
#~ msgid "Don't assume that unaligned accesses are handled by the system"
#~ msgstr "ku i Sisitemu"

#, fuzzy
#~ msgid "Assume that unaligned accesses are handled by the system"
#~ msgstr "ku i Sisitemu"

#, fuzzy
#~ msgid "Produce code relocatable at runtime"
#~ msgstr "ITEGEKONGENGA ku"

#, fuzzy
#~ msgid "Don't produce code relocatable at runtime"
#~ msgstr "ITEGEKONGENGA ku"

#, fuzzy
#~ msgid "Produce little endian code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "Produce big endian code"
#~ msgstr "ITEGEKONGENGA"

#, fuzzy
#~ msgid "no description yet"
#~ msgstr "Oya Isobanuramiterere"

#, fuzzy
#~ msgid "Don't use EABI"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "Do not allow bit-fields to cross word boundaries"
#~ msgstr "OYA Kwemerera Imyanya Kuri Kwambukiranya ijambo"

#, fuzzy
#~ msgid "Use alternate register names"
#~ msgstr "Kwiyandikisha Amazina"

#, fuzzy
#~ msgid "Don't use alternate register names"
#~ msgstr "Gukoresha Kwiyandikisha Amazina"

#, fuzzy
#~ msgid "Link with libsim.a, libc.a and sim-crt0.o"
#~ msgstr "Na: a a Na o"

#, fuzzy
#~ msgid "Link with libads.a, libc.a and crt0.o"
#~ msgstr "Na: a a Na o"

#, fuzzy
#~ msgid "Link with libyk.a, libc.a and crt0.o"
#~ msgstr "Na: a a Na o"

#, fuzzy
#~ msgid "Link with libmvme.a, libc.a and crt0.o"
#~ msgstr "Na: a a Na o"

#, fuzzy
#~ msgid "Set the PPC_EMB bit in the ELF flags header"
#~ msgstr "i in i Amabendera Umutwempangano"

#, fuzzy
#~ msgid "Use the WindISS simulator"
#~ msgstr "i"

#, fuzzy
#~ msgid "bad value for -mcall-%s"
#~ msgstr "Agaciro kugirango"

#, fuzzy
#~ msgid "bad value for -msdata=%s"
#~ msgstr "Agaciro kugirango"

#, fuzzy
#~ msgid "-mrelocatable and -msdata=%s are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "-f%s and -msdata=%s are incompatible"
#~ msgstr "-F Na"

#, fuzzy
#~ msgid "-msdata=%s and -mcall-%s are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "-mrelocatable and -mno-minimal-toc are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "-mrelocatable and -mcall-%s are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "-fPIC and -mcall-%s are incompatible"
#~ msgstr "-Na"

#, fuzzy
#~ msgid "invalid UNSPEC as operand (1)"
#~ msgstr "Sibyo Nka 1."

#, fuzzy
#~ msgid "invalid UNSPEC as operand (2)"
#~ msgstr "Sibyo Nka 2."

#, fuzzy
#~ msgid "UNKNOWN in s390_output_symbolic_const !?"
#~ msgstr "in"

#, fuzzy
#~ msgid "Cannot decompose address."
#~ msgstr "Aderesi"

#, fuzzy
#~ msgid "UNKNOWN in print_operand !?"
#~ msgstr "in"

#, fuzzy
#~ msgid "Total size of local variables exceeds architecture limit."
#~ msgstr "Ingano Bya Ibihinduka"

#, fuzzy
#~ msgid "Don't set backchain (faster, but debug harder"
#~ msgstr "Gushyiraho Kosora amakosa"

#, fuzzy
#~ msgid "Use bras for executable < 64k"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Don't use bras"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "Additional debug prints"
#~ msgstr "Kosora amakosa"

#, fuzzy
#~ msgid "Don't print additional debug prints"
#~ msgstr "Gucapa Kosora amakosa"

#, fuzzy
#~ msgid "64 bit mode"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "31 bit mode"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "mvcle use"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "__builtin_saveregs not supported by this subtarget"
#~ msgstr "_OYA ku iyi"

#, fuzzy
#~ msgid "attribute interrupt_handler is not compatible with -m5-compact"
#~ msgstr "Ikiranga ni OYA Na:"

#, fuzzy
#~ msgid "`%s' attribute only applies to interrupt functions"
#~ msgstr "`%s'Ikiranga Kuri Hagarikira aho Imimaro"

#, fuzzy
#~ msgid "`%s' attribute argument not a string constant"
#~ msgstr "`%s'Ikiranga OYA a Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "`%s' attribute argument not an integer constant"
#~ msgstr "`%s'Ikiranga OYA Umubare wuzuye"

#, fuzzy
#~ msgid "Profiling is not supported on this target."
#~ msgstr "ni OYA ku iyi Intego"

#, fuzzy
#~ msgid "%s is not supported by this configuration"
#~ msgstr "%sni OYA ku iyi Iboneza"

#, fuzzy
#~ msgid "-mlong-double-64 not allowed with -m64"
#~ msgstr "-MAHARAKUBIRI OYA Na:"

#, fuzzy
#~ msgid "-mcmodel= is not supported on 32 bit systems"
#~ msgstr "-ni OYA ku"

#, fuzzy
#~ msgid "invalid %%Y operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%A operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%B operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%c operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%C operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%d operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%D operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%f operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid %%s operand"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "long long constant not a valid immediate operand"
#~ msgstr "OYA a Byemewe"

#, fuzzy
#~ msgid "floating point constant not a valid immediate operand"
#~ msgstr "Bihindagurika Akadomo OYA a Byemewe"

#, fuzzy
#~ msgid "Generate code for big endian"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for little endian"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Use little-endian byte order for data"
#~ msgstr "Bayite Itondekanya kugirango Ibyatanzwe"

#, fuzzy
#~ msgid "Assume possible double misalignment"
#~ msgstr "MAHARAKUBIRI"

#, fuzzy
#~ msgid "Assume all doubles are aligned"
#~ msgstr "Byose"

#, fuzzy
#~ msgid "Pass -assert pure-text to linker"
#~ msgstr "Umwandiko Kuri"

#, fuzzy
#~ msgid "Do not pass -assert pure-text to linker"
#~ msgstr "OYA Umwandiko Kuri"

#, fuzzy
#~ msgid "Use flat register window model"
#~ msgstr "Kirambuye Kwiyandikisha Idirishya Urugero"

#, fuzzy
#~ msgid "Do not use flat register window model"
#~ msgstr "OYA Gukoresha Kirambuye Kwiyandikisha Idirishya Urugero"

#, fuzzy
#~ msgid "Do not use ABI reserved registers"
#~ msgstr "OYA Gukoresha"

#, fuzzy
#~ msgid "Use hardware quad fp instructions"
#~ msgstr "Amabwiriza"

#, fuzzy
#~ msgid "Do not use hardware quad fp instructions"
#~ msgstr "OYA Gukoresha Amabwiriza"

#, fuzzy
#~ msgid "Compile for v8plus ABI"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Do not compile for v8plus ABI"
#~ msgstr "OYA Gukusanya kugirango"

#, fuzzy
#~ msgid "Do not utilize Visual Instruction Set"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "Optimize for Cypress processors"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Optimize for SPARCLite processors"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Optimize for F930 processors"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Optimize for F934 processors"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Optimize for SuperSPARC processors"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Do not use stack bias"
#~ msgstr "OYA Gukoresha"

#, fuzzy
#~ msgid "Use structs on stronger alignment for double-word copies"
#~ msgstr "ku Itunganya kugirango MAHARAKUBIRI ijambo Amakopi"

#, fuzzy
#~ msgid "Do not use structs on stronger alignment for double-word copies"
#~ msgstr "OYA Gukoresha ku Itunganya kugirango MAHARAKUBIRI ijambo Amakopi"

#, fuzzy
#~ msgid "Optimize tail call instructions in assembler and linker"
#~ msgstr "Amabwiriza in Na"

#, fuzzy
#~ msgid "Do not optimize tail call instructions in assembler or linker"
#~ msgstr "OYA Kugeza ku ndunduro Amabwiriza in Cyangwa"

#, fuzzy
#~ msgid "Use given SPARC code model"
#~ msgstr "ITEGEKONGENGA Urugero"

#, fuzzy
#~ msgid "cannot use va_start in interrupt function"
#~ msgstr "Gukoresha in Hagarikira aho Umumaro"

#, fuzzy
#~ msgid "`B' operand is not constant"
#~ msgstr "`ni OYA"

#, fuzzy
#~ msgid "`B' operand has multiple bits set"
#~ msgstr "`Igikubo Gushyiraho"

#, fuzzy
#~ msgid "`o' operand is not constant"
#~ msgstr "`ni OYA"

#, fuzzy
#~ msgid "xstormy16_print_operand: unknown code"
#~ msgstr "Kitazwi ITEGEKONGENGA"

#, fuzzy
#~ msgid "switch statement of size %lu entries too large"
#~ msgstr "Hindura Inyandiko Bya Ingano Ibyinjijwe Binini"

#, fuzzy
#~ msgid "#pragma GHS endXXXX found without previous startXXX"
#~ msgstr "#Byabonetse Ibanjirije"

#, fuzzy
#~ msgid "#pragma GHS endXXX does not match previous startXXX"
#~ msgstr "#OYA BIHUYE Ibanjirije"

#, fuzzy
#~ msgid "cannot set interrupt attribute: no current function"
#~ msgstr "Gushyiraho Hagarikira aho Ikiranga Oya KIGEZWEHO Umumaro"

#, fuzzy
#~ msgid "cannot set interrupt attribute: no such identifier"
#~ msgstr "Gushyiraho Hagarikira aho Ikiranga Oya Ikiranga"

#, fuzzy
#~ msgid "junk at end of #pragma ghs section"
#~ msgstr "Umwanda ku Impera Bya Icyiciro"

#, fuzzy
#~ msgid "unrecognized section name \"%s\""
#~ msgstr "Icyiciro Izina:"

#, fuzzy
#~ msgid "malformed #pragma ghs section"
#~ msgstr "Icyiciro"

#, fuzzy
#~ msgid "junk at end of #pragma ghs interrupt"
#~ msgstr "Umwanda ku Impera Bya Hagarikira aho"

#, fuzzy
#~ msgid "junk at end of #pragma ghs starttda"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "junk at end of #pragma ghs startsda"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "junk at end of #pragma ghs startzda"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "junk at end of #pragma ghs endtda"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "junk at end of #pragma ghs endsda"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "junk at end of #pragma ghs endzda"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "%s=%s is not numeric"
#~ msgstr "%s=%sni OYA Bikurikije umubare"

#, fuzzy
#~ msgid "%s=%s is too large"
#~ msgstr "%s=%sni Binini"

#, fuzzy
#~ msgid "const_double_split got a bad insn:"
#~ msgstr "a"

#, fuzzy
#~ msgid "a data area attribute cannot be specified for local variables"
#~ msgstr "a Ibyatanzwe Ubuso Ikiranga kugirango Ibihinduka"

#, fuzzy
#~ msgid "data area of '%s' conflicts with previous declaration"
#~ msgstr "Ibyatanzwe Ubuso Bya Na: Ibanjirije"

#, fuzzy
#~ msgid "bad amount of stack space removal: %d"
#~ msgstr "Igiteranyo Bya Umwanya"

#, fuzzy
#~ msgid "Too much stack space to dispose of: %d"
#~ msgstr "Umwanya Kuri Bya"

#, fuzzy
#~ msgid "Too much stack space to prepare: %d"
#~ msgstr "Umwanya Kuri"

#, fuzzy
#~ msgid "Prohibit PC relative function calls"
#~ msgstr "Bifitanye isano Umumaro Amahamagara:"

#, fuzzy
#~ msgid "Reuse r30 on a per function basis"
#~ msgstr "ku a Umumaro Ishingiro"

#, fuzzy
#~ msgid "Use stubs for function prologues"
#~ msgstr "kugirango Umumaro"

#, fuzzy
#~ msgid "Same as: -mep -mprolog-function"
#~ msgstr "Nka Umumaro"

#, fuzzy
#~ msgid "Compile for the v850 processor"
#~ msgstr "kugirango i"

#, fuzzy
#~ msgid "Compile for v850e processor"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "Enable the use of the short load instructions"
#~ msgstr "i Gukoresha Bya i Ibirimo Amabwiriza"

#, fuzzy
#~ msgid "Do not use the callt instruction"
#~ msgstr "OYA Gukoresha i"

#, fuzzy
#~ msgid "Do not use registers r2 and r5"
#~ msgstr "OYA Gukoresha Na"

#, fuzzy
#~ msgid "Enforce strict alignment"
#~ msgstr "Itunganya"

#, fuzzy
#~ msgid "Use 4 byte entries in switch tables"
#~ msgstr "4. Bayite Ibyinjijwe in Hindura Imbonerahamwe"

#, fuzzy
#~ msgid "Set the max size of data eligible for the TDA area"
#~ msgstr "i KININI Ingano Bya Ibyatanzwe kugirango i Ubuso"

#, fuzzy
#~ msgid "Set the max size of data eligible for the SDA area"
#~ msgstr "i KININI Ingano Bya Ibyatanzwe kugirango i Ubuso"

#, fuzzy
#~ msgid "Set the max size of data eligible for the ZDA area"
#~ msgstr "i KININI Ingano Bya Ibyatanzwe kugirango i Ubuso"

#, fuzzy
#~ msgid "bad test"
#~ msgstr "Igerageza"

#, fuzzy
#~ msgid "boolean registers required for the floating-point option"
#~ msgstr "Icyungo Bya ngombwa kugirango i Bihindagurika Akadomo Ihitamo"

#, fuzzy
#~ msgid "invalid mask"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "invalid address"
#~ msgstr "Sibyo Aderesi"

#, fuzzy
#~ msgid "no register in address"
#~ msgstr "Oya Kwiyandikisha in Aderesi"

#, fuzzy
#~ msgid "address offset not a constant"
#~ msgstr "Aderesi Nta- boneza OYA a"

#, fuzzy
#~ msgid "only uninitialized variables can be placed in a .bss section"
#~ msgstr "Itatangijwe Ibihinduka in a Icyiciro"

#, fuzzy
#~ msgid "Use the Xtensa code density option"
#~ msgstr "i ITEGEKONGENGA Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa code density option"
#~ msgstr "OYA Gukoresha i ITEGEKONGENGA Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa MAC16 option"
#~ msgstr "i Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa MAC16 option"
#~ msgstr "OYA Gukoresha i Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa MUL16 option"
#~ msgstr "i Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa MUL16 option"
#~ msgstr "OYA Gukoresha i Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa MUL32 option"
#~ msgstr "i Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa MUL32 option"
#~ msgstr "OYA Gukoresha i Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa NSA option"
#~ msgstr "i Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa NSA option"
#~ msgstr "OYA Gukoresha i Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa MIN/MAX option"
#~ msgstr "i Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa MIN/MAX option"
#~ msgstr "OYA Gukoresha i Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa SEXT option"
#~ msgstr "i Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa SEXT option"
#~ msgstr "OYA Gukoresha i Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa boolean register option"
#~ msgstr "i Icyungo Kwiyandikisha Ihitamo"

#, fuzzy
#~ msgid "Do not use the Xtensa boolean register option"
#~ msgstr "OYA Gukoresha i Icyungo Kwiyandikisha Ihitamo"

#, fuzzy
#~ msgid "Use the Xtensa floating-point unit"
#~ msgstr "i Bihindagurika Akadomo Igice:"

#, fuzzy
#~ msgid "Do not use the Xtensa floating-point unit"
#~ msgstr "OYA Gukoresha i Bihindagurika Akadomo Igice:"

#, fuzzy
#~ msgid "Disable fused multiply/add and multiply/subtract FP instructions"
#~ msgstr "Gukuba Kongeramo Na Gukuba Gukuramo Amabwiriza"

#, fuzzy
#~ msgid "Enable fused multiply/add and multiply/subtract FP instructions"
#~ msgstr "Gukuba Kongeramo Na Gukuba Gukuramo Amabwiriza"

#, fuzzy
#~ msgid "Serialize volatile memory references with MEMW instructions"
#~ msgstr "Ububiko Indango Na: Amabwiriza"

#, fuzzy
#~ msgid "Do not serialize volatile memory references with MEMW instructions"
#~ msgstr "OYA Ububiko Indango Na: Amabwiriza"

#, fuzzy
#~ msgid "Intersperse literal pools with code in the text section"
#~ msgstr "Na: ITEGEKONGENGA in i Umwandiko Icyiciro"

#, fuzzy
#~ msgid "Put literal pools in a separate literal section"
#~ msgstr "in a Icyiciro"

#, fuzzy
#~ msgid "Automatically align branch targets to reduce branch penalties"
#~ msgstr "Gutondeka Kuri"

#, fuzzy
#~ msgid "Do not automatically align branch targets"
#~ msgstr "OYA ku buryo bwikora Gutondeka"

#, fuzzy
#~ msgid "Use indirect CALLXn instructions for large programs"
#~ msgstr "BUZIGUYE Amabwiriza kugirango Binini Porogaramu"

#, fuzzy
#~ msgid "Use direct CALLn instructions for fast calls"
#~ msgstr "Amabwiriza kugirango Byihuta Amahamagara:"

#, fuzzy
#~ msgid "`-gnat' misspelled as `-gant'"
#~ msgstr "`-Nka"

#, fuzzy
#~ msgid "qualified type `%T' does not match destructor name `~%T'"
#~ msgstr "Ubwoko OYA BIHUYE Izina:"

#, fuzzy
#~ msgid "type of `%E' does not match destructor type `%T' (type was `%T')"
#~ msgstr "Ubwoko Bya OYA BIHUYE Ubwoko Ubwoko"

#, fuzzy
#~ msgid "`%D' is a namespace"
#~ msgstr "`%D'ni a"

#, fuzzy
#~ msgid "base object `%E' of scoped method call is of non-aggregate type `%T'"
#~ msgstr "SHINGIRO Igikoresho Bya Uburyo ni Bya Ubwoko"

#, fuzzy
#~ msgid "unable to call pointer to member function here"
#~ msgstr "Kuri Mweretsi Kuri Umumaro"

#, fuzzy
#~ msgid "destructors take no parameters"
#~ msgstr "Oya Ibigenga"

#, fuzzy
#~ msgid "destructor name `~%T' does not match type `%T' of expression"
#~ msgstr "Izina: OYA BIHUYE Ubwoko Bya imvugo"

#, fuzzy
#~ msgid "request for member `%D' in `%E', which is of non-aggregate type `%T'"
#~ msgstr "Kubaza... kugirango in ni Bya Ubwoko"

#, fuzzy
#~ msgid "request for member `%D' is ambiguous"
#~ msgstr "Kubaza... kugirango ni"

#, fuzzy
#~ msgid "%s %D(%T, %T, %T) <built-in>"
#~ msgstr "%s%D(%T,%T,%T)<in"

#, fuzzy
#~ msgid "%s %D(%T, %T) <built-in>"
#~ msgstr "%s%D(%T,%T)<in"

#, fuzzy
#~ msgid "%s %D(%T) <built-in>"
#~ msgstr "%s%D(%T)<in"

#, fuzzy
#~ msgid "%s %T <conversion>"
#~ msgstr "%s%T<Ihindurangero"

# desktop/source\app\ssodlg.src:DLG_SSOLOGIN.text
#, fuzzy
#~ msgid "%s %+#D%s"
#~ msgstr "%s%+#D%s"

#, fuzzy
#~ msgid "incomplete type '%T' cannot be used to name a scope"
#~ msgstr "Ubwoko Kuri Izina: a Ingano:"

#, fuzzy
#~ msgid "'%D' has no member named '%E'"
#~ msgstr "'%D'Oya"

#, fuzzy
#~ msgid "no matching function for call to `%D(%A)'"
#~ msgstr "Oya Umumaro kugirango Kuri"

#, fuzzy
#~ msgid "call of overloaded `%D(%A)' is ambiguous"
#~ msgstr "Bya ni"

#, fuzzy
#~ msgid "pointer-to-member function %E cannot be called without an object; consider using .* or ->*"
#~ msgstr "Mweretsi Kuri Umumaro Igikoresho ikoresha Cyangwa"

#, fuzzy
#~ msgid "no match for call to `(%T) (%A)'"
#~ msgstr "Oya BIHUYE kugirango Kuri"

#, fuzzy
#~ msgid "call of `(%T) (%A)' is ambiguous"
#~ msgstr "Bya ni"

#, fuzzy
#~ msgid "%s for `%T ? %T : %T' operator"
#~ msgstr "%skugirango."

#, fuzzy
#~ msgid "%s for `%T %s' operator"
#~ msgstr "%skugirango Mukoresha"

#, fuzzy
#~ msgid "%s for `%T [%T]' operator"
#~ msgstr "%skugirango Mukoresha"

#, fuzzy
#~ msgid "%s for `%T %s %T' operator"
#~ msgstr "%skugirango Mukoresha"

#, fuzzy
#~ msgid "%s for `%s %T' operator"
#~ msgstr "%skugirango Mukoresha"

#, fuzzy
#~ msgid "ISO C++ forbids omitting the middle term of a ?: expression"
#~ msgstr "C i Hagati Ijambo Bya a imvugo"

#, fuzzy
#~ msgid "`%E' has type `void' and is not a throw-expression"
#~ msgstr "`%E'Ubwoko Na ni OYA a imvugo"

#, fuzzy
#~ msgid "operands to ?: have different types"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "enumeral mismatch in conditional expression: `%T' vs `%T'"
#~ msgstr "in imvugo"

#, fuzzy
#~ msgid "enumeral and non-enumeral type in conditional expression"
#~ msgstr "Na Ubwoko in imvugo"

#, fuzzy
#~ msgid "`%D' must be declared before use"
#~ msgstr "`%D'Mbere Gukoresha"

#, fuzzy
#~ msgid "no `%D(int)' declared for postfix `%s', trying prefix operator instead"
#~ msgstr "Oya INT kugirango Imbanziriza Mukoresha"

#, fuzzy
#~ msgid "using synthesized `%#D' for copy assignment"
#~ msgstr "ikoresha kugirango Gukoporora Igenera"

#, fuzzy
#~ msgid "  where cfront would use `%#D'"
#~ msgstr "Gukoresha"

#, fuzzy
#~ msgid "comparison between `%#T' and `%#T'"
#~ msgstr "hagati Na"

#, fuzzy
#~ msgid "no suitable `operator delete' for `%T'"
#~ msgstr "Oya Mukoresha kugirango"

#, fuzzy
#~ msgid "`%+#D' is private"
#~ msgstr "`%+#D'ni By'umwihariko"

#, fuzzy
#~ msgid "`%+#D' is protected"
#~ msgstr "`%+#D'ni Birinzwe"

#, fuzzy
#~ msgid "`%+#D' is inaccessible"
#~ msgstr "`%+#D'ni"

#, fuzzy
#~ msgid "within this context"
#~ msgstr "muri iyi Imvugiro"

#, fuzzy
#~ msgid "invalid conversion from `%T' to `%T'"
#~ msgstr "Sibyo Ihindurangero Bivuye Kuri"

#, fuzzy
#~ msgid "  initializing argument %P of `%D'"
#~ msgstr "Gutangiza Bya"

#, fuzzy
#~ msgid "  initializing argument %P of `%D' from result of `%D'"
#~ msgstr "Gutangiza Bya Bivuye Igisubizo Bya"

#, fuzzy
#~ msgid "  initializing temporary from result of `%D'"
#~ msgstr "Gutangiza By'igihe gito Bivuye Igisubizo Bya"

#, fuzzy
#~ msgid "cannot pass objects of non-POD type `%#T' through `...'; call will abort at runtime"
#~ msgstr "Ibintu Bya Ubwoko Gihinguranya Kureka ku"

#, fuzzy
#~ msgid "cannot receive objects of non-POD type `%#T' through `...'"
#~ msgstr "Akira Ibintu Bya Ubwoko Gihinguranya"

#, fuzzy
#~ msgid "passing `%T' as `this' argument of `%#D' discards qualifiers"
#~ msgstr "Nka Bya"

#, fuzzy
#~ msgid "could not find class$ field in java interface type `%T'"
#~ msgstr "OYA Gushaka ishuri Umwanya in java Ubwoko"

#, fuzzy
#~ msgid "call to non-function `%D'"
#~ msgstr "Kuri Umumaro"

#, fuzzy
#~ msgid "no matching function for call to `%T::%D(%A)%#V'"
#~ msgstr "Oya Umumaro kugirango Kuri"

#, fuzzy
#~ msgid "cannot call member function `%D' without object"
#~ msgstr "Umumaro Igikoresho"

#, fuzzy
#~ msgid "passing `%T' chooses `%T' over `%T'"
#~ msgstr "KURI"

#, fuzzy
#~ msgid "  in call to `%D'"
#~ msgstr "in Kuri"

#, fuzzy
#~ msgid "choosing `%D' over `%D'"
#~ msgstr "KURI"

#, fuzzy
#~ msgid "  for conversion from `%T' to `%T'"
#~ msgstr "kugirango Ihindurangero Bivuye Kuri"

#, fuzzy
#~ msgid "  because conversion sequence for the argument is better"
#~ msgstr "Ihindurangero kugirango i ni"

#, fuzzy
#~ msgid "ISO C++ says that `%D' and `%D' are ambiguous even though the worst conversion for the former is better than the worst conversion for the latter"
#~ msgstr "C Na ATARIIGIHARWE i Ihindurangero kugirango i ni i Ihindurangero kugirango i"

#, fuzzy
#~ msgid "cannot convert from base `%T' to derived type `%T' via virtual base `%T'"
#~ msgstr "GUHINDURA Bivuye SHINGIRO Kuri Ubwoko Biturutse Kitaboneka SHINGIRO"

#, fuzzy
#~ msgid "`%#D' and `%#D' cannot be overloaded"
#~ msgstr "`%#D'Na"

#, fuzzy
#~ msgid "duplicate enum value `%D'"
#~ msgstr "Gusubiramo Agaciro"

#, fuzzy
#~ msgid "duplicate field `%D' (as enum and non-enum)"
#~ msgstr "Gusubiramo Umwanya Nka Na"

#, fuzzy
#~ msgid "duplicate nested type `%D'"
#~ msgstr "Gusubiramo Ubwoko"

#, fuzzy
#~ msgid "duplicate field `%D' (as type and non-type)"
#~ msgstr "Gusubiramo Umwanya Nka Ubwoko Na Ubwoko"

#, fuzzy
#~ msgid "duplicate member `%D'"
#~ msgstr "Gusubiramo"

#, fuzzy
#~ msgid "conflicting access specifications for method `%D', ignored"
#~ msgstr "kugirango Uburyo"

#, fuzzy
#~ msgid "conflicting access specifications for field `%s', ignored"
#~ msgstr "kugirango Umwanya"

#, fuzzy
#~ msgid "`%D' names constructor"
#~ msgstr "`%D'Amazina"

#, fuzzy
#~ msgid "`%D' invalid in `%T'"
#~ msgstr "`%D'Sibyo in"

#, fuzzy
#~ msgid "no members matching `%D' in `%#T'"
#~ msgstr "Oya in"

#, fuzzy
#~ msgid "`%D' invalid in `%#T'"
#~ msgstr "`%D'Sibyo in"

#, fuzzy
#~ msgid "  because of local method `%#D' with same name"
#~ msgstr "Bya Uburyo Na: Izina:"

#, fuzzy
#~ msgid "  because of local member `%#D' with same name"
#~ msgstr "Bya Na: Izina:"

#, fuzzy
#~ msgid "base class `%#T' has a non-virtual destructor"
#~ msgstr "SHINGIRO ishuri a Kitaboneka"

#, fuzzy
#~ msgid "base `%T' with only non-default constructor in class without a constructor"
#~ msgstr "SHINGIRO Na: Mburabuzi in ishuri a"

#, fuzzy
#~ msgid "all member functions in class `%T' are private"
#~ msgstr "Byose Imimaro in ishuri By'umwihariko"

#, fuzzy
#~ msgid "`%#T' only defines a private destructor and has no friends"
#~ msgstr "`%#T'a By'umwihariko Na Oya"

#, fuzzy
#~ msgid "`%#T' only defines private constructors and has no friends"
#~ msgstr "`%#T'By'umwihariko Na Oya"

#, fuzzy
#~ msgid "redefinition of `%#T'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "previous definition of `%#T'"
#~ msgstr "Ibanjirije Insobanuro Bya"

#, fuzzy
#~ msgid "no unique final overrider for `%D' in `%T'"
#~ msgstr "Oya Cyo nyine kugirango in"

#, fuzzy
#~ msgid "`%D' was hidden"
#~ msgstr "`%D'gihishwe"

# sc/source\ui\src\globstr.src:RID_GLOBSTR.STR_BY.text
#, fuzzy
#~ msgid "  by `%D'"
#~ msgstr "ku"

#, fuzzy
#~ msgid "ISO C++ forbids member `%D' with same name as enclosing class"
#~ msgstr "C Na: Izina: Nka ishuri"

#, fuzzy
#~ msgid "`%#D' invalid; an anonymous union can only have non-static data members"
#~ msgstr "`%#D'Sibyo Ihuza Ibyatanzwe"

#, fuzzy
#~ msgid "private member `%#D' in anonymous union"
#~ msgstr "By'umwihariko in Ihuza"

#, fuzzy
#~ msgid "protected member `%#D' in anonymous union"
#~ msgstr "Birinzwe in Ihuza"

#, fuzzy
#~ msgid "vtable layout for class `%T' may not be ABI-compliant and may change in a future version of GCC due to implicit virtual destructor"
#~ msgstr "Imigaragarire kugirango ishuri Gicurasi OYA Na Gicurasi Guhindura>> in a Verisiyo Bya Kuri Kitaboneka"

#, fuzzy
#~ msgid "bit-field `%#D' with non-integral type"
#~ msgstr "Umwanya Na: Umubare Wuzuye Ubwoko"

#, fuzzy
#~ msgid "bit-field `%D' width not an integer constant"
#~ msgstr "Umwanya Ubugari OYA Umubare wuzuye"

#, fuzzy
#~ msgid "negative width in bit-field `%D'"
#~ msgstr "Ubugari in Umwanya"

#, fuzzy
#~ msgid "zero width for bit-field `%D'"
#~ msgstr "Zeru Ubugari kugirango Umwanya"

#, fuzzy
#~ msgid "width of `%D' exceeds its type"
#~ msgstr "Ubugari Bya Ubwoko"

#, fuzzy
#~ msgid "`%D' is too small to hold all values of `%#T'"
#~ msgstr "`%D'ni Gitoya Kuri Byose Uduciro Bya"

#, fuzzy
#~ msgid "member `%#D' with constructor not allowed in union"
#~ msgstr "Na: OYA in Ihuza"

#, fuzzy
#~ msgid "member `%#D' with destructor not allowed in union"
#~ msgstr "Na: OYA in Ihuza"

#, fuzzy
#~ msgid "member `%#D' with copy assignment operator not allowed in union"
#~ msgstr "Na: Gukoporora Igenera Mukoresha OYA in Ihuza"

#, fuzzy
#~ msgid "multiple fields in union `%T' initialized"
#~ msgstr "Igikubo Imyanya in Ihuza"

#, fuzzy
#~ msgid "field `%D' in local class cannot be static"
#~ msgstr "Umwanya in ishuri"

#, fuzzy
#~ msgid "field `%D' invalidly declared function type"
#~ msgstr "Umwanya Umumaro Ubwoko"

#, fuzzy
#~ msgid "field `%D' invalidly declared method type"
#~ msgstr "Umwanya Uburyo Ubwoko"

#, fuzzy
#~ msgid "field `%D' invalidly declared offset type"
#~ msgstr "Umwanya Nta- boneza Ubwoko"

#, fuzzy
#~ msgid "field `%D' declared static in union"
#~ msgstr "Umwanya in Ihuza"

#, fuzzy
#~ msgid "non-static reference `%#D' in class without a constructor"
#~ msgstr "Indango in ishuri a"

#, fuzzy
#~ msgid "non-static const member `%#D' in class without a constructor"
#~ msgstr "in ishuri a"

#, fuzzy
#~ msgid "field `%#D' with same name as class"
#~ msgstr "Umwanya Na: Izina: Nka ishuri"

#, fuzzy
#~ msgid "`%#T' has pointer data members"
#~ msgstr "`%#T'Mweretsi Ibyatanzwe"

#, fuzzy
#~ msgid "  but does not override `%T(const %T&)'"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "  or `operator=(const %T&)'"
#~ msgstr "Cyangwa Mukoresha"

#, fuzzy
#~ msgid "  but does not override `operator=(const %T&)'"
#~ msgstr "OYA Mukoresha"

#, fuzzy
#~ msgid "offset of empty base `%T' may not be ABI-compliant and maychange in a future version of GCC"
#~ msgstr "Nta- boneza Bya ubusa SHINGIRO Gicurasi OYA Na in a Verisiyo Bya"

#, fuzzy
#~ msgid "class `%T' will be considered nearly empty in a future version of GCC"
#~ msgstr "ishuri ubusa in a Verisiyo Bya"

#, fuzzy
#~ msgid "initializer specified for non-virtual method `%D'"
#~ msgstr "kugirango Kitaboneka Uburyo"

#, fuzzy
#~ msgid "offset of virtual base `%T' is not ABI-compliant and may change in a future version of GCC"
#~ msgstr "Nta- boneza Bya Kitaboneka SHINGIRO ni OYA Na Gicurasi Guhindura>> in a Verisiyo Bya"

#, fuzzy
#~ msgid "direct base `%T' inaccessible in `%T' due to ambiguity"
#~ msgstr "SHINGIRO in Kuri"

#, fuzzy
#~ msgid "virtual base `%T' inaccessible in `%T' due to ambiguity"
#~ msgstr "Kitaboneka SHINGIRO in Kuri"

#, fuzzy
#~ msgid "size assigned to `%T' may not be ABI-compliant and may change in a future version of GCC"
#~ msgstr "Ingano Kuri Gicurasi OYA Na Gicurasi Guhindura>> in a Verisiyo Bya"

#, fuzzy
#~ msgid "offset of `%D' is not ABI-compliant and may change in a future version of GCC"
#~ msgstr "Nta- boneza Bya ni OYA Na Gicurasi Guhindura>> in a Verisiyo Bya"

#, fuzzy
#~ msgid "`%D' contains empty classes which may cause base classes to be placed at different locations in a future version of GCC"
#~ msgstr "`%D'Kirimo ubusa Inzego Gicurasi SHINGIRO Inzego Kuri ku in a Verisiyo Bya"

#, fuzzy
#~ msgid "layout of classes derived from empty class `%T' may change in a future version of GCC"
#~ msgstr "Imigaragarire Bya Inzego Bivuye ubusa ishuri Gicurasi Guhindura>> in a Verisiyo Bya"

#, fuzzy
#~ msgid "`%#T' has virtual functions but non-virtual destructor"
#~ msgstr "`%#T'Kitaboneka Imimaro Kitaboneka"

#, fuzzy
#~ msgid "trying to finish struct, but kicked out due to previous parse errors"
#~ msgstr "Kuri Kurangiza Inyuma Kuri Ibanjirije Amakosa"

#, fuzzy
#~ msgid "language string `\"%s\"' not recognized"
#~ msgstr "Ururimi Ikurikiranyanyuguti OYA"

#, fuzzy
#~ msgid "cannot resolve overloaded function `%D' based on conversion to type `%T'"
#~ msgstr "Umumaro ku Ihindurangero Kuri Ubwoko"

#, fuzzy
#~ msgid "no matches converting function `%D' to type `%#T'"
#~ msgstr "Oya Guhindura.... Umumaro Kuri Ubwoko"

#, fuzzy
#~ msgid "converting overloaded function `%D' to type `%#T' is ambiguous"
#~ msgstr "Guhindura.... Umumaro Kuri Ubwoko ni"

#, fuzzy
#~ msgid "assuming pointer to member `%D'"
#~ msgstr "Mweretsi Kuri"

#, fuzzy
#~ msgid "(a pointer to member can only be formed with `&%E')"
#~ msgstr "(a Mweretsi Kuri Na:"

#, fuzzy
#~ msgid "not enough type information"
#~ msgstr "OYA Ubwoko Ibisobanuro"

#, fuzzy
#~ msgid "argument of type `%T' does not match `%T'"
#~ msgstr "Bya Ubwoko OYA BIHUYE"

#, fuzzy
#~ msgid "invalid operation on uninstantiated type"
#~ msgstr "Sibyo ku Ubwoko"

#, fuzzy
#~ msgid "declaration of `%#D'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "changes meaning of `%D' from `%+#D'"
#~ msgstr "Amahinduka Igisobanuro Bya Bivuye"

#, fuzzy
#~ msgid "can't convert from incomplete type `%T' to `%T'"
#~ msgstr "GUHINDURA Bivuye Ubwoko Kuri"

#, fuzzy
#~ msgid "conversion of `%E' from `%T' to `%T' is ambiguous"
#~ msgstr "Ihindurangero Bya Bivuye Kuri ni"

#, fuzzy
#~ msgid "converting from `%T' to `%T'"
#~ msgstr "Guhindura.... Bivuye Kuri"

#, fuzzy
#~ msgid "pointer to member cast from `%T' to `%T' is via virtual base"
#~ msgstr "Mweretsi Kuri Bivuye Kuri ni Biturutse Kitaboneka SHINGIRO"

#, fuzzy
#~ msgid "cannot convert `%E' from type `%T' to type `%T'"
#~ msgstr "GUHINDURA Bivuye Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "invalid conversion from '%T' to '%T'"
#~ msgstr "Sibyo Ihindurangero Bivuye Kuri"

#, fuzzy
#~ msgid "conversion from `%T' to `%T' discards qualifiers"
#~ msgstr "Ihindurangero Bivuye Kuri"

#, fuzzy
#~ msgid "casting `%T' to `%T' does not dereference pointer"
#~ msgstr "Kuri OYA Mweretsi"

#, fuzzy
#~ msgid "cannot convert type `%T' to type `%T'"
#~ msgstr "GUHINDURA Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "conversion from `%#T' to `%#T'"
#~ msgstr "Ihindurangero Bivuye Kuri"

#, fuzzy
#~ msgid "`%#T' used where a `%T' was expected"
#~ msgstr "`%#T'a Ikitezwe:"

#, fuzzy
#~ msgid "the address of `%D', will always be `true'"
#~ msgstr "i Aderesi Bya Buri gihe"

#, fuzzy
#~ msgid "`%#T' used where a floating point value was expected"
#~ msgstr "`%#T'a Bihindagurika Akadomo Agaciro Ikitezwe:"

#, fuzzy
#~ msgid "conversion from `%T' to non-scalar type `%T' requested"
#~ msgstr "Ihindurangero Bivuye Kuri Ubwoko"

#, fuzzy
#~ msgid "object of incomplete type `%T' will not be accessed in %s"
#~ msgstr "Igikoresho Bya Ubwoko OYA birabonetse in"

#, fuzzy
#~ msgid "object of type `%T' will not be accessed in %s"
#~ msgstr "Igikoresho Bya Ubwoko OYA birabonetse in"

#, fuzzy
#~ msgid "object `%E' of incomplete type `%T' will not be accessed in %s"
#~ msgstr "Igikoresho Bya Ubwoko OYA birabonetse in"

#, fuzzy
#~ msgid "%s cannot resolve address of overloaded function"
#~ msgstr "%sAderesi Bya Umumaro"

#, fuzzy
#~ msgid "%s is a reference, not call, to function `%E'"
#~ msgstr "%sni a Indango OYA Kuri Umumaro"

#, fuzzy
#~ msgid "ambiguous default type conversion from `%T'"
#~ msgstr "Mburabuzi Ubwoko Ihindurangero Bivuye"

#, fuzzy
#~ msgid "  candidate conversions include `%D' and `%D'"
#~ msgstr "Gushyiramo Na"

#, fuzzy
#~ msgid "conflicts with previous declaration `%#D'"
#~ msgstr "Na: Ibanjirije"

#, fuzzy
#~ msgid "label `%D' used but not defined"
#~ msgstr "Akarango OYA"

#, fuzzy
#~ msgid "label `%D' defined but not used"
#~ msgstr "Akarango OYA"

#, fuzzy
#~ msgid "namespace alias `%D' not allowed here, assuming `%D'"
#~ msgstr "Irihimbano OYA"

#, fuzzy
#~ msgid "previous declaration of `%D'"
#~ msgstr "Ibanjirije Bya"

#, fuzzy
#~ msgid "shadowing %s function `%#D'"
#~ msgstr "Ishyiraho ry'igicucu Umumaro"

#, fuzzy
#~ msgid "library function `%#D' redeclared as non-function `%#D'"
#~ msgstr "Isomero Umumaro Nka Umumaro"

#, fuzzy
#~ msgid "conflicts with built-in declaration `%#D'"
#~ msgstr "Na: in"

#, fuzzy
#~ msgid "new declaration `%#D'"
#~ msgstr "Gishya"

#, fuzzy
#~ msgid "ambiguates built-in declaration `%#D'"
#~ msgstr "in"

#, fuzzy
#~ msgid "`%#D' redeclared as different kind of symbol"
#~ msgstr "`%#D'Nka Bya IKIMENYETSO"

#, fuzzy
#~ msgid "previous declaration of `%#D'"
#~ msgstr "Ibanjirije Bya"

#, fuzzy
#~ msgid "declaration of template `%#D'"
#~ msgstr "Bya Inyandikorugero"

#, fuzzy
#~ msgid "ambiguates old declaration `%#D'"
#~ msgstr "ki/ bishaje"

#, fuzzy
#~ msgid "declaration of C function `%#D' conflicts with"
#~ msgstr "Bya C Umumaro Na:"

#, fuzzy
#~ msgid "previous declaration `%#D' here"
#~ msgstr "Ibanjirije"

#, fuzzy
#~ msgid "conflicting types for `%#D'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "previous declaration as `%#D'"
#~ msgstr "Ibanjirije Nka"

#, fuzzy
#~ msgid "prototype for `%#D'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "follows non-prototype definition here"
#~ msgstr "Insobanuro"

#, fuzzy
#~ msgid "previous declaration of `%#D' with %L linkage"
#~ msgstr "Ibanjirije Bya Na:"

#, fuzzy
#~ msgid "conflicts with new declaration with %L linkage"
#~ msgstr "Na: Gishya Na:"

#, fuzzy
#~ msgid "default argument given for parameter %d of `%#D'"
#~ msgstr "Mburabuzi kugirango Bya"

#, fuzzy
#~ msgid "after previous specification in `%#D'"
#~ msgstr "Nyuma Ibanjirije in"

#, fuzzy
#~ msgid "`%#D' was used before it was declared inline"
#~ msgstr "`%#D'Mbere Mumurongo"

#, fuzzy
#~ msgid "previous non-inline declaration here"
#~ msgstr "Ibanjirije Mumurongo"

#, fuzzy
#~ msgid "redundant redeclaration of `%D' in same scope"
#~ msgstr "Bya in Ingano:"

#, fuzzy
#~ msgid "declaration of `%F' throws different exceptions"
#~ msgstr "Bya Amarengayobora"

#, fuzzy
#~ msgid "than previous declaration `%F'"
#~ msgstr "Ibanjirije"

#, fuzzy
#~ msgid "explicit specialization of %D after first use"
#~ msgstr "Bya Nyuma Itangira Gukoresha"

#, fuzzy
#~ msgid "`%#D' used prior to declaration"
#~ msgstr "`%#D'Kuri"

#, fuzzy
#~ msgid "redeclaration of `wchar_t' as `%T'"
#~ msgstr "Bya Nka"

#, fuzzy
#~ msgid "invalid redeclaration of `%D'"
#~ msgstr "Sibyo Bya"

# svx/source\dialog\backgrnd.src:RID_SVXPAGE_BACKGROUND.FT_SELECTOR.text
#, fuzzy
#~ msgid "as `%D'"
#~ msgstr "Nka"

#, fuzzy
#~ msgid "previous external decl of `%#D'"
#~ msgstr "Ibanjirije external Bya"

#, fuzzy
#~ msgid "`%D' was previously implicitly declared to return `int'"
#~ msgstr "`%D'Kuri Garuka"

#, fuzzy
#~ msgid "extern declaration of `%#D' doesn't match"
#~ msgstr "Bya BIHUYE"

#, fuzzy
#~ msgid "declaration of `%#D' shadows a parameter"
#~ msgstr "Bya a"

#, fuzzy
#~ msgid "declaration of `%s' shadows a member of `this'"
#~ msgstr "Bya a Bya"

#, fuzzy
#~ msgid "`%#D' hides constructor for `%#T'"
#~ msgstr "`%#D'kugirango"

#, fuzzy
#~ msgid "`%#D' conflicts with previous using declaration `%#D'"
#~ msgstr "`%#D'Na: Ibanjirije ikoresha"

#, fuzzy
#~ msgid "previous non-function declaration `%#D'"
#~ msgstr "Ibanjirije Umumaro"

#, fuzzy
#~ msgid "conflicts with function declaration `%#D'"
#~ msgstr "Na: Umumaro"

#, fuzzy
#~ msgid "implicit declaration of function `%#D'"
#~ msgstr "Bya Umumaro"

#, fuzzy
#~ msgid "label `%s' referenced outside of any function"
#~ msgstr "Akarango Hanze Bya Umumaro"

#, fuzzy
#~ msgid "jump to label `%D'"
#~ msgstr "Simbuka Kuri Akarango"

#, fuzzy
#~ msgid "jump to case label"
#~ msgstr "Simbuka Kuri Akarango"

#, fuzzy
#~ msgid "  crosses initialization of `%#D'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "  enters scope of non-POD `%#D'"
#~ msgstr "Ingano: Bya"

#, fuzzy
#~ msgid "  enters try block"
#~ msgstr "Funga"

#, fuzzy
#~ msgid "  enters catch block"
#~ msgstr "Funga"

#, fuzzy
#~ msgid "  from here"
#~ msgstr "Bivuye"

#, fuzzy
#~ msgid "  skips initialization of `%#D'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "label named wchar_t"
#~ msgstr "Akarango"

#, fuzzy
#~ msgid "duplicate label `%D'"
#~ msgstr "Gusubiramo Akarango"

#, fuzzy
#~ msgid "case label `%E' not within a switch statement"
#~ msgstr "Akarango OYA muri a Hindura Inyandiko"

#, fuzzy
#~ msgid "`%#D' redeclared as %C"
#~ msgstr "`%#D'Nka"

#, fuzzy
#~ msgid "invalid use of `%D'"
#~ msgstr "Sibyo Gukoresha Bya"

#, fuzzy
#~ msgid "`%D::%D' is not a template"
#~ msgstr "`%D::%D'ni OYA a Inyandikorugero"

#, fuzzy
#~ msgid "`%D' undeclared in namespace `%D'"
#~ msgstr "`%D'in"

#, fuzzy
#~ msgid "`%D' used without template parameters"
#~ msgstr "`%D'Inyandikorugero Ibigenga"

#, fuzzy
#~ msgid "no class template named `%#T' in `%#T'"
#~ msgstr "Oya ishuri Inyandikorugero in"

#, fuzzy
#~ msgid "no type named `%#T' in `%#T'"
#~ msgstr "Oya Ubwoko in"

#, fuzzy
#~ msgid "lookup of `%D' finds `%#D'"
#~ msgstr "GUSHAKISHA Bya"

#, fuzzy
#~ msgid "  instead of `%D' from dependent base class"
#~ msgstr "Bya Bivuye SHINGIRO ishuri"

#, fuzzy
#~ msgid "  (use `typename %T::%D' if that's what you meant)"
#~ msgstr "(Gukoresha NIBA"

#, fuzzy
#~ msgid "name lookup of `%D' changed"
#~ msgstr "Izina: GUSHAKISHA Bya Byahinduwe"

#, fuzzy
#~ msgid "  matches this `%D' under ISO standard rules"
#~ msgstr "iyi Bisanzwe"

#, fuzzy
#~ msgid "  matches this `%D' under old rules"
#~ msgstr "iyi ki/ bishaje"

#, fuzzy
#~ msgid "name lookup of `%D' changed for new ISO `for' scoping"
#~ msgstr "Izina: GUSHAKISHA Bya Byahinduwe kugirango Gishya"

#, fuzzy
#~ msgid "  cannot use obsolete binding at `%D' because it has a destructor"
#~ msgstr "Gukoresha Bifatanya ku a"

#, fuzzy
#~ msgid "  using obsolete binding at `%D'"
#~ msgstr "ikoresha Bifatanya ku"

#, fuzzy
#~ msgid "lookup of `%D' in the scope of `%#T' (`%#D') does not match lookup in the current scope (`%#D')"
#~ msgstr "GUSHAKISHA Bya in i Ingano: Bya OYA BIHUYE GUSHAKISHA in i KIGEZWEHO Ingano:"

#, fuzzy
#~ msgid "an anonymous union cannot have function members"
#~ msgstr "Ihuza Umumaro"

#, fuzzy
#~ msgid "member %#D' with constructor not allowed in anonymous aggregate"
#~ msgstr "Na: OYA in"

#, fuzzy
#~ msgid "member %#D' with destructor not allowed in anonymous aggregate"
#~ msgstr "Na: OYA in"

#, fuzzy
#~ msgid "member %#D' with copy assignment operator not allowed in anonymous aggregate"
#~ msgstr "Na: Gukoporora Igenera Mukoresha OYA in"

#, fuzzy
#~ msgid "redeclaration of C++ built-in type `%T'"
#~ msgstr "Bya C in Ubwoko"

#, fuzzy
#~ msgid "multiple types in one declaration"
#~ msgstr "Igikubo in"

#, fuzzy
#~ msgid "missing type-name in typedef-declaration"
#~ msgstr "Ibuze Ubwoko Izina: in"

#, fuzzy
#~ msgid "ISO C++ prohibits anonymous structs"
#~ msgstr "C"

#, fuzzy
#~ msgid "`%D' can only be specified for functions"
#~ msgstr "`%D'kugirango Imimaro"

#, fuzzy
#~ msgid "`%D' can only be specified inside a class"
#~ msgstr "`%D'Mo Imbere a ishuri"

#, fuzzy
#~ msgid "`%D' can only be specified for constructors"
#~ msgstr "`%D'kugirango"

#, fuzzy
#~ msgid "`%D' can only be specified for objects and functions"
#~ msgstr "`%D'kugirango Ibintu Na Imimaro"

#, fuzzy
#~ msgid "typedef `%D' is initialized (use __typeof__ instead)"
#~ msgstr "ni Gukoresha"

#, fuzzy
#~ msgid "function `%#D' is initialized like a variable"
#~ msgstr "Umumaro ni nka a IMPINDURAGACIRO"

#, fuzzy
#~ msgid "declaration of `%#D' has `extern' and is initialized"
#~ msgstr "Bya Na ni"

#, fuzzy
#~ msgid "`%#D' is not a static member of `%#T'"
#~ msgstr "`%#D'ni OYA a Bya"

#, fuzzy
#~ msgid "ISO C++ does not permit `%T::%D' to be defined as `%T::%D'"
#~ msgstr "C OYA Kuri Nka"

#, fuzzy
#~ msgid "duplicate initialization of %D"
#~ msgstr "Gusubiramo Bya"

#, fuzzy
#~ msgid "declaration of `%#D' outside of class is not definition"
#~ msgstr "Bya Hanze Bya ishuri ni OYA Insobanuro"

#, fuzzy
#~ msgid "variable `%#D' has initializer but incomplete type"
#~ msgstr "IMPINDURAGACIRO Ubwoko"

#, fuzzy
#~ msgid "elements of array `%#D' have incomplete type"
#~ msgstr "Ibintu Bya Imbonerahamwe Ubwoko"

#, fuzzy
#~ msgid "aggregate `%#D' has incomplete type and cannot be defined"
#~ msgstr "Ubwoko Na"

#, fuzzy
#~ msgid "`%D' declared as reference but not initialized"
#~ msgstr "`%D'Nka Indango OYA"

#, fuzzy
#~ msgid "ISO C++ forbids use of initializer list to initialize reference `%D'"
#~ msgstr "C Gukoresha Bya Urutonde Kuri gutangiza Indango"

#, fuzzy
#~ msgid "cannot initialize `%T' from `%T'"
#~ msgstr "gutangiza Bivuye"

#, fuzzy
#~ msgid "initializer fails to determine size of `%D'"
#~ msgstr "Kuri Ingano Bya"

#, fuzzy
#~ msgid "array size missing in `%D'"
#~ msgstr "Imbonerahamwe Ingano Ibuze in"

#, fuzzy
#~ msgid "zero-size array `%D'"
#~ msgstr "Zeru Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "storage size of `%D' isn't known"
#~ msgstr "Ingano Bya si"

#, fuzzy
#~ msgid "storage size of `%D' isn't constant"
#~ msgstr "Ingano Bya si"

#, fuzzy
#~ msgid "sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)"
#~ msgstr "Bya Mumurongo Umumaro Ibyatanzwe Hejuru Na: Igikubo Amakopi"

#, fuzzy
#~ msgid "  you can work around this by removing the initializer"
#~ msgstr "Akazi iyi ku i"

#, fuzzy
#~ msgid "uninitialized const `%D'"
#~ msgstr "Itatangijwe"

#, fuzzy
#~ msgid "brace-enclosed initializer used to initialize `%T'"
#~ msgstr "Kuri gutangiza"

#, fuzzy
#~ msgid "initializer for `%T' must be brace-enclosed"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "ISO C++ does not allow designated initializers"
#~ msgstr "C OYA Kwemerera"

#, fuzzy
#~ msgid "`%T' has no non-static data member named `%D'"
#~ msgstr "`%T'Oya Ibyatanzwe"

#, fuzzy
#~ msgid "too many initializers for `%T'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "variable-sized object `%D' may not be initialized"
#~ msgstr "IMPINDURAGACIRO Igikoresho Gicurasi OYA"

#, fuzzy
#~ msgid "`%D' has incomplete type"
#~ msgstr "`%D'Ubwoko"

#, fuzzy
#~ msgid "`%D' must be initialized by constructor, not by `{...}'"
#~ msgstr "`%D'ku OYA ku"

#, fuzzy
#~ msgid "structure `%D' with uninitialized const members"
#~ msgstr "Imiterere Na: Itatangijwe"

#, fuzzy
#~ msgid "structure `%D' with uninitialized reference members"
#~ msgstr "Imiterere Na: Itatangijwe Indango"

#, fuzzy
#~ msgid "assignment (not initialization) in declaration"
#~ msgstr "Igenera OYA in"

#, fuzzy
#~ msgid "cannot initialize `%D' to namespace `%D'"
#~ msgstr "gutangiza Kuri"

#, fuzzy
#~ msgid "shadowing previous type declaration of `%#D'"
#~ msgstr "Ishyiraho ry'igicucu Ibanjirije Ubwoko Bya"

#, fuzzy
#~ msgid "`%D' cannot be thread-local because it has non-POD type `%T'"
#~ msgstr "`%D'Urudodo Ubwoko"

#, fuzzy
#~ msgid "`%D' is thread-local and so cannot be dynamically initialized"
#~ msgstr "`%D'ni Urudodo Na"

#, fuzzy
#~ msgid "multiple initializations given for `%D'"
#~ msgstr "Igikubo kugirango"

#, fuzzy
#~ msgid "invalid catch parameter"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "destructor for alien class `%T' cannot be a member"
#~ msgstr "kugirango ishuri a"

#, fuzzy
#~ msgid "constructor for alien class `%T' cannot be a member"
#~ msgstr "kugirango ishuri a"

#, fuzzy
#~ msgid "`%D' declared as a `virtual' %s"
#~ msgstr "`%D'Nka a"

#, fuzzy
#~ msgid "`%D' declared as an `inline' %s"
#~ msgstr "`%D'Nka"

#, fuzzy
#~ msgid "`const' and `volatile' function specifiers on `%D' invalid in %s declaration"
#~ msgstr "`Na Umumaro ku Sibyo in"

#, fuzzy
#~ msgid "`%D' declared as a friend"
#~ msgstr "`%D'Nka a"

#, fuzzy
#~ msgid "`%D' declared with an exception specification"
#~ msgstr "`%D'Na: Irengayobora(-)"

#, fuzzy
#~ msgid "cannot declare `::main' to be a template"
#~ msgstr "Kuri a Inyandikorugero"

#, fuzzy
#~ msgid "cannot declare `::main' to be inline"
#~ msgstr "Kuri Mumurongo"

#, fuzzy
#~ msgid "cannot declare `::main' to be static"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "`main' must return `int'"
#~ msgstr "`Garuka"

#, fuzzy
#~ msgid "non-local function `%#D' uses anonymous type"
#~ msgstr "Umumaro Ubwoko"

#, fuzzy
#~ msgid "`%#D' does not refer to the unqualified type, so it is not used for linkage"
#~ msgstr "`%#D'OYA Kuri i Ubwoko ni OYA kugirango"

#, fuzzy
#~ msgid "non-local function `%#D' uses local type `%T'"
#~ msgstr "Umumaro Ubwoko"

#, fuzzy
#~ msgid "%smember function `%D' cannot have `%T' method qualifier"
#~ msgstr "%smemberUmumaro Uburyo"

#, fuzzy
#~ msgid "defining explicit specialization `%D' in friend declaration"
#~ msgstr "in"

#, fuzzy
#~ msgid "invalid use of template-id `%D' in declaration of primary template"
#~ msgstr "Sibyo Gukoresha Bya Inyandikorugero ID in Bya Inyandikorugero"

#, fuzzy
#~ msgid "default arguments are not allowed in declaration of friend template specialization `%D'"
#~ msgstr "Mburabuzi ingingo OYA in Bya Inyandikorugero"

#, fuzzy
#~ msgid "`inline' is not allowed in declaration of friend template specialization `%D'"
#~ msgstr "`ni OYA in Bya Inyandikorugero"

#, fuzzy
#~ msgid "definition of implicitly-declared `%D'"
#~ msgstr "Insobanuro Bya"

#, fuzzy
#~ msgid "no `%#D' member function declared in class `%T'"
#~ msgstr "Oya Umumaro in ishuri"

#, fuzzy
#~ msgid "non-local variable `%#D' uses local type `%T'"
#~ msgstr "IMPINDURAGACIRO Ubwoko"

#, fuzzy
#~ msgid "invalid in-class initialization of static data member of non-integral type `%T'"
#~ msgstr "Sibyo in ishuri Bya Ibyatanzwe Bya Umubare Wuzuye Ubwoko"

#, fuzzy
#~ msgid "ISO C++ forbids in-class initialization of non-const static member `%D'"
#~ msgstr "C in ishuri Bya"

#, fuzzy
#~ msgid "ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'"
#~ msgstr "C Bya Bya Umubare Wuzuye Ubwoko"

#, fuzzy
#~ msgid "size of array `%D' has non-integer type"
#~ msgstr "Ingano Bya Imbonerahamwe Umubare wuzuye Ubwoko"

#, fuzzy
#~ msgid "size of array has non-integer type"
#~ msgstr "Ingano Bya Imbonerahamwe Umubare wuzuye Ubwoko"

#, fuzzy
#~ msgid "size of array `%D' is negative"
#~ msgstr "Ingano Bya Imbonerahamwe ni"

#, fuzzy
#~ msgid "size of array is negative"
#~ msgstr "Ingano Bya Imbonerahamwe ni"

#, fuzzy
#~ msgid "ISO C++ forbids zero-size array `%D'"
#~ msgstr "C Zeru Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "ISO C++ forbids zero-size array"
#~ msgstr "C Zeru Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "size of array `%D' is not an integral constant-expression"
#~ msgstr "Ingano Bya Imbonerahamwe ni OYA Umubare Wuzuye imvugo"

#, fuzzy
#~ msgid "size of array is not an integral constant-expression"
#~ msgstr "Ingano Bya Imbonerahamwe ni OYA Umubare Wuzuye imvugo"

#, fuzzy
#~ msgid "ISO C++ forbids variable-size array `%D'"
#~ msgstr "C IMPINDURAGACIRO Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "ISO C++ forbids variable-size array"
#~ msgstr "C IMPINDURAGACIRO Ingano Imbonerahamwe"

#, fuzzy
#~ msgid "overflow in array dimension"
#~ msgstr "Byarenze urugero in Imbonerahamwe"

#, fuzzy
#~ msgid "declaration of `%D' as %s"
#~ msgstr "Bya Nka"

#, fuzzy
#~ msgid "declaration of `%D' as multidimensional array must have bounds for all dimensions except the first"
#~ msgstr "Bya Nka Imbonerahamwe kugirango Byose Ingero i Itangira"

#, fuzzy
#~ msgid "multidimensional array must have bounds for all dimensions except the first"
#~ msgstr "Imbonerahamwe kugirango Byose Ingero i Itangira"

#, fuzzy
#~ msgid "return type specification for constructor invalid"
#~ msgstr "Garuka Ubwoko kugirango Sibyo"

#, fuzzy
#~ msgid "return type specification for destructor invalid"
#~ msgstr "Garuka Ubwoko kugirango Sibyo"

#, fuzzy
#~ msgid "operator `%T' declared to return `%T'"
#~ msgstr "Mukoresha Kuri Garuka"

#, fuzzy
#~ msgid "return type specified for `operator %T'"
#~ msgstr "Garuka Ubwoko kugirango Mukoresha"

#, fuzzy
#~ msgid "destructors must be member functions"
#~ msgstr "Imimaro"

#, fuzzy
#~ msgid "destructor `%T' must match class name `%T'"
#~ msgstr "BIHUYE ishuri Izina:"

#, fuzzy
#~ msgid "variable declaration is not allowed here"
#~ msgstr "IMPINDURAGACIRO ni OYA"

#, fuzzy
#~ msgid "invalid declarator"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "declarator-id missing; using reserved word `%D'"
#~ msgstr "ID Ibuze ikoresha ijambo"

#, fuzzy
#~ msgid "type `%T' is not derived from type `%T'"
#~ msgstr "Ubwoko ni OYA Bivuye Ubwoko"

#, fuzzy
#~ msgid "`%T' specified as declarator-id"
#~ msgstr "`%T'Nka ID"

#, fuzzy
#~ msgid "  perhaps you want `%T' for a constructor"
#~ msgstr "kugirango a"

#, fuzzy
#~ msgid "invalid use of template-name '%E' in a declarator"
#~ msgstr "Sibyo Gukoresha Bya Inyandikorugero Izina: in a"

#, fuzzy
#~ msgid "declaration of `%D' as non-function"
#~ msgstr "Bya Nka Umumaro"

#, fuzzy
#~ msgid "`bool' is now a keyword"
#~ msgstr "`ni NONEAHA a Ijambo- banze"

#, fuzzy
#~ msgid "multiple declarations `%T' and `%T'"
#~ msgstr "Igikubo Na"

#, fuzzy
#~ msgid "ISO C++ does not support `long long'"
#~ msgstr "C OYA Gushigikira"

#, fuzzy
#~ msgid "ISO C++ forbids declaration of `%s' with no type"
#~ msgstr "C Bya Na: Oya Ubwoko"

#, fuzzy
#~ msgid "`%T' is implicitly a typename"
#~ msgstr "`%T'ni a"

#, fuzzy
#~ msgid "short, signed or unsigned invalid for `%s'"
#~ msgstr "Cyangwa Bitashizweho umukono Sibyo kugirango"

#, fuzzy
#~ msgid "long and short specified together for `%s'"
#~ msgstr "Na kugirango"

#, fuzzy
#~ msgid "signed and unsigned given together for `%s'"
#~ msgstr "Na Bitashizweho umukono kugirango"

#, fuzzy
#~ msgid "qualifiers are not allowed on declaration of `operator %T'"
#~ msgstr "OYA ku Bya Mukoresha"

#, fuzzy
#~ msgid "member `%D' cannot be declared both virtual and static"
#~ msgstr "Byombi Kitaboneka Na"

#, fuzzy
#~ msgid "storage class specifiers invalid in parameter declarations"
#~ msgstr "ishuri Sibyo in"

#, fuzzy
#~ msgid "typedef declaration invalid in parameter declaration"
#~ msgstr "Sibyo in"

#, fuzzy
#~ msgid "virtual outside class declaration"
#~ msgstr "Kitaboneka Hanze ishuri"

#, fuzzy
#~ msgid "storage class specified for %s `%s'"
#~ msgstr "ishuri kugirango"

#, fuzzy
#~ msgid "storage class specifiers invalid in friend function declarations"
#~ msgstr "ishuri Sibyo in Umumaro"

#, fuzzy
#~ msgid "destructor cannot be static member function"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "destructors may not be `%s'"
#~ msgstr "Gicurasi OYA"

#, fuzzy
#~ msgid "constructor cannot be static member function"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "constructors cannot be declared virtual"
#~ msgstr "Kitaboneka"

#, fuzzy
#~ msgid "constructors may not be `%s'"
#~ msgstr "Gicurasi OYA"

#, fuzzy
#~ msgid "return value type specifier for constructor ignored"
#~ msgstr "Garuka Agaciro Ubwoko kugirango"

#, fuzzy
#~ msgid "can't initialize friend function `%s'"
#~ msgstr "gutangiza Umumaro"

#, fuzzy
#~ msgid "virtual functions cannot be friends"
#~ msgstr "Kitaboneka Imimaro"

#, fuzzy
#~ msgid "friend declaration not in class definition"
#~ msgstr "OYA in ishuri Insobanuro"

#, fuzzy
#~ msgid "can't define friend function `%s' in a local class definition"
#~ msgstr "Kugaragaza... Umumaro in a ishuri Insobanuro"

#, fuzzy
#~ msgid "destructors may not have parameters"
#~ msgstr "Gicurasi OYA Ibigenga"

#, fuzzy
#~ msgid "cannot declare reference to `%#T'"
#~ msgstr "Indango Kuri"

#, fuzzy
#~ msgid "cannot declare pointer to `%#T'"
#~ msgstr "Mweretsi Kuri"

#, fuzzy
#~ msgid "cannot declare pointer to `%#T' member"
#~ msgstr "Mweretsi Kuri"

#, fuzzy
#~ msgid "extra qualification `%T::' on member `%s' ignored"
#~ msgstr "Birenga ku"

#, fuzzy
#~ msgid "cannot declare member function `%T::%s' within `%T'"
#~ msgstr "Umumaro muri"

#, fuzzy
#~ msgid "cannot declare member `%T::%s' within `%T'"
#~ msgstr "muri"

#, fuzzy
#~ msgid "data member may not have variably modified type `%T'"
#~ msgstr "Ibyatanzwe Gicurasi OYA Byahinduwe Ubwoko"

#, fuzzy
#~ msgid "parameter may not have variably modified type `%T'"
#~ msgstr "Gicurasi OYA Byahinduwe Ubwoko"

#, fuzzy
#~ msgid "only declarations of constructors can be `explicit'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "non-object member `%s' cannot be declared `mutable'"
#~ msgstr "Igikoresho"

#, fuzzy
#~ msgid "function `%s' cannot be declared `mutable'"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "template-id `%D' used as a declarator"
#~ msgstr "Inyandikorugero ID Nka a"

#, fuzzy
#~ msgid "ISO C++ forbids nested type `%D' with same name as enclosing class"
#~ msgstr "C Ubwoko Na: Izina: Nka ishuri"

#, fuzzy
#~ msgid "typedef name may not be class-qualified"
#~ msgstr "Izina: Gicurasi OYA ishuri"

#, fuzzy
#~ msgid "invalid type qualifier for non-member function type"
#~ msgstr "Sibyo Ubwoko kugirango Umumaro Ubwoko"

#, fuzzy
#~ msgid "type qualifiers specified for friend class declaration"
#~ msgstr "Ubwoko kugirango ishuri"

#, fuzzy
#~ msgid "`inline' specified for friend class declaration"
#~ msgstr "`kugirango ishuri"

#, fuzzy
#~ msgid "template parameters cannot be friends"
#~ msgstr "Inyandikorugero Ibigenga"

#, fuzzy
#~ msgid "friend declaration requires class-key, i.e. `friend class %T::%D'"
#~ msgstr "E."

#, fuzzy
#~ msgid "friend declaration requires class-key, i.e. `friend %#T'"
#~ msgstr "E."

#, fuzzy
#~ msgid "trying to make class `%T' a friend of global scope"
#~ msgstr "Kuri Ubwoko ishuri a Bya Ingano:"

#, fuzzy
#~ msgid "invalid qualifiers on non-member function type"
#~ msgstr "Sibyo ku Umumaro Ubwoko"

#, fuzzy
#~ msgid "abstract declarator `%T' used as declaration"
#~ msgstr "Incamake Nka"

#, fuzzy
#~ msgid "unnamed variable or field declared void"
#~ msgstr "Kitiswe IMPINDURAGACIRO Cyangwa Umwanya"

#, fuzzy
#~ msgid "variable or field declared void"
#~ msgstr "IMPINDURAGACIRO Cyangwa Umwanya"

#, fuzzy
#~ msgid "cannot use `::' in parameter declaration"
#~ msgstr "Gukoresha in"

#, fuzzy
#~ msgid "invalid use of `::'"
#~ msgstr "Sibyo Gukoresha Bya"

#, fuzzy
#~ msgid "function `%D' cannot be declared friend"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "can't make `%D' into a method -- not in a class"
#~ msgstr "Ubwoko a Uburyo OYA in a ishuri"

#, fuzzy
#~ msgid "function `%D' declared virtual inside a union"
#~ msgstr "Umumaro Kitaboneka Mo Imbere a Ihuza"

#, fuzzy
#~ msgid "`%D' cannot be declared virtual, since it is always static"
#~ msgstr "`%D'Kitaboneka guhera ni Buri gihe"

#, fuzzy
#~ msgid "field `%D' has incomplete type"
#~ msgstr "Umwanya Ubwoko"

#, fuzzy
#~ msgid "name `%T' has incomplete type"
#~ msgstr "Izina: Ubwoko"

#, fuzzy
#~ msgid "  in instantiation of template `%T'"
#~ msgstr "in Bya Inyandikorugero"

#, fuzzy
#~ msgid "`%s' is neither function nor member function; cannot be declared friend"
#~ msgstr "`%s'ni Umumaro Umumaro"

#, fuzzy
#~ msgid "member functions are implicitly friends of their class"
#~ msgstr "Imimaro Bya ishuri"

#, fuzzy
#~ msgid "ISO C++ forbids initialization of member `%D'"
#~ msgstr "C Bya"

#, fuzzy
#~ msgid "ISO C++ forbids static data member `%D' with same name as enclosing class"
#~ msgstr "C Ibyatanzwe Na: Izina: Nka ishuri"

#, fuzzy
#~ msgid "storage class `auto' invalid for function `%s'"
#~ msgstr "ishuri Sibyo kugirango Umumaro"

#, fuzzy
#~ msgid "storage class `register' invalid for function `%s'"
#~ msgstr "ishuri Sibyo kugirango Umumaro"

#, fuzzy
#~ msgid "storage class `__thread' invalid for function `%s'"
#~ msgstr "ishuri Sibyo kugirango Umumaro"

#, fuzzy
#~ msgid "storage class `static' invalid for function `%s' declared out of global scope"
#~ msgstr "ishuri Sibyo kugirango Umumaro Inyuma Bya Ingano:"

#, fuzzy
#~ msgid "storage class `inline' invalid for function `%s' declared out of global scope"
#~ msgstr "ishuri Sibyo kugirango Umumaro Inyuma Bya Ingano:"

#, fuzzy
#~ msgid "virtual non-class function `%s'"
#~ msgstr "Kitaboneka ishuri Umumaro"

#, fuzzy
#~ msgid "cannot declare member function `%D' to have static linkage"
#~ msgstr "Umumaro Kuri"

#, fuzzy
#~ msgid "cannot declare static function inside another function"
#~ msgstr "Umumaro Mo Imbere Umumaro"

#, fuzzy
#~ msgid "`static' may not be used when defining (as opposed to declaring) a static data member"
#~ msgstr "`Gicurasi OYA Ryari: Nka Kuri a Ibyatanzwe"

#, fuzzy
#~ msgid "cannot explicitly declare member `%#D' to have extern linkage"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "default argument for `%#D' has type `%T'"
#~ msgstr "Mburabuzi kugirango Ubwoko"

#, fuzzy
#~ msgid "default argument for parameter of type `%T' has type `%T'"
#~ msgstr "Mburabuzi kugirango Bya Ubwoko Ubwoko"

#, fuzzy
#~ msgid "default argument `%E' uses local variable `%D'"
#~ msgstr "Mburabuzi IMPINDURAGACIRO"

#, fuzzy
#~ msgid "invalid string constant `%E'"
#~ msgstr "Sibyo Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "invalid integer constant in parameter list, did you forget to give parameter name?"
#~ msgstr "Sibyo Umubare wuzuye in Urutonde Kuri Izina:"

#, fuzzy
#~ msgid "parameter `%D' invalidly declared method type"
#~ msgstr "Uburyo Ubwoko"

#, fuzzy
#~ msgid "parameter `%D' invalidly declared offset type"
#~ msgstr "Nta- boneza Ubwoko"

#, fuzzy
#~ msgid "parameter `%D' includes %s to array of unknown bound `%T'"
#~ msgstr "Kuri Imbonerahamwe Bya Kitazwi"

#, fuzzy
#~ msgid "invalid constructor; you probably meant `%T (const %T&)'"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "`%D' must be a nonstatic member function"
#~ msgstr "`%D'a Umumaro"

#, fuzzy
#~ msgid "`%D' must be either a non-static member function or a non-member function"
#~ msgstr "`%D'a Umumaro Cyangwa a Umumaro"

#, fuzzy
#~ msgid "`%D' must have an argument of class or enumerated type"
#~ msgstr "`%D'Bya ishuri Cyangwa Ubwoko"

#, fuzzy
#~ msgid "conversion to %s%s will never use a type conversion operator"
#~ msgstr "Ihindurangero Kuri Nta narimwe Gukoresha a Ubwoko Ihindurangero Mukoresha"

#, fuzzy
#~ msgid "ISO C++ prohibits overloading operator ?:"
#~ msgstr "C Mukoresha"

#, fuzzy
#~ msgid "postfix `%D' must take `int' as its argument"
#~ msgstr "Nka"

#, fuzzy
#~ msgid "postfix `%D' must take `int' as its second argument"
#~ msgstr "Nka ISEGONDA"

#, fuzzy
#~ msgid "`%D' must take either zero or one argument"
#~ msgstr "`%D'Zeru Cyangwa"

#, fuzzy
#~ msgid "`%D' must take either one or two arguments"
#~ msgstr "`%D'Cyangwa ingingo"

#, fuzzy
#~ msgid "prefix `%D' should return `%T'"
#~ msgstr "Imbanziriza Garuka"

#, fuzzy
#~ msgid "postfix `%D' should return `%T'"
#~ msgstr "Garuka"

#, fuzzy
#~ msgid "`%D' must take exactly two arguments"
#~ msgstr "`%D'ingingo"

#, fuzzy
#~ msgid "user-defined `%D' always evaluates both arguments"
#~ msgstr "Ukoresha: Buri gihe Byombi ingingo"

#, fuzzy
#~ msgid "`%D' should return by value"
#~ msgstr "`%D'Garuka ku Agaciro"

#, fuzzy
#~ msgid "`%D' cannot have default arguments"
#~ msgstr "`%D'Mburabuzi ingingo"

#, fuzzy
#~ msgid "using typedef-name `%D' after `%s'"
#~ msgstr "ikoresha Izina: Nyuma"

#, fuzzy
#~ msgid "using template type parameter `%T' after `%s'"
#~ msgstr "ikoresha Inyandikorugero Ubwoko Nyuma"

#, fuzzy
#~ msgid "`%s %T' declares a new type at namespace scope"
#~ msgstr "`%s%T'a Gishya Ubwoko ku Ingano:"

#, fuzzy
#~ msgid "  names from dependent base classes are not visible to unqualified name lookup - to refer to the inherited type, say `%s %T::%T'"
#~ msgstr "Amazina Bivuye SHINGIRO Inzego OYA Kigaragara Kuri Izina: GUSHAKISHA Kuri Kuri i Ubwoko"

#, fuzzy
#~ msgid "use of enum `%#D' without previous declaration"
#~ msgstr "Gukoresha Bya Ibanjirije"

#, fuzzy
#~ msgid "derived union `%T' invalid"
#~ msgstr "Ihuza Sibyo"

#, fuzzy
#~ msgid "base type `%T' fails to be a struct or class type"
#~ msgstr "SHINGIRO Ubwoko Kuri a Cyangwa ishuri Ubwoko"

#, fuzzy
#~ msgid "base class `%T' has incomplete type"
#~ msgstr "SHINGIRO ishuri Ubwoko"

#, fuzzy
#~ msgid "recursive type `%T' undefined"
#~ msgstr "Ubwoko kidasobanuye"

#, fuzzy
#~ msgid "duplicate base type `%T' invalid"
#~ msgstr "Gusubiramo SHINGIRO Ubwoko Sibyo"

#, fuzzy
#~ msgid "multiple definition of `%#T'"
#~ msgstr "Igikubo Insobanuro Bya"

#, fuzzy
#~ msgid "previous definition here"
#~ msgstr "Ibanjirije Insobanuro"

#, fuzzy
#~ msgid "enumerator value for `%D' not integer constant"
#~ msgstr "Agaciro kugirango OYA Umubare wuzuye"

#, fuzzy
#~ msgid "overflow in enumeration values at `%D'"
#~ msgstr "Byarenze urugero in Uduciro ku"

#, fuzzy
#~ msgid "return type `%#T' is incomplete"
#~ msgstr "Garuka Ubwoko ni"

#, fuzzy
#~ msgid "semicolon missing after declaration of `%#T'"
#~ msgstr "Akabago n'Akitso Ibuze Nyuma Bya"

#, fuzzy
#~ msgid "return type for `main' changed to `int'"
#~ msgstr "Garuka Ubwoko kugirango Byahinduwe Kuri"

#, fuzzy
#~ msgid "`%D' implicitly declared before its definition"
#~ msgstr "`%D'Mbere Insobanuro"

#, fuzzy
#~ msgid "`operator=' should return a reference to `*this'"
#~ msgstr "`Mukoresha Garuka a Indango Kuri"

#, fuzzy
#~ msgid "`%D' is already defined in class `%T'"
#~ msgstr "`%D'ni in ishuri"

#, fuzzy
#~ msgid "static member function `%#D' declared with type qualifiers"
#~ msgstr "Umumaro Na: Ubwoko"

#, fuzzy
#~ msgid "duplicate type qualifiers in %s declaration"
#~ msgstr "Gusubiramo Ubwoko in"

#, fuzzy
#~ msgid "template `%#D' instantiated in file without #pragma interface"
#~ msgstr "Inyandikorugero in IDOSIYE"

#, fuzzy
#~ msgid "template `%#D' defined in file without #pragma interface"
#~ msgstr "Inyandikorugero in IDOSIYE"

#, fuzzy
#~ msgid "name missing for member function"
#~ msgstr "Izina: Ibuze kugirango Umumaro"

#, fuzzy
#~ msgid "parser may be lost: is there a '{' missing somewhere?"
#~ msgstr "Gicurasi ni a Ibuze"

#, fuzzy
#~ msgid "ambiguous conversion for array subscript"
#~ msgstr "Ihindurangero kugirango Imbonerahamwe Inyandiko nyesi"

#, fuzzy
#~ msgid "invalid types `%T[%T]' for array subscript"
#~ msgstr "Sibyo kugirango Imbonerahamwe Inyandiko nyesi"

#, fuzzy
#~ msgid "type `%#T' argument given to `delete', expected pointer"
#~ msgstr "Ubwoko Kuri Ikitezwe: Mweretsi"

#, fuzzy
#~ msgid "anachronistic use of array size in vector delete"
#~ msgstr "Gukoresha Bya Imbonerahamwe Ingano in Gusiba"

#, fuzzy
#~ msgid "cannot delete a function.  Only pointer-to-objects are valid arguments to `delete'"
#~ msgstr "Gusiba a Umumaro Mweretsi Kuri Ibintu Byemewe ingingo Kuri"

#, fuzzy
#~ msgid "deleting `%T' is undefined"
#~ msgstr "ni kidasobanuye"

#, fuzzy
#~ msgid "deleting array `%#D'"
#~ msgstr "Imbonerahamwe"

#, fuzzy
#~ msgid "invalid declaration of member template `%#D' in local class"
#~ msgstr "Sibyo Bya Inyandikorugero in ishuri"

#, fuzzy
#~ msgid "invalid use of `virtual' in template declaration of `%#D'"
#~ msgstr "Sibyo Gukoresha Bya in Inyandikorugero Bya"

#, fuzzy
#~ msgid "template declaration of `%#D'"
#~ msgstr "Inyandikorugero Bya"

#, fuzzy
#~ msgid "Java method '%D' has non-Java return type `%T'"
#~ msgstr "Uburyo Garuka Ubwoko"

#, fuzzy
#~ msgid "Java method '%D' has non-Java parameter type `%T'"
#~ msgstr "Uburyo Ubwoko"

#, fuzzy
#~ msgid "prototype for `%#D' does not match any in class `%T'"
#~ msgstr "kugirango OYA BIHUYE in ishuri"

#, fuzzy
#~ msgid "local class `%#T' shall not have static data member `%#D'"
#~ msgstr "ishuri OYA Ibyatanzwe"

#, fuzzy
#~ msgid "initializer invalid for static member with constructor"
#~ msgstr "Sibyo kugirango Na:"

#, fuzzy
#~ msgid "(an out of class initialization is required)"
#~ msgstr "(Inyuma Bya ishuri ni Bya ngombwa"

#, fuzzy
#~ msgid "invalid data member initialization"
#~ msgstr "Sibyo Ibyatanzwe"

#, fuzzy
#~ msgid "(use `=' to initialize static data members)"
#~ msgstr "(Gukoresha Kuri gutangiza Ibyatanzwe"

#, fuzzy
#~ msgid "member `%D' conflicts with virtual function table field name"
#~ msgstr "Na: Kitaboneka Umumaro imbonerahamwe# Umwanya Izina:"

#, fuzzy
#~ msgid "`%D' is already defined in `%T'"
#~ msgstr "`%D'ni in"

#, fuzzy
#~ msgid "field initializer is not constant"
#~ msgstr "Umwanya ni OYA"

#, fuzzy
#~ msgid "`asm' specifiers are not permitted on non-static data members"
#~ msgstr "`OYA ku Ibyatanzwe"

#, fuzzy
#~ msgid "cannot declare `%D' to be a bit-field type"
#~ msgstr "Kuri a Umwanya Ubwoko"

#, fuzzy
#~ msgid "cannot declare bit-field `%D' with function type"
#~ msgstr "Umwanya Na: Umumaro Ubwoko"

#, fuzzy
#~ msgid "`%D' is already defined in the class %T"
#~ msgstr "`%D'ni in i ishuri"

#, fuzzy
#~ msgid "static member `%D' cannot be a bit-field"
#~ msgstr "a Umwanya"

#, fuzzy
#~ msgid "initializer specified for non-member function `%D'"
#~ msgstr "kugirango Umumaro"

#, fuzzy
#~ msgid "invalid initializer for virtual method `%D'"
#~ msgstr "Sibyo kugirango Kitaboneka Uburyo"

#, fuzzy
#~ msgid "anonymous struct not inside named type"
#~ msgstr "OYA Mo Imbere Ubwoko"

#, fuzzy
#~ msgid "namespace-scope anonymous aggregates must be static"
#~ msgstr "Ingano:"

#, fuzzy
#~ msgid "anonymous aggregate with no members"
#~ msgstr "Na: Oya"

#, fuzzy
#~ msgid "`operator new' must return type `%T'"
#~ msgstr "`Mukoresha Garuka Ubwoko"

#, fuzzy
#~ msgid "`operator new' takes type `size_t' (`%T') as first parameter"
#~ msgstr "`Mukoresha Ubwoko Nka Itangira"

#, fuzzy
#~ msgid "`operator delete' must return type `%T'"
#~ msgstr "`Mukoresha Garuka Ubwoko"

#, fuzzy
#~ msgid "`operator delete' takes type `%T' as first parameter"
#~ msgstr "`Mukoresha Ubwoko Nka Itangira"

#, fuzzy
#~ msgid "too many initialization functions required"
#~ msgstr "Imimaro Bya ngombwa"

#, fuzzy
#~ msgid "inline function `%D' used but never defined"
#~ msgstr "Mumurongo Umumaro Nta narimwe"

#, fuzzy
#~ msgid "use of old-style cast"
#~ msgstr "Gukoresha Bya ki/ bishaje IMISUSIRE"

#, fuzzy
#~ msgid "use of `%D' is ambiguous"
#~ msgstr "Gukoresha Bya ni"

#, fuzzy
#~ msgid "  first declared as `%#D' here"
#~ msgstr "Itangira Nka"

#, fuzzy
#~ msgid "  also declared as `%#D' here"
#~ msgstr "Nka"

#, fuzzy
#~ msgid "`%D' denotes an ambiguous type"
#~ msgstr "`%D'Ubwoko"

#, fuzzy
#~ msgid "  first type here"
#~ msgstr "Itangira Ubwoko"

#, fuzzy
#~ msgid "  other type here"
#~ msgstr "Ikindi Ubwoko"

#, fuzzy
#~ msgid "declaration of `%D' not in a namespace surrounding `%D'"
#~ msgstr "Bya OYA in a"

#, fuzzy
#~ msgid "`%D' should have been declared inside `%D'"
#~ msgstr "`%D'Mo Imbere"

#, fuzzy
#~ msgid "`%D' is not a function,"
#~ msgstr "`%D'ni OYA a Umumaro"

#, fuzzy
#~ msgid "  conflict with `%D'"
#~ msgstr "Na:"

#, fuzzy
#~ msgid "unknown namespace `%D'"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "`%T' is not a namespace"
#~ msgstr "`%T'ni OYA a"

#, fuzzy
#~ msgid "`%D' is not a namespace"
#~ msgstr "`%D'ni OYA a"

#, fuzzy
#~ msgid "a using-declaration cannot specify a template-id.  Try `using %D'"
#~ msgstr "a ikoresha a Inyandikorugero ID ikoresha"

#, fuzzy
#~ msgid "namespace `%D' not allowed in using-declaration"
#~ msgstr "OYA in ikoresha"

#, fuzzy
#~ msgid "`%D' not declared"
#~ msgstr "`%D'OYA"

#, fuzzy
#~ msgid "`%D' is already declared in this scope"
#~ msgstr "`%D'ni in iyi Ingano:"

#, fuzzy
#~ msgid "using declaration `%D' introduced ambiguous type `%T'"
#~ msgstr "ikoresha Ubwoko"

#, fuzzy
#~ msgid "using-declaration for non-member at class scope"
#~ msgstr "ikoresha kugirango ku ishuri Ingano:"

#, fuzzy
#~ msgid "using-declaration for destructor"
#~ msgstr "ikoresha kugirango"

#, fuzzy
#~ msgid "a using-declaration cannot specify a template-id.  Try  `using %T::%D'"
#~ msgstr "a ikoresha a Inyandikorugero ID ikoresha"

#, fuzzy
#~ msgid "default argument missing for parameter %P of `%+#D'"
#~ msgstr "Mburabuzi Ibuze kugirango Bya"

#, fuzzy
#~ msgid "extra qualification `%T::' on member `%D' ignored"
#~ msgstr "Birenga ku"

#, fuzzy
#~ msgid "`%T' does not have a class or union named `%D'"
#~ msgstr "`%T'OYA a ishuri Cyangwa Ihuza"

#, fuzzy
#~ msgid "`%T' is not a class or union type"
#~ msgstr "`%T'ni OYA a ishuri Cyangwa Ihuza Ubwoko"

#, fuzzy
#~ msgid "template argument is required for `%T'"
#~ msgstr "Inyandikorugero ni Bya ngombwa kugirango"

#, fuzzy
#~ msgid "declaration of `%D' in `%D' which does not enclose `%D'"
#~ msgstr "Bya in OYA"

#, fuzzy
#~ msgid "`%s' not supported by %s"
#~ msgstr "`%s'OYA ku"

#, fuzzy
#~ msgid "(static %s for %s)"
#~ msgstr "(kugirango"

# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
#, fuzzy
#~ msgid "\\x%x"
#~ msgstr "\\x%x"

# vcl/source\src\units.src:SV_FUNIT_STRINGS.10.text
#, fuzzy
#~ msgid "In %s `%s':"
#~ msgstr "in"

#, fuzzy
#~ msgid "%s: In instantiation of `%s':\n"
#~ msgstr "%s:Bya"

#, fuzzy
#~ msgid "%s:%d:   instantiated from `%s'\n"
#~ msgstr "%s:%d:Bivuye"

#, fuzzy
#~ msgid "%s:%d:   instantiated from here\n"
#~ msgstr "%s:%d:Bivuye"

#, fuzzy
#~ msgid "unexpected letter `%c' in locate_error\n"
#~ msgstr "Ibaruwa... in"

#, fuzzy
#~ msgid "type `%T' is disallowed in Java `throw' or `catch'"
#~ msgstr "Ubwoko ni in Cyangwa"

#, fuzzy
#~ msgid "call to Java `catch' or `throw' with `jthrowable' undefined"
#~ msgstr "Kuri Cyangwa Na: kidasobanuye"

#, fuzzy
#~ msgid "type `%T' is not derived from `java::lang::Throwable'"
#~ msgstr "Ubwoko ni OYA Bivuye java"

#, fuzzy
#~ msgid "mixing C++ and Java catches in a single translation unit"
#~ msgstr "C Na in a UMWE Umwandiko wahinduwe ururimi Igice:"

#, fuzzy
#~ msgid "throwing NULL, which has integral, not pointer type"
#~ msgstr "Umubare Wuzuye OYA Mweretsi Ubwoko"

#, fuzzy
#~ msgid "  in thrown expression"
#~ msgstr "in imvugo"

#, fuzzy
#~ msgid "expression '%E' of abstract class type '%T' cannot be used in throw-expression"
#~ msgstr "imvugo Bya Incamake ishuri Ubwoko in imvugo"

#, fuzzy
#~ msgid "exception of type `%T' will be caught"
#~ msgstr "Irengayobora(-) Bya Ubwoko"

#, fuzzy
#~ msgid "   by earlier handler for `%T'"
#~ msgstr "ku kugirango"

#, fuzzy
#~ msgid "`...' handler must be the last handler for its try block"
#~ msgstr "`...'i Iheruka kugirango Funga"

#, fuzzy
#~ msgid "`%D' is already a friend of class `%T'"
#~ msgstr "`%D'ni a Bya ishuri"

#, fuzzy
#~ msgid "previous friend declaration of `%D'"
#~ msgstr "Ibanjirije Bya"

#, fuzzy
#~ msgid "invalid type `%T' declared `friend'"
#~ msgstr "Sibyo Ubwoko"

#, fuzzy
#~ msgid "partial specialization `%T' declared `friend'"
#~ msgstr "Bituzuye"

#, fuzzy
#~ msgid "class `%T' is implicitly friends with itself"
#~ msgstr "ishuri ni Na:"

#, fuzzy
#~ msgid "typename type `%#T' declared `friend'"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "template parameter type `%T' declared `friend'"
#~ msgstr "Inyandikorugero Ubwoko"

#, fuzzy
#~ msgid "`%#T' is not a template"
#~ msgstr "`%#T'ni OYA a Inyandikorugero"

#, fuzzy
#~ msgid "`%T' is already a friend of `%T'"
#~ msgstr "`%T'ni a Bya"

#, fuzzy
#~ msgid "member `%D' declared as friend before type `%T' defined"
#~ msgstr "Nka Mbere Ubwoko"

#, fuzzy
#~ msgid "friend declaration `%#D' declares a non-template function"
#~ msgstr "a Inyandikorugero Umumaro"

#, fuzzy
#~ msgid "(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) -Wno-non-template-friend disables this warning"
#~ msgstr "(NIBA iyi ni OYA Ubwoko i Umumaro Inyandikorugero Na Kongeramo Nyuma i Umumaro Izina: Inyandikorugero iyi Iburira"

#, fuzzy
#~ msgid "argument to `%s' missing\n"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "`%D' should be initialized in the member initialization list"
#~ msgstr "`%D'in i Urutonde"

#, fuzzy
#~ msgid "default-initialization of `%#D', which has reference type"
#~ msgstr "Mburabuzi Bya Indango Ubwoko"

#, fuzzy
#~ msgid "uninitialized reference member `%D'"
#~ msgstr "Itatangijwe Indango"

#, fuzzy
#~ msgid "initializer list treated as compound expression"
#~ msgstr "Urutonde Nka imvugo"

#, fuzzy
#~ msgid "`%D' will be initialized after"
#~ msgstr "`%D'Nyuma"

#, fuzzy
#~ msgid "base `%T' will be initialized after"
#~ msgstr "SHINGIRO Nyuma"

# desktop/source\app\ssodlg.src:DLG_SSOLOGIN.text
#, fuzzy
#~ msgid "  `%#D'"
#~ msgstr "`%#D'"

# sc/source\core\src\compiler.src:RID_SC_FUNCTION_NAMES.SC_OPCODE_BASE.text
#, fuzzy
#~ msgid "  base `%T'"
#~ msgstr "SHINGIRO"

#, fuzzy
#~ msgid "multiple initializations given for base `%T'"
#~ msgstr "Igikubo kugirango SHINGIRO"

#, fuzzy
#~ msgid "initializations for multiple members of `%T'"
#~ msgstr "kugirango Igikubo Bya"

#, fuzzy
#~ msgid "base class `%#T' should be explicitly initialized in the copy constructor"
#~ msgstr "SHINGIRO ishuri in i Gukoporora"

#, fuzzy
#~ msgid "class `%T' does not have any field named `%D'"
#~ msgstr "ishuri OYA Umwanya"

#, fuzzy
#~ msgid "field `%#D' is static; the only point of initialization is its definition"
#~ msgstr "Umwanya ni i Akadomo Bya ni Insobanuro"

#, fuzzy
#~ msgid "unnamed initializer for `%T', which has no base classes"
#~ msgstr "Kitiswe kugirango Oya SHINGIRO Inzego"

#, fuzzy
#~ msgid "unnamed initializer for `%T', which uses multiple inheritance"
#~ msgstr "Kitiswe kugirango Igikubo"

#, fuzzy
#~ msgid "type `%D' is not a direct or virtual base of `%T'"
#~ msgstr "Ubwoko ni OYA a Cyangwa Kitaboneka SHINGIRO Bya"

#, fuzzy
#~ msgid "type `%D' is not a direct base of `%T'"
#~ msgstr "Ubwoko ni OYA a SHINGIRO Bya"

#, fuzzy
#~ msgid "bad array initializer"
#~ msgstr "Imbonerahamwe"

#, fuzzy
#~ msgid "`%T' is not an aggregate type"
#~ msgstr "`%T'ni OYA Ubwoko"

#, fuzzy
#~ msgid "`%T' fails to be an aggregate typedef"
#~ msgstr "`%T'Kuri"

#, fuzzy
#~ msgid "type `%T' is of non-aggregate type"
#~ msgstr "Ubwoko ni Bya Ubwoko"

#, fuzzy
#~ msgid "cannot call destructor `%T::~%T' without object"
#~ msgstr "Igikoresho"

#, fuzzy
#~ msgid "invalid use of non-static field `%D'"
#~ msgstr "Sibyo Gukoresha Bya Umwanya"

#, fuzzy
#~ msgid "invalid use of member `%D'"
#~ msgstr "Sibyo Gukoresha Bya"

#, fuzzy
#~ msgid "no method `%T::%D'"
#~ msgstr "Oya Uburyo"

#, fuzzy
#~ msgid "incomplete type `%T' does not have member `%D'"
#~ msgstr "Ubwoko OYA"

#, fuzzy
#~ msgid "`%D' is not a member of type `%T'"
#~ msgstr "`%D'ni OYA a Bya Ubwoko"

#, fuzzy
#~ msgid "invalid pointer to bit-field `%D'"
#~ msgstr "Sibyo Mweretsi Kuri Umwanya"

#, fuzzy
#~ msgid "object missing in use of pointer-to-member construct"
#~ msgstr "Igikoresho Ibuze in Gukoresha Bya Mweretsi Kuri"

#, fuzzy
#~ msgid "member `%D' is non-static but referenced as a static member"
#~ msgstr "ni Nka a"

#, fuzzy
#~ msgid "at this point in file"
#~ msgstr "ku iyi Akadomo in IDOSIYE"

#, fuzzy
#~ msgid "object missing in `%E'"
#~ msgstr "Igikoresho Ibuze in"

#, fuzzy
#~ msgid "new of array type fails to specify size"
#~ msgstr "Gishya Bya Imbonerahamwe Ubwoko Kuri Ingano"

#, fuzzy
#~ msgid "size in array new must have integral type"
#~ msgstr "Ingano in Imbonerahamwe Gishya Umubare Wuzuye Ubwoko"

#, fuzzy
#~ msgid "zero size array reserves no space"
#~ msgstr "Zeru Ingano Imbonerahamwe Oya Umwanya"

#, fuzzy
#~ msgid "new cannot be applied to a reference type"
#~ msgstr "Gishya Byashyizweho Kuri a Indango Ubwoko"

#, fuzzy
#~ msgid "new cannot be applied to a function type"
#~ msgstr "Gishya Byashyizweho Kuri a Umumaro Ubwoko"

#, fuzzy
#~ msgid "call to Java constructor, while `jclass' undefined"
#~ msgstr "Kuri kidasobanuye"

#, fuzzy
#~ msgid "can't find class$"
#~ msgstr "Gushaka ishuri"

#, fuzzy
#~ msgid "invalid type `void' for new"
#~ msgstr "Sibyo Ubwoko kugirango Gishya"

#, fuzzy
#~ msgid "call to Java constructor with `%s' undefined"
#~ msgstr "Kuri Na: kidasobanuye"

#, fuzzy
#~ msgid "ISO C++ forbids initialization in array new"
#~ msgstr "C in Imbonerahamwe Gishya"

#, fuzzy
#~ msgid "initializer list being treated as compound expression"
#~ msgstr "Urutonde Nka imvugo"

#, fuzzy
#~ msgid "ISO C++ forbids aggregate initializer to new"
#~ msgstr "C Kuri Gishya"

#, fuzzy
#~ msgid "uninitialized const in `new' of `%#T'"
#~ msgstr "Itatangijwe in Bya"

#, fuzzy
#~ msgid "cannot initialize multi-dimensional array with initializer"
#~ msgstr "gutangiza Imbonerahamwe Na:"

#, fuzzy
#~ msgid "unknown array size in delete"
#~ msgstr "Kitazwi Imbonerahamwe Ingano in Gusiba"

#, fuzzy
#~ msgid "type to vector delete is neither pointer or array type"
#~ msgstr "Ubwoko Kuri Gusiba ni Mweretsi Cyangwa Imbonerahamwe Ubwoko"

#, fuzzy
#~ msgid "type name expected before `*'"
#~ msgstr "Ubwoko Izina: Ikitezwe: Mbere"

#, fuzzy
#~ msgid "cannot declare references to references"
#~ msgstr "Indango Kuri Indango"

#, fuzzy
#~ msgid "cannot declare pointers to references"
#~ msgstr "Kuri Indango"

#, fuzzy
#~ msgid "type name expected before `&'"
#~ msgstr "Ubwoko Izina: Ikitezwe: Mbere"

#, fuzzy
#~ msgid "semicolon missing after %s declaration"
#~ msgstr "Akabago n'Akitso Ibuze Nyuma"

#, fuzzy
#~ msgid "semicolon missing after declaration of `%T'"
#~ msgstr "Akabago n'Akitso Ibuze Nyuma Bya"

#, fuzzy
#~ msgid "junk at end of #pragma %s"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "invalid #pragma %s"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "#pragma vtable no longer supported"
#~ msgstr "#Oya"

#, fuzzy
#~ msgid "#pragma implementation for %s appears after file is included"
#~ msgstr "#kugirango Nyuma IDOSIYE ni"

#, fuzzy
#~ msgid "junk at end of #pragma GCC java_exceptions"
#~ msgstr "Umwanda ku Impera Bya"

#, fuzzy
#~ msgid "`%D' not defined"
#~ msgstr "`%D'Bitasobanutse>"

#, fuzzy
#~ msgid "`%D' was not declared in this scope"
#~ msgstr "`%D'OYA in iyi Ingano:"

#, fuzzy
#~ msgid "`%D' undeclared (first use this function)"
#~ msgstr "`%D'Itangira Gukoresha iyi Umumaro"

#, fuzzy
#~ msgid "(Each undeclared identifier is reported only once for each function it appears in.)"
#~ msgstr "(Ikiranga ni Rimwe kugirango Umumaro in"

#, fuzzy
#~ msgid "`::%D' undeclared (first use here)"
#~ msgstr "`::%D'Itangira Gukoresha"

#, fuzzy
#~ msgid "real-valued template parameters when cross-compiling"
#~ msgstr "Inyandikorugero Ibigenga Ryari: Kwambukiranya"

#, fuzzy
#~ msgid "the mangled name of `%D' will change in a future version of GCC"
#~ msgstr "i Izina: Bya Guhindura>> in a Verisiyo Bya"

#, fuzzy
#~ msgid "due to a defect in the G++ 3.2 ABI, G++ has assigned the same mangled name to two different types"
#~ msgstr "Kuri a in i 3. 2. i Izina: Kuri"

#, fuzzy
#~ msgid "invalid use of member `%D' in static member function"
#~ msgstr "Sibyo Gukoresha Bya in Umumaro"

#, fuzzy
#~ msgid "use of namespace `%D' as expression"
#~ msgstr "Gukoresha Bya Nka imvugo"

#, fuzzy
#~ msgid "use of class template `%T' as expression"
#~ msgstr "Gukoresha Bya ishuri Inyandikorugero Nka imvugo"

#, fuzzy
#~ msgid "use of %s from containing function"
#~ msgstr "Gukoresha Bya Bivuye Umumaro"

#, fuzzy
#~ msgid "request for member `%D' is ambiguous in multiple inheritance lattice"
#~ msgstr "Kubaza... kugirango ni in Igikubo"

#, fuzzy
#~ msgid "generic thunk code fails for method `%#D' which uses `...'"
#~ msgstr "Gifitanye isano ITEGEKONGENGA kugirango Uburyo"

#, fuzzy
#~ msgid "non-static const member `%#D', can't use default assignment operator"
#~ msgstr "Gukoresha Mburabuzi Igenera Mukoresha"

#, fuzzy
#~ msgid "non-static reference member `%#D', can't use default assignment operator"
#~ msgstr "Indango Gukoresha Mburabuzi Igenera Mukoresha"

#, fuzzy
#~ msgid "`%s' tag used in naming `%#T'"
#~ msgstr "`%s'Itagi: in"

#, fuzzy
#~ msgid "keyword `export' not implemented, and will be ignored"
#~ msgstr "Ijambo- banze OYA Na"

#, fuzzy
#~ msgid "use of linkage spec `%D' is different from previous spec `%D'"
#~ msgstr "Gukoresha Bya ni Bivuye Ibanjirije"

#, fuzzy
#~ msgid "no base or member initializers given following ':'"
#~ msgstr "Oya SHINGIRO Cyangwa"

#, fuzzy
#~ msgid "anachronistic old style base class initializer"
#~ msgstr "ki/ bishaje IMISUSIRE SHINGIRO ishuri"

#, fuzzy
#~ msgid "`>>' should be `> >' in template class name"
#~ msgstr "`>>'in Inyandikorugero ishuri Izina:"

#, fuzzy
#~ msgid "use of template qualifier outside template"
#~ msgstr "Gukoresha Bya Inyandikorugero Hanze Inyandikorugero"

#, fuzzy
#~ msgid "ISO C++ forbids an empty condition for `%s'"
#~ msgstr "C ubusa Ibisabwa kugirango"

#, fuzzy
#~ msgid "definition of class `%T' in condition"
#~ msgstr "Insobanuro Bya ishuri in Ibisabwa"

#, fuzzy
#~ msgid "definition of enum `%T' in condition"
#~ msgstr "Insobanuro Bya in Ibisabwa"

#, fuzzy
#~ msgid "definition of array `%#D' in condition"
#~ msgstr "Insobanuro Bya Imbonerahamwe in Ibisabwa"

#, fuzzy
#~ msgid "old style placement syntax, use () instead"
#~ msgstr "ki/ bishaje IMISUSIRE Ishyira mu mwanya Gukoresha"

#, fuzzy
#~ msgid "`%T' is not a valid expression"
#~ msgstr "`%T'ni OYA a Byemewe imvugo"

#, fuzzy
#~ msgid "initialization of new expression with `='"
#~ msgstr "Bya Gishya imvugo Na:"

#, fuzzy
#~ msgid "ISO C++ forbids compound literals"
#~ msgstr "C"

#, fuzzy
#~ msgid "ISO C++ forbids braced-groups within expressions"
#~ msgstr "C Amatsinda muri"

#, fuzzy
#~ msgid "sigof type specifier"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "`sigof' applied to non-aggregate expression"
#~ msgstr "`Byashyizweho Kuri imvugo"

#, fuzzy
#~ msgid "`sigof' applied to non-aggregate type"
#~ msgstr "`Byashyizweho Kuri Ubwoko"

#, fuzzy
#~ msgid "using `typename' outside of template"
#~ msgstr "ikoresha Hanze Bya Inyandikorugero"

#, fuzzy
#~ msgid "storage class specifier `%s' not allowed after struct or class"
#~ msgstr "ishuri OYA Nyuma Cyangwa ishuri"

#, fuzzy
#~ msgid "type specifier `%s' not allowed after struct or class"
#~ msgstr "Ubwoko OYA Nyuma Cyangwa ishuri"

#, fuzzy
#~ msgid "type qualifier `%s' not allowed after struct or class"
#~ msgstr "Ubwoko OYA Nyuma Cyangwa ishuri"

#, fuzzy
#~ msgid "no body nor ';' separates two class, struct or union declarations"
#~ msgstr "Oya Umubiri ishuri Cyangwa Ihuza"

#, fuzzy
#~ msgid "no bases given following `:'"
#~ msgstr "Oya"

#, fuzzy
#~ msgid "multiple access specifiers"
#~ msgstr "Igikubo"

#, fuzzy
#~ msgid "multiple `virtual' specifiers"
#~ msgstr "Igikubo"

#, fuzzy
#~ msgid "missing ';' before right brace"
#~ msgstr "Ibuze Mbere Iburyo:"

#, fuzzy
#~ msgid "ISO C++ forbids array dimensions with parenthesized type in new"
#~ msgstr "C Imbonerahamwe Ingero Na: Ubwoko in Gishya"

#, fuzzy
#~ msgid "`%T' is not a class or namespace"
#~ msgstr "`%T'ni OYA a ishuri Cyangwa"

#, fuzzy
#~ msgid "ISO C++ forbids label declarations"
#~ msgstr "C Akarango"

#, fuzzy
#~ msgid "ISO C++ forbids computed gotos"
#~ msgstr "C"

#, fuzzy
#~ msgid "label must be followed by statement"
#~ msgstr "Akarango ku Inyandiko"

#, fuzzy
#~ msgid "must have at least one catch per try block"
#~ msgstr "ku Funga"

#, fuzzy
#~ msgid "ISO C++ forbids compound statements inside for initializations"
#~ msgstr "C Mo Imbere kugirango"

#, fuzzy
#~ msgid "possibly missing ')'"
#~ msgstr "Ibuze"

#, fuzzy
#~ msgid "type specifier omitted for parameter"
#~ msgstr "Ubwoko kugirango"

#, fuzzy
#~ msgid "`%E' is not a type, use `typename %E' to make it one"
#~ msgstr "`%E'ni OYA a Ubwoko Gukoresha Kuri Ubwoko"

#, fuzzy
#~ msgid "no type `%D' in `%T'"
#~ msgstr "Oya Ubwoko in"

#, fuzzy
#~ msgid "type specifier omitted for parameter `%E'"
#~ msgstr "Ubwoko kugirango"

#, fuzzy
#~ msgid "'%D' is used as a type, but is not defined as a type."
#~ msgstr "'%D'ni Nka a Ubwoko ni OYA Nka a Ubwoko"

#, fuzzy
#~ msgid "data member `%D' cannot be a member template"
#~ msgstr "Ibyatanzwe a Inyandikorugero"

#, fuzzy
#~ msgid "invalid member template declaration `%D'"
#~ msgstr "Sibyo Inyandikorugero"

#, fuzzy
#~ msgid "explicit specialization in non-namespace scope `%D'"
#~ msgstr "in Ingano:"

#, fuzzy
#~ msgid "enclosing class templates are not explicitly specialized"
#~ msgstr "ishuri Inyandikorugero OYA cy'umwihariko/ mwihariko"

#, fuzzy
#~ msgid "specializing `%#T' in different namespace"
#~ msgstr "in"

#, fuzzy
#~ msgid "  from definition of `%#D'"
#~ msgstr "Bivuye Insobanuro Bya"

#, fuzzy
#~ msgid "specialization of `%T' after instantiation"
#~ msgstr "Bya Nyuma"

#, fuzzy
#~ msgid "specialization `%T' after instantiation `%T'"
#~ msgstr "Nyuma"

#, fuzzy
#~ msgid "explicit specialization of non-template `%T'"
#~ msgstr "Bya Inyandikorugero"

#, fuzzy
#~ msgid "specialization of %D after instantiation"
#~ msgstr "Bya Nyuma"

# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
#, fuzzy
#~ msgid "%s %+#D"
#~ msgstr "%s%+#D"

#, fuzzy
#~ msgid "`%D' is not a function template"
#~ msgstr "`%D'ni OYA a Umumaro Inyandikorugero"

#, fuzzy
#~ msgid "template-id `%D' for `%+D' does not match any template declaration"
#~ msgstr "Inyandikorugero ID kugirango OYA BIHUYE Inyandikorugero"

#, fuzzy
#~ msgid "ambiguous template specialization `%D' for `%+D'"
#~ msgstr "Inyandikorugero kugirango"

#, fuzzy
#~ msgid "template-id `%D' in declaration of primary template"
#~ msgstr "Inyandikorugero ID in Bya Inyandikorugero"

#, fuzzy
#~ msgid "template parameter list used in explicit instantiation"
#~ msgstr "Inyandikorugero Urutonde in"

#, fuzzy
#~ msgid "definition provided for explicit instantiation"
#~ msgstr "Insobanuro kugirango"

#, fuzzy
#~ msgid "too many template parameter lists in declaration of `%D'"
#~ msgstr "Inyandikorugero Intonde in Bya"

#, fuzzy
#~ msgid "too few template parameter lists in declaration of `%D'"
#~ msgstr "Inyandikorugero Intonde in Bya"

#, fuzzy
#~ msgid "explicit specialization not preceded by `template <>'"
#~ msgstr "OYA ku Inyandikorugero"

#, fuzzy
#~ msgid "partial specialization `%D' of function template"
#~ msgstr "Bituzuye Bya Umumaro Inyandikorugero"

#, fuzzy
#~ msgid "default argument specified in explicit specialization"
#~ msgstr "Mburabuzi in"

#, fuzzy
#~ msgid "template specialization with C linkage"
#~ msgstr "Inyandikorugero Na: C"

#, fuzzy
#~ msgid "specialization of implicitly-declared special member function"
#~ msgstr "Bya Bidasanzwe Umumaro"

#, fuzzy
#~ msgid "no member function `%D' declared in `%T'"
#~ msgstr "Oya Umumaro in"

#, fuzzy
#~ msgid "too many template parameter lists in declaration of `%T'"
#~ msgstr "Inyandikorugero Intonde in Bya"

#, fuzzy
#~ msgid " shadows template parm `%#D'"
#~ msgstr "Inyandikorugero"

#, fuzzy
#~ msgid "template parameters not used in partial specialization:"
#~ msgstr "Inyandikorugero Ibigenga OYA in Bituzuye"

# desktop/source\app\ssodlg.src:DLG_SSOLOGIN.text
#, fuzzy
#~ msgid "        `%D'"
#~ msgstr "`%D'"

#, fuzzy
#~ msgid "partial specialization `%T' does not specialize any template arguments"
#~ msgstr "Bituzuye OYA Inyandikorugero ingingo"

#, fuzzy
#~ msgid "template argument `%E' involves template parameter(s)"
#~ msgstr "Inyandikorugero Inyandikorugero S"

#, fuzzy
#~ msgid "type `%T' of template argument `%E' depends on template parameter(s)"
#~ msgstr "Ubwoko Bya Inyandikorugero ku Inyandikorugero S"

#, fuzzy
#~ msgid "no default argument for `%D'"
#~ msgstr "Oya Mburabuzi kugirango"

#, fuzzy
#~ msgid "template with C linkage"
#~ msgstr "Inyandikorugero Na: C"

#, fuzzy
#~ msgid "template class without a name"
#~ msgstr "Inyandikorugero ishuri a Izina:"

#, fuzzy
#~ msgid "`%D' does not declare a template type"
#~ msgstr "`%D'OYA a Inyandikorugero Ubwoko"

#, fuzzy
#~ msgid "template definition of non-template `%#D'"
#~ msgstr "Inyandikorugero Insobanuro Bya Inyandikorugero"

#, fuzzy
#~ msgid "expected %d levels of template parms for `%#D', got %d"
#~ msgstr "Ikitezwe: Intera Bya Inyandikorugero kugirango"

#, fuzzy
#~ msgid "got %d template parameters for `%#D'"
#~ msgstr "Inyandikorugero Ibigenga kugirango"

#, fuzzy
#~ msgid "got %d template parameters for `%#T'"
#~ msgstr "Inyandikorugero Ibigenga kugirango"

#, fuzzy
#~ msgid "  but %d required"
#~ msgstr "Bya ngombwa"

#, fuzzy
#~ msgid "`%T' is not a template type"
#~ msgstr "`%T'ni OYA a Inyandikorugero Ubwoko"

#, fuzzy
#~ msgid "previous declaration `%D'"
#~ msgstr "Ibanjirije"

#, fuzzy
#~ msgid "used %d template parameter%s instead of %d"
#~ msgstr "Inyandikorugero Bya"

#, fuzzy
#~ msgid "template parameter `%#D'"
#~ msgstr "Inyandikorugero"

#, fuzzy
#~ msgid "redeclared here as `%#D'"
#~ msgstr "Nka"

#, fuzzy
#~ msgid "redefinition of default argument for `%#D'"
#~ msgstr "Bya Mburabuzi kugirango"

#, fuzzy
#~ msgid "  original definition appeared here"
#~ msgstr "Umwimerere Insobanuro"

#, fuzzy
#~ msgid "`%E' is not a valid template argument"
#~ msgstr "`%E'ni OYA a Byemewe Inyandikorugero"

#, fuzzy
#~ msgid "it must be the address of a function with external linkage"
#~ msgstr "i Aderesi Bya a Umumaro Na: external"

#, fuzzy
#~ msgid "it must be the address of an object with external linkage"
#~ msgstr "i Aderesi Bya Igikoresho Na: external"

#, fuzzy
#~ msgid "it must be a pointer-to-member of the form `&X::Y'"
#~ msgstr "a Mweretsi Kuri Bya i Ifishi"

#, fuzzy
#~ msgid "string literal %E is not a valid template argument because it is the address of an object with static linkage"
#~ msgstr "Ikurikiranyanyuguti ni OYA a Byemewe Inyandikorugero ni i Aderesi Bya Igikoresho Na:"

#, fuzzy
#~ msgid "address of non-extern `%E' cannot be used as template argument"
#~ msgstr "Aderesi Bya Nka Inyandikorugero"

#, fuzzy
#~ msgid "non-constant `%E' cannot be used as template argument"
#~ msgstr "Nka Inyandikorugero"

#, fuzzy
#~ msgid "object `%E' cannot be used as template argument"
#~ msgstr "Igikoresho Nka Inyandikorugero"

#, fuzzy
#~ msgid "to refer to a type member of a template parameter, use `typename %E'"
#~ msgstr "Kuri Kuri a Ubwoko Bya a Inyandikorugero Gukoresha"

#, fuzzy
#~ msgid "type/value mismatch at argument %d in template parameter list for `%D'"
#~ msgstr "Ubwoko Agaciro ku in Inyandikorugero Urutonde kugirango"

#, fuzzy
#~ msgid "  expected a constant of type `%T', got `%T'"
#~ msgstr "Ikitezwe: a Bya Ubwoko"

#, fuzzy
#~ msgid "  expected a type, got `%E'"
#~ msgstr "Ikitezwe: a Ubwoko"

#, fuzzy
#~ msgid "  expected a type, got `%T'"
#~ msgstr "Ikitezwe: a Ubwoko"

#, fuzzy
#~ msgid "  expected a class template, got `%T'"
#~ msgstr "Ikitezwe: a ishuri Inyandikorugero"

#, fuzzy
#~ msgid "  expected a template of type `%D', got `%D'"
#~ msgstr "Ikitezwe: a Inyandikorugero Bya Ubwoko"

#, fuzzy
#~ msgid "template-argument `%T' uses anonymous type"
#~ msgstr "Inyandikorugero Ubwoko"

#, fuzzy
#~ msgid "template-argument `%T' uses local type `%T'"
#~ msgstr "Inyandikorugero Ubwoko"

#, fuzzy
#~ msgid "template-argument `%T' is a variably modified type"
#~ msgstr "Inyandikorugero ni a Byahinduwe Ubwoko"

#, fuzzy
#~ msgid "could not convert template argument `%E' to `%T'"
#~ msgstr "OYA GUHINDURA Inyandikorugero Kuri"

#, fuzzy
#~ msgid "wrong number of template arguments (%d, should be %d)"
#~ msgstr "Umubare Bya Inyandikorugero ingingo"

#, fuzzy
#~ msgid "provided for `%D'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "template argument %d is invalid"
#~ msgstr "Inyandikorugero ni Sibyo"

#, fuzzy
#~ msgid "non-template used as template"
#~ msgstr "Inyandikorugero Nka Inyandikorugero"

#, fuzzy
#~ msgid "`%T' is not a template"
#~ msgstr "`%T'ni OYA a Inyandikorugero"

#, fuzzy
#~ msgid "non-template type `%T' used as a template"
#~ msgstr "Inyandikorugero Ubwoko Nka a Inyandikorugero"

#, fuzzy
#~ msgid "for template declaration `%D'"
#~ msgstr "kugirango Inyandikorugero"

#, fuzzy
#~ msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth-NN to increase the maximum) instantiating `%D'"
#~ msgstr "Inyandikorugero Ubujyakuzimu Kinini Bya Gukoresha Ubujyakuzimu Kuri i Kinini"

#, fuzzy
#~ msgid "ambiguous class template instantiation for `%#T'"
#~ msgstr "ishuri Inyandikorugero kugirango"

# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
# #-#-#-#-#  dbaccess.pot (PACKAGE VERSION)  #-#-#-#-#
#, fuzzy
#~ msgid "%s %+#T"
#~ msgstr "%s%+#T"

#, fuzzy
#~ msgid "instantiation of `%D' as type `%T'"
#~ msgstr "Bya Nka Ubwoko"

#, fuzzy
#~ msgid "invalid parameter type `%T'"
#~ msgstr "Sibyo Ubwoko"

#, fuzzy
#~ msgid "in declaration `%D'"
#~ msgstr "in"

#, fuzzy
#~ msgid "creating pointer to member function of non-class type `%T'"
#~ msgstr "Mweretsi Kuri Umumaro Bya ishuri Ubwoko"

#, fuzzy
#~ msgid "creating array with size zero"
#~ msgstr "Imbonerahamwe Na: Ingano Zeru"

#, fuzzy
#~ msgid "creating array with size zero (`%E')"
#~ msgstr "Imbonerahamwe Na: Ingano Zeru"

#, fuzzy
#~ msgid "forming reference to void"
#~ msgstr "Indango Kuri"

#, fuzzy
#~ msgid "forming %s to reference type `%T'"
#~ msgstr "Kuri Indango Ubwoko"

#, fuzzy
#~ msgid "creating pointer to member of non-class type `%T'"
#~ msgstr "Mweretsi Kuri Bya ishuri Ubwoko"

#, fuzzy
#~ msgid "creating pointer to member reference type `%T'"
#~ msgstr "Mweretsi Kuri Indango Ubwoko"

#, fuzzy
#~ msgid "creating array of `%T'"
#~ msgstr "Imbonerahamwe Bya"

#, fuzzy
#~ msgid "`%T' is not a class, struct, or union type"
#~ msgstr "`%T'ni OYA a ishuri Cyangwa Ihuza Ubwoko"

#, fuzzy
#~ msgid "use of `%s' in template"
#~ msgstr "Gukoresha Bya in Inyandikorugero"

#, fuzzy
#~ msgid "type `%T' composed from a local class is not a valid template-argument"
#~ msgstr "Ubwoko Bivuye a ishuri ni OYA a Byemewe Inyandikorugero"

#, fuzzy
#~ msgid "  trying to instantiate `%D'"
#~ msgstr "Kuri"

#, fuzzy
#~ msgid "incomplete type unification"
#~ msgstr "Ubwoko"

#, fuzzy
#~ msgid "use of `%s' in template type unification"
#~ msgstr "Gukoresha Bya in Inyandikorugero Ubwoko"

#, fuzzy
#~ msgid "explicit instantiation of non-template `%#D'"
#~ msgstr "Bya Inyandikorugero"

#, fuzzy
#~ msgid "no matching template for `%D' found"
#~ msgstr "Oya Inyandikorugero kugirango Byabonetse"

#, fuzzy
#~ msgid "explicit instantiation of `%#D'"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "duplicate explicit instantiation of `%#D'"
#~ msgstr "Gusubiramo Bya"

#, fuzzy
#~ msgid "ISO C++ forbids the use of `extern' on explicit instantiations"
#~ msgstr "C i Gukoresha Bya ku"

#, fuzzy
#~ msgid "storage class `%D' applied to template instantiation"
#~ msgstr "ishuri Byashyizweho Kuri Inyandikorugero"

#, fuzzy
#~ msgid "explicit instantiation of non-template type `%T'"
#~ msgstr "Bya Inyandikorugero Ubwoko"

#, fuzzy
#~ msgid "explicit instantiation of `%#T' before definition of template"
#~ msgstr "Bya Mbere Insobanuro Bya Inyandikorugero"

#, fuzzy
#~ msgid "ISO C++ forbids the use of `%s' on explicit instantiations"
#~ msgstr "C i Gukoresha Bya ku"

#, fuzzy
#~ msgid "duplicate explicit instantiation of `%#T'"
#~ msgstr "Gusubiramo Bya"

#, fuzzy
#~ msgid "explicit instantiation of `%D' but no definition available"
#~ msgstr "Bya Oya Insobanuro Bihari"

#, fuzzy
#~ msgid "`%#T' is not a valid type for a template constant parameter"
#~ msgstr "`%#T'ni OYA a Byemewe Ubwoko kugirango a Inyandikorugero"

#, fuzzy
#~ msgid "-frepo must be used with -c"
#~ msgstr "-Na: C"

#, fuzzy
#~ msgid "mysterious repository information in %s"
#~ msgstr "Ibisobanuro in"

#, fuzzy
#~ msgid "can't create repository information file `%s'"
#~ msgstr "Kurema Ibisobanuro IDOSIYE"

#, fuzzy
#~ msgid "cannot use typeid with -fno-rtti"
#~ msgstr "Gukoresha Na:"

#, fuzzy
#~ msgid "must #include <typeinfo> before using typeid"
#~ msgstr "Gushyiramo Mbere ikoresha"

#, fuzzy
#~ msgid "cannot create type information for type `%T' because its size is variable"
#~ msgstr "Kurema Ubwoko Ibisobanuro kugirango Ubwoko Ingano ni IMPINDURAGACIRO"

#, fuzzy
#~ msgid "dynamic_cast of `%#D' to `%#T' can never succeed"
#~ msgstr "Bya Kuri Nta narimwe"

#, fuzzy
#~ msgid "cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)"
#~ msgstr "Bya Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "`%T' is an inaccessible base of `%T'"
#~ msgstr "`%T'ni SHINGIRO Bya"

#, fuzzy
#~ msgid "`%T' is an ambiguous base of `%T'"
#~ msgstr "`%T'ni SHINGIRO Bya"

#, fuzzy
#~ msgid "assignment to non-static member `%D' of enclosing class `%T'"
#~ msgstr "Igenera Kuri Bya ishuri"

#, fuzzy
#~ msgid "adjusting pointers for covariant returns"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "invalid covariant return type for `%#D'"
#~ msgstr "Sibyo Garuka Ubwoko kugirango"

#, fuzzy
#~ msgid "  overriding `%#D' (must be pointer or reference to class)"
#~ msgstr "Mweretsi Cyangwa Indango Kuri ishuri"

#, fuzzy
#~ msgid "  overriding `%#D' (must use pointer or reference)"
#~ msgstr "Gukoresha Mweretsi Cyangwa Indango"

#, fuzzy
#~ msgid "conflicting return type specified for `%#D'"
#~ msgstr "Garuka Ubwoko kugirango"

#, fuzzy
#~ msgid "looser throw specifier for `%#F'"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "  since `%#D' declared in base class"
#~ msgstr "guhera in SHINGIRO ishuri"

#, fuzzy
#~ msgid "`%#D' needs a final overrider"
#~ msgstr "`%#D'a"

#, fuzzy
#~ msgid "type of asm operand `%E' could not be determined"
#~ msgstr "Ubwoko Bya OYA"

#, fuzzy
#~ msgid "ISO C++ does not permit named return values"
#~ msgstr "C OYA Garuka Uduciro"

#, fuzzy
#~ msgid "return identifier `%D' already in place"
#~ msgstr "Garuka Ikiranga in"

#, fuzzy
#~ msgid "can't redefine default return value for constructors"
#~ msgstr "Mburabuzi Garuka Agaciro kugirango"

#, fuzzy
#~ msgid "only constructors take base initializers"
#~ msgstr "SHINGIRO"

#, fuzzy
#~ msgid "`this' is unavailable for static member functions"
#~ msgstr "`ni kugirango Imimaro"

#, fuzzy
#~ msgid "invalid use of `this' in non-member function"
#~ msgstr "Sibyo Gukoresha Bya in Umumaro"

#, fuzzy
#~ msgid "invalid use of `this' at top level"
#~ msgstr "Sibyo Gukoresha Bya ku Hejuru: urwego"

#, fuzzy
#~ msgid "calling type `%T' like a method"
#~ msgstr "Ubwoko nka a Uburyo"

#, fuzzy
#~ msgid "destructor specifier `%T::~%T()' must have matching names"
#~ msgstr "Amazina"

#, fuzzy
#~ msgid "`%E' is not of type `%T'"
#~ msgstr "`%E'ni OYA Bya Ubwoko"

#, fuzzy
#~ msgid "template type parameters must use the keyword `class' or `typename'"
#~ msgstr "Inyandikorugero Ubwoko Ibigenga Gukoresha i Ijambo- banze Cyangwa"

#, fuzzy
#~ msgid "invalid default template argument"
#~ msgstr "Sibyo Mburabuzi Inyandikorugero"

#, fuzzy
#~ msgid "definition of `%#T' inside template parameter list"
#~ msgstr "Insobanuro Bya Mo Imbere Inyandikorugero Urutonde"

#, fuzzy
#~ msgid "invalid definition of qualified type `%T'"
#~ msgstr "Sibyo Insobanuro Bya Ubwoko"

#, fuzzy
#~ msgid "invalid base-class specification"
#~ msgstr "Sibyo SHINGIRO ishuri"

#, fuzzy
#~ msgid "base class `%T' has cv qualifiers"
#~ msgstr "SHINGIRO ishuri"

#, fuzzy
#~ msgid "multiple declarators in template declaration"
#~ msgstr "Igikubo in Inyandikorugero"

#, fuzzy
#~ msgid "type of `%E' is unknown"
#~ msgstr "Ubwoko Bya ni Kitazwi"

#, fuzzy
#~ msgid "identifier name `%s' conflicts with GNU C++ internal naming strategy"
#~ msgstr "Ikiranga Izina: Na: C By'imbere"

#, fuzzy
#~ msgid "parse error at end of saved function text"
#~ msgstr "Ikosa ku Impera Bya Umumaro Umwandiko"

#, fuzzy
#~ msgid "%Hend of file read inside definition"
#~ msgstr "%HendBya IDOSIYE Gusoma Mo Imbere Insobanuro"

#, fuzzy
#~ msgid "parse error in method specification"
#~ msgstr "Ikosa in Uburyo"

#, fuzzy
#~ msgid "function body for constructor missing"
#~ msgstr "Umumaro Umubiri kugirango Ibuze"

#, fuzzy
#~ msgid "%Hend of file read inside default argument"
#~ msgstr "%HendBya IDOSIYE Gusoma Mo Imbere Mburabuzi"

#, fuzzy
#~ msgid "circular dependency in default args of `%#D'"
#~ msgstr "Cy'uruziga in Mburabuzi Bya"

#, fuzzy
#~ msgid "invalid type `%T' for default argument to `%T'"
#~ msgstr "Sibyo Ubwoko kugirango Mburabuzi Kuri"

#, fuzzy
#~ msgid "%s before `%s'"
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "%s before `%c'"
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "%s before `\\%o'"
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "%s before `%s' token"
#~ msgstr "%sMbere"

#, fuzzy
#~ msgid "non-lvalue in %s"
#~ msgstr "in"

#, fuzzy
#~ msgid "`%V' qualifiers cannot be applied to `%T'"
#~ msgstr "`%V'Byashyizweho Kuri"

#, fuzzy
#~ msgid "`%s' attribute can only be applied to Java class definitions"
#~ msgstr "`%s'Ikiranga Byashyizweho Kuri ishuri"

#, fuzzy
#~ msgid "`%s' attribute can only be applied to class definitions"
#~ msgstr "`%s'Ikiranga Byashyizweho Kuri ishuri"

#, fuzzy
#~ msgid "`%s' is obsolete; g++ vtables are now COM-compatible by default"
#~ msgstr "`%s'ni g NONEAHA ku Mburabuzi"

#, fuzzy
#~ msgid "requested init_priority is not an integer constant"
#~ msgstr "ni OYA Umubare wuzuye"

#, fuzzy
#~ msgid "can only use `%s' attribute on file-scope definitions of objects of class type"
#~ msgstr "Gukoresha Ikiranga ku IDOSIYE Ingano: Bya Ibintu Bya ishuri Ubwoko"

#, fuzzy
#~ msgid "requested init_priority is out of range"
#~ msgstr "ni Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "requested init_priority is reserved for internal use"
#~ msgstr "ni kugirango By'imbere Gukoresha"

#, fuzzy
#~ msgid "`%s' attribute is not supported on this platform"
#~ msgstr "`%s'Ikiranga ni OYA ku iyi"

#, fuzzy
#~ msgid "lang_* check: failed in %s, at %s:%d"
#~ msgstr "Kugenzura... Byanze in ku"

#, fuzzy
#~ msgid "ISO C++ forbids %s between pointer of type `void *' and pointer-to-function"
#~ msgstr "C hagati Mweretsi Bya Ubwoko Na Mweretsi Kuri Umumaro"

#, fuzzy
#~ msgid "%s between distinct pointer types `%T' and `%T' lacks a cast"
#~ msgstr "%shagati Mweretsi Na a"

#, fuzzy
#~ msgid "ISO C++ prohibits conversion from `%#T' to `(...)'"
#~ msgstr "C Ihindurangero Bivuye Kuri"

#, fuzzy
#~ msgid "invalid application of `%s' to a member function"
#~ msgstr "Sibyo Porogaramu Bya Kuri a Umumaro"

#, fuzzy
#~ msgid "invalid application of `%s' to non-static member"
#~ msgstr "Sibyo Porogaramu Bya Kuri"

#, fuzzy
#~ msgid "sizeof applied to a bit-field"
#~ msgstr "Byashyizweho Kuri a Umwanya"

#, fuzzy
#~ msgid "ISO C++ forbids applying `sizeof' to an expression of function type"
#~ msgstr "C Kuri imvugo Bya Umumaro Ubwoko"

#, fuzzy
#~ msgid "invalid use of non-lvalue array"
#~ msgstr "Sibyo Gukoresha Bya Imbonerahamwe"

#, fuzzy
#~ msgid "deprecated conversion from string constant to `%T'"
#~ msgstr "Bitemewe. Ihindurangero Bivuye Ikurikiranyanyuguti Kuri"

#, fuzzy
#~ msgid "request for member `%D' in `%E', which is of non-class type `%T'"
#~ msgstr "Kubaza... kugirango in ni Bya ishuri Ubwoko"

#, fuzzy
#~ msgid "`%D' is not a member of `%T'"
#~ msgstr "`%D'ni OYA a Bya"

#, fuzzy
#~ msgid "invalid access to non-static data member `%D' of NULL object"
#~ msgstr "Sibyo Kuri Ibyatanzwe Bya Igikoresho"

#, fuzzy
#~ msgid "(perhaps the `offsetof' macro was used incorrectly)"
#~ msgstr "(i Makoro"

#, fuzzy
#~ msgid "`%D::%D' is not a member of `%T'"
#~ msgstr "`%D::%D'ni OYA a Bya"

#, fuzzy
#~ msgid "destructor specifier `%T::~%T' must have matching names"
#~ msgstr "Amazina"

#, fuzzy
#~ msgid "type `%T' has no destructor"
#~ msgstr "Ubwoko Oya"

#, fuzzy
#~ msgid "`%D' is not a member template function"
#~ msgstr "`%D'ni OYA a Inyandikorugero Umumaro"

#, fuzzy
#~ msgid "`%T' is not a pointer-to-object type"
#~ msgstr "`%T'ni OYA a Mweretsi Kuri Igikoresho Ubwoko"

#, fuzzy
#~ msgid "invalid use of `%s' on pointer to member"
#~ msgstr "Sibyo Gukoresha Bya ku Mweretsi Kuri"

#, fuzzy
#~ msgid "invalid type argument"
#~ msgstr "Sibyo Ubwoko"

#, fuzzy
#~ msgid "ISO C++ forbids subscripting non-lvalue array"
#~ msgstr "C Imbonerahamwe"

#, fuzzy
#~ msgid "subscripting array declared `register'"
#~ msgstr "Imbonerahamwe"

#, fuzzy
#~ msgid "object missing in use of `%E'"
#~ msgstr "Igikoresho Ibuze in Gukoresha Bya"

#, fuzzy
#~ msgid "ISO C++ forbids calling `::main' from within program"
#~ msgstr "C Bivuye muri Porogaramu"

#, fuzzy
#~ msgid "must use .* or ->* to call pointer-to-member function in `%E (...)'"
#~ msgstr "Gukoresha Cyangwa Kuri Mweretsi Kuri Umumaro in"

#, fuzzy
#~ msgid "`%E' cannot be used as a function"
#~ msgstr "`%E'Nka a Umumaro"

#, fuzzy
#~ msgid "too many arguments to %s `%+#D'"
#~ msgstr "ingingo Kuri"

#, fuzzy
#~ msgid "parameter type of called function is incomplete"
#~ msgstr "Ubwoko Bya Umumaro ni"

#, fuzzy
#~ msgid "too few arguments to %s `%+#D'"
#~ msgstr "ingingo Kuri"

#, fuzzy
#~ msgid "assuming cast to type `%T' from overloaded function"
#~ msgstr "Kuri Ubwoko Bivuye Umumaro"

#, fuzzy
#~ msgid "division by zero in `%E / 0'"
#~ msgstr "ku Zeru in"

#, fuzzy
#~ msgid "division by zero in `%E / 0.'"
#~ msgstr "ku Zeru in 0"

#, fuzzy
#~ msgid "division by zero in `%E %% 0'"
#~ msgstr "ku Zeru in"

#, fuzzy
#~ msgid "division by zero in `%E %% 0.'"
#~ msgstr "ku Zeru in 0"

#, fuzzy
#~ msgid "%s rotate count is negative"
#~ msgstr "%sKuzerutsa IBARA ni"

#, fuzzy
#~ msgid "%s rotate count >= width of type"
#~ msgstr "%sKuzerutsa IBARA Ubugari Bya Ubwoko"

#, fuzzy
#~ msgid "ISO C++ forbids comparison between pointer and integer"
#~ msgstr "C hagati Mweretsi Na Umubare wuzuye"

#, fuzzy
#~ msgid "comparison between types `%#T' and `%#T'"
#~ msgstr "hagati Na"

#, fuzzy
#~ msgid "comparison between signed and unsigned integer expressions"
#~ msgstr "hagati Na Bitashizweho umukono Umubare wuzuye"

#, fuzzy
#~ msgid "invalid operands of types `%T' and `%T' to binary `%O'"
#~ msgstr "Sibyo Bya Na Kuri Nyabibiri"

#, fuzzy
#~ msgid "NULL used in arithmetic"
#~ msgstr "in"

#, fuzzy
#~ msgid "ISO C++ forbids using pointer of type `void *' in subtraction"
#~ msgstr "C ikoresha Mweretsi Bya Ubwoko in Gukuramo"

#, fuzzy
#~ msgid "ISO C++ forbids using pointer to a function in subtraction"
#~ msgstr "C ikoresha Mweretsi Kuri a Umumaro in Gukuramo"

#, fuzzy
#~ msgid "ISO C++ forbids using pointer to a method in subtraction"
#~ msgstr "C ikoresha Mweretsi Kuri a Uburyo in Gukuramo"

#, fuzzy
#~ msgid "ISO C++ forbids using pointer to a member in subtraction"
#~ msgstr "C ikoresha Mweretsi Kuri a in Gukuramo"

#, fuzzy
#~ msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
#~ msgstr "Sibyo Gukoresha Bya a Mweretsi Kuri Ubwoko in Mweretsi"

#, fuzzy
#~ msgid "invalid use of '%E' to form a pointer-to-member-function.  Use a qualified-id."
#~ msgstr "Sibyo Gukoresha Bya Kuri Ifishi a Mweretsi Kuri Umumaro a ID"

#, fuzzy
#~ msgid "parenthesis around '%E' cannot be used to form a pointer-to-member-function"
#~ msgstr "Kuri Ifishi a Mweretsi Kuri Umumaro"

#, fuzzy
#~ msgid "taking address of temporary"
#~ msgstr "Aderesi Bya By'igihe gito"

#, fuzzy
#~ msgid "ISO C++ forbids %sing an enum"
#~ msgstr "C"

#, fuzzy
#~ msgid "cannot %s a pointer to incomplete type `%T'"
#~ msgstr "a Mweretsi Kuri Ubwoko"

#, fuzzy
#~ msgid "ISO C++ forbids %sing a pointer of type `%T'"
#~ msgstr "C a Mweretsi Bya Ubwoko"

#, fuzzy
#~ msgid "cast to non-reference type used as lvalue"
#~ msgstr "Kuri Indango Ubwoko Nka"

#, fuzzy
#~ msgid "invalid use of `--' on bool variable `%D'"
#~ msgstr "Sibyo Gukoresha Bya ku IMPINDURAGACIRO"

#, fuzzy
#~ msgid "ISO C++ forbids taking address of function `::main'"
#~ msgstr "C Aderesi Bya Umumaro"

#, fuzzy
#~ msgid "ISO C++ forbids taking the address of an unqualified non-static member function to form a pointer to member function.  Say `&%T::%D'"
#~ msgstr "C i Aderesi Bya Umumaro Kuri Ifishi a Mweretsi Kuri Umumaro"

#, fuzzy
#~ msgid "ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say `&%T::%D'"
#~ msgstr "C i Aderesi Bya a Umumaro Kuri Ifishi a Mweretsi Kuri Umumaro"

#, fuzzy
#~ msgid "ISO C++ forbids taking the address of a cast to a non-lvalue expression"
#~ msgstr "C i Aderesi Bya a Kuri a imvugo"

#, fuzzy
#~ msgid "attempt to take address of bit-field structure member `%D'"
#~ msgstr "Kuri Aderesi Bya Umwanya Imiterere"

#, fuzzy
#~ msgid "taking address of destructor"
#~ msgstr "Aderesi Bya"

#, fuzzy
#~ msgid "taking address of bound pointer-to-member expression"
#~ msgstr "Aderesi Bya Mweretsi Kuri imvugo"

#, fuzzy
#~ msgid "cannot create pointer to reference member `%D'"
#~ msgstr "Kurema Mweretsi Kuri Indango"

#, fuzzy
#~ msgid "cannot take the address of `this', which is an rvalue expression"
#~ msgstr "i Aderesi Bya ni imvugo"

#, fuzzy
#~ msgid "address requested for `%D', which is declared `register'"
#~ msgstr "Aderesi kugirango ni"

#, fuzzy
#~ msgid "static_cast from type `%T' to type `%T' casts away constness"
#~ msgstr "Bivuye Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "invalid static_cast from type `%T' to type `%T'"
#~ msgstr "Sibyo Bivuye Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "invalid reinterpret_cast of an rvalue expression of type `%T' to type `%T'"
#~ msgstr "Sibyo Bya imvugo Bya Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "reinterpret_cast from `%T' to `%T' loses precision"
#~ msgstr "Bivuye Kuri"

#, fuzzy
#~ msgid "reinterpret_cast from `%T' to `%T' casts away const (or volatile)"
#~ msgstr "Bivuye Kuri Cyangwa"

#, fuzzy
#~ msgid "ISO C++ forbids casting between pointer-to-function and pointer-to-object"
#~ msgstr "C hagati Mweretsi Kuri Umumaro Na Mweretsi Kuri Igikoresho"

#, fuzzy
#~ msgid "invalid reinterpret_cast from type `%T' to type `%T'"
#~ msgstr "Sibyo Bivuye Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "invalid use of const_cast with type `%T', which is not a pointer, reference, nor a pointer-to-data-member type"
#~ msgstr "Sibyo Gukoresha Bya Na: Ubwoko ni OYA a Mweretsi Indango a Mweretsi Kuri Ibyatanzwe Ubwoko"

#, fuzzy
#~ msgid "invalid use of const_cast with type `%T', which is a pointer or reference to a function type"
#~ msgstr "Sibyo Gukoresha Bya Na: Ubwoko ni a Mweretsi Cyangwa Indango Kuri a Umumaro Ubwoko"

#, fuzzy
#~ msgid "invalid const_cast of an rvalue of type `%T' to type `%T'"
#~ msgstr "Sibyo Bya Bya Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "invalid const_cast from type `%T' to type `%T'"
#~ msgstr "Sibyo Bivuye Ubwoko Kuri Ubwoko"

#, fuzzy
#~ msgid "ISO C++ forbids casting to an array type `%T'"
#~ msgstr "C Kuri Imbonerahamwe Ubwoko"

#, fuzzy
#~ msgid "invalid cast to function type `%T'"
#~ msgstr "Sibyo Kuri Umumaro Ubwoko"

#, fuzzy
#~ msgid "cast from `%T' to `%T' discards qualifiers from pointer target type"
#~ msgstr "Bivuye Kuri Bivuye Mweretsi Intego Ubwoko"

#, fuzzy
#~ msgid "cast from `%T' to `%T' increases required alignment of target type"
#~ msgstr "Bivuye Kuri Bya ngombwa Itunganya Bya Intego Ubwoko"

#, fuzzy
#~ msgid "  in evaluation of `%Q(%#T, %#T)'"
#~ msgstr "in Bya"

#, fuzzy
#~ msgid "ISO C++ forbids cast to non-reference type used as lvalue"
#~ msgstr "C Kuri Indango Ubwoko Nka"

#, fuzzy
#~ msgid "incompatible types in assignment of `%T' to `%T'"
#~ msgstr "in Igenera Bya Kuri"

#, fuzzy
#~ msgid "ISO C++ forbids assignment of arrays"
#~ msgstr "C Igenera Bya"

#, fuzzy
#~ msgid "   in pointer to member function conversion"
#~ msgstr "in Mweretsi Kuri Umumaro Ihindurangero"

#, fuzzy
#~ msgid "   in pointer to member conversion"
#~ msgstr "in Mweretsi Kuri Ihindurangero"

#, fuzzy
#~ msgid "pointer to member cast via virtual base `%T' of `%T'"
#~ msgstr "Mweretsi Kuri Biturutse Kitaboneka SHINGIRO Bya"

#, fuzzy
#~ msgid "pointer to member conversion via virtual base `%T' of `%T'"
#~ msgstr "Mweretsi Kuri Ihindurangero Biturutse Kitaboneka SHINGIRO Bya"

#, fuzzy
#~ msgid "invalid conversion to type `%T' from type `%T'"
#~ msgstr "Sibyo Ihindurangero Kuri Ubwoko Bivuye Ubwoko"

#, fuzzy
#~ msgid "passing NULL used for non-pointer %s %P of `%D'"
#~ msgstr "kugirango Mweretsi Bya"

#, fuzzy
#~ msgid "%s to non-pointer type `%T' from NULL"
#~ msgstr "%sKuri Mweretsi Ubwoko Bivuye"

#, fuzzy
#~ msgid "passing `%T' for %s %P of `%D'"
#~ msgstr "kugirango Bya"

#, fuzzy
#~ msgid "%s to `%T' from `%T'"
#~ msgstr "%sKuri Bivuye"

#, fuzzy
#~ msgid "passing negative value `%E' for %s %P of `%D'"
#~ msgstr "Agaciro kugirango Bya"

#, fuzzy
#~ msgid "%s of negative value `%E' to `%T'"
#~ msgstr "%sBya Agaciro Kuri"

#, fuzzy
#~ msgid "cannot convert `%T' to `%T' for argument `%P' to `%D'"
#~ msgstr "GUHINDURA Kuri kugirango Kuri"

#, fuzzy
#~ msgid "cannot convert `%T' to `%T' in %s"
#~ msgstr "GUHINDURA Kuri in"

#, fuzzy
#~ msgid "in passing argument %P of `%+D'"
#~ msgstr "in Bya"

#, fuzzy
#~ msgid "returning reference to temporary"
#~ msgstr "Indango Kuri By'igihe gito"

#, fuzzy
#~ msgid "reference to non-lvalue returned"
#~ msgstr "Indango Kuri"

#, fuzzy
#~ msgid "reference to local variable `%D' returned"
#~ msgstr "Indango Kuri IMPINDURAGACIRO"

#, fuzzy
#~ msgid "address of local variable `%D' returned"
#~ msgstr "Aderesi Bya IMPINDURAGACIRO"

#, fuzzy
#~ msgid "returning a value from a destructor"
#~ msgstr "a Agaciro Bivuye a"

#, fuzzy
#~ msgid "cannot return from a handler of a function-try-block of a constructor"
#~ msgstr "Garuka Bivuye a Bya a Umumaro Funga Bya a"

#, fuzzy
#~ msgid "returning a value from a constructor"
#~ msgstr "a Agaciro Bivuye a"

#, fuzzy
#~ msgid "return-statement with no value, in function declared with a non-void return type"
#~ msgstr "Garuka Inyandiko Na: Oya Agaciro in Umumaro Na: a Garuka Ubwoko"

#, fuzzy
#~ msgid "return-statement with a value, in function declared with a void return type"
#~ msgstr "Garuka Inyandiko Na: a Agaciro in Umumaro Na: a Garuka Ubwoko"

#, fuzzy
#~ msgid "`operator new' must not return NULL unless it is declared `throw()' (or -fcheck-new is in effect)"
#~ msgstr "`Mukoresha OYA Garuka ni Cyangwa Gishya ni in INGARUKA"

#, fuzzy
#~ msgid "type `%T' is not a base type for type `%T'"
#~ msgstr "Ubwoko ni OYA a SHINGIRO Ubwoko kugirango Ubwoko"

#, fuzzy
#~ msgid "cannot declare variable `%D' to be of type `%T'"
#~ msgstr "IMPINDURAGACIRO Kuri Bya Ubwoko"

#, fuzzy
#~ msgid "cannot declare parameter `%D' to be of type `%T'"
#~ msgstr "Kuri Bya Ubwoko"

#, fuzzy
#~ msgid "cannot declare field `%D' to be of type `%T'"
#~ msgstr "Umwanya Kuri Bya Ubwoko"

#, fuzzy
#~ msgid "invalid return type for member function `%#D'"
#~ msgstr "Sibyo Garuka Ubwoko kugirango Umumaro"

#, fuzzy
#~ msgid "invalid return type for function `%#D'"
#~ msgstr "Sibyo Garuka Ubwoko kugirango Umumaro"

#, fuzzy
#~ msgid "cannot allocate an object of type `%T'"
#~ msgstr "Igikoresho Bya Ubwoko"

#, fuzzy
#~ msgid "  because the following virtual functions are abstract:"
#~ msgstr "i Kitaboneka Imimaro Incamake"

# basctl/source\basicide\basidesh.src:RID_IMGBTN_REMOVEWATCH.text
#, fuzzy
#~ msgid "\t%#D"
#~ msgstr "%#D"

#, fuzzy
#~ msgid "  since type `%T' has abstract virtual functions"
#~ msgstr "guhera Ubwoko Incamake Kitaboneka Imimaro"

#, fuzzy
#~ msgid "constructor syntax used, but no constructor declared for type `%T'"
#~ msgstr "Oya kugirango Ubwoko"

#, fuzzy
#~ msgid "comma expression used to initialize return value"
#~ msgstr "Akitso imvugo Kuri gutangiza Garuka Agaciro"

#, fuzzy
#~ msgid "cannot initialize arrays using this syntax"
#~ msgstr "gutangiza ikoresha iyi"

#, fuzzy
#~ msgid "initializing array with parameter list"
#~ msgstr "Gutangiza Imbonerahamwe Na: Urutonde"

#, fuzzy
#~ msgid "initializer for scalar variable requires one element"
#~ msgstr "kugirango IMPINDURAGACIRO Ikigize:"

#, fuzzy
#~ msgid "braces around scalar initializer for `%T'"
#~ msgstr "Ingirwadusodeko kugirango"

#, fuzzy
#~ msgid "ignoring extra initializers for `%T'"
#~ msgstr "Birenga kugirango"

#, fuzzy
#~ msgid "variable-sized object of type `%T' may not be initialized"
#~ msgstr "IMPINDURAGACIRO Igikoresho Bya Ubwoko Gicurasi OYA"

#, fuzzy
#~ msgid "subobject of type `%T' must be initialized by constructor, not by `%E'"
#~ msgstr "Bya Ubwoko ku OYA ku"

#, fuzzy
#~ msgid "aggregate has a partly bracketed initializer"
#~ msgstr "a"

#, fuzzy
#~ msgid "non-empty initializer for array of empty elements"
#~ msgstr "ubusa kugirango Imbonerahamwe Bya ubusa Ibintu"

#, fuzzy
#~ msgid "initializer list for object of class with virtual base classes"
#~ msgstr "Urutonde kugirango Igikoresho Bya ishuri Na: Kitaboneka SHINGIRO Inzego"

#, fuzzy
#~ msgid "initializer list for object of class with base classes"
#~ msgstr "Urutonde kugirango Igikoresho Bya ishuri Na: SHINGIRO Inzego"

#, fuzzy
#~ msgid "initializer list for object using virtual functions"
#~ msgstr "Urutonde kugirango Igikoresho ikoresha Kitaboneka Imimaro"

#, fuzzy
#~ msgid "missing initializer for member `%D'"
#~ msgstr "Ibuze kugirango"

#, fuzzy
#~ msgid "uninitialized const member `%D'"
#~ msgstr "Itatangijwe"

#, fuzzy
#~ msgid "member `%D' with uninitialized const fields"
#~ msgstr "Na: Itatangijwe Imyanya"

#, fuzzy
#~ msgid "member `%D' is uninitialized reference"
#~ msgstr "ni Itatangijwe Indango"

#, fuzzy
#~ msgid "index value instead of field name in union initializer"
#~ msgstr "Umubarendanga Agaciro Bya Umwanya Izina: in Ihuza"

#, fuzzy
#~ msgid "no field `%D' in union being initialized"
#~ msgstr "Oya Umwanya in Ihuza"

#, fuzzy
#~ msgid "union `%T' with no named members cannot be initialized"
#~ msgstr "Ihuza Na: Oya"

#, fuzzy
#~ msgid "excess elements in aggregate initializer"
#~ msgstr "Ibintu in"

#, fuzzy
#~ msgid "circular pointer delegation detected"
#~ msgstr "Cy'uruziga Mweretsi"

#, fuzzy
#~ msgid "base operand of `->' has non-pointer type `%T'"
#~ msgstr "SHINGIRO Bya Mweretsi Ubwoko"

#, fuzzy
#~ msgid "result of `operator->()' yields non-pointer result"
#~ msgstr "Igisubizo Bya Mukoresha Mweretsi Igisubizo"

#, fuzzy
#~ msgid "base operand of `->' is not a pointer"
#~ msgstr "SHINGIRO Bya ni OYA a Mweretsi"

#, fuzzy
#~ msgid "`%E' cannot be used as a member pointer, since it is of type `%T'"
#~ msgstr "`%E'Nka a Mweretsi guhera ni Bya Ubwoko"

#, fuzzy
#~ msgid "cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'"
#~ msgstr "Gukurikiza Mweretsi Kuri ni Bya Ubwoko"

#, fuzzy
#~ msgid "member type `%T::' incompatible with object type `%T'"
#~ msgstr "Ubwoko Na: Igikoresho Ubwoko"

#, fuzzy
#~ msgid "`%T' fails to be a typedef or built-in type"
#~ msgstr "`%T'Kuri a Cyangwa in Ubwoko"

#, fuzzy
#~ msgid "ISO C++ forbids defining types within %s"
#~ msgstr "C muri"

#, fuzzy
#~ msgid "call to function `%D' which throws incomplete type `%#T'"
#~ msgstr "Kuri Umumaro Ubwoko"

#, fuzzy
#~ msgid "call to function which throws incomplete type `%#T'"
#~ msgstr "Kuri Umumaro Ubwoko"

#, fuzzy
#~ msgid "%s is deprecated, please see the documentation for details"
#~ msgstr "%sni Bitemewe. i kugirango Birambuye"

#, fuzzy
#~ msgid "Do not obey access control semantics"
#~ msgstr "OYA Igenzura"

#, fuzzy
#~ msgid "Change when template instances are emitted"
#~ msgstr "Ryari: Inyandikorugero Ingero"

#, fuzzy
#~ msgid "Check the return value of new"
#~ msgstr "i Garuka Agaciro Bya Gishya"

#, fuzzy
#~ msgid "Reduce size of object files"
#~ msgstr "Ingano Bya Igikoresho Idosiye"

#, fuzzy
#~ msgid "Make string literals `char[]' instead of `const char[]'"
#~ msgstr "Ikurikiranyanyuguti INYUGUTI Bya INYUGUTI"

#, fuzzy
#~ msgid "Dump the entire translation unit to a file"
#~ msgstr "i Umwandiko wahinduwe ururimi Igice: Kuri a IDOSIYE"

#, fuzzy
#~ msgid "Do not inline member functions by default"
#~ msgstr "OYA Mumurongo Imimaro ku Mburabuzi"

#, fuzzy
#~ msgid "Do not generate run time type descriptor information"
#~ msgstr "OYA Gukoresha Igihe Ubwoko Ibisobanuro"

#, fuzzy
#~ msgid "Do not generate code to check exception specifications"
#~ msgstr "OYA ITEGEKONGENGA Kuri Kugenzura... Irengayobora(-)"

#, fuzzy
#~ msgid "Scope of for-init-statement vars extends outside"
#~ msgstr "Bya kugirango Inyandiko Hanze"

#, fuzzy
#~ msgid "Do not recognize GNU defined keywords"
#~ msgstr "OYA Amagambo fatizo"

#, fuzzy
#~ msgid "Enable support for huge objects"
#~ msgstr "Gushigikira kugirango Ibintu"

#, fuzzy
#~ msgid "Export functions even if they can be inlined"
#~ msgstr "Imimaro ATARIIGIHARWE NIBA"

#, fuzzy
#~ msgid "Only emit explicit template instantiations"
#~ msgstr "Inyandikorugero"

#, fuzzy
#~ msgid "Only emit explicit instantiations of inline templates"
#~ msgstr "Bya Mumurongo Inyandikorugero"

#, fuzzy
#~ msgid "Don't pedwarn about uses of Microsoft extensions"
#~ msgstr "Ibyerekeye Bya Umigereka"

#, fuzzy
#~ msgid "Recognize and/bitand/bitor/compl/not/or/xor"
#~ msgstr "Na OYA Cyangwa"

#, fuzzy
#~ msgid "Disable optional diagnostics"
#~ msgstr "Bitari ngombwa"

#, fuzzy
#~ msgid "Downgrade conformance errors to warnings"
#~ msgstr "Amakosa Kuri Iburira"

#, fuzzy
#~ msgid "Enable automatic template instantiation"
#~ msgstr "Byikoresha Inyandikorugero"

#, fuzzy
#~ msgid "Display statistics accumulated during compilation"
#~ msgstr "Sitatisitiki"

#, fuzzy
#~ msgid "Specify maximum template instantiation depth"
#~ msgstr "Kinini Inyandikorugero Ubujyakuzimu"

#, fuzzy
#~ msgid "Use __cxa_atexit to register destructors"
#~ msgstr "Kuri Kwiyandikisha"

#, fuzzy
#~ msgid "Discard unused virtual functions"
#~ msgstr "Kidakoreshwa Kitaboneka Imimaro"

#, fuzzy
#~ msgid "Implement vtables using thunks"
#~ msgstr "ikoresha"

#, fuzzy
#~ msgid "Emit common-like symbols as weak symbols"
#~ msgstr "nka Ibimenyetso Nka Ibimenyetso"

#, fuzzy
#~ msgid "Emit cross referencing information"
#~ msgstr "Kwambukiranya Ibisobanuro"

#, fuzzy
#~ msgid "Warn about inconsistent return types"
#~ msgstr "Ibyerekeye Garuka"

#, fuzzy
#~ msgid "Warn about overloaded virtual function names"
#~ msgstr "Ibyerekeye Kitaboneka Umumaro Amazina"

#, fuzzy
#~ msgid "Don't warn when all ctors/dtors are private"
#~ msgstr "Ryari: Byose By'umwihariko"

#, fuzzy
#~ msgid "Warn about non virtual destructors"
#~ msgstr "Ibyerekeye Kitaboneka"

#, fuzzy
#~ msgid "Warn when a function is declared extern, then inline"
#~ msgstr "Ryari: a Umumaro ni Hanyuma Mumurongo"

#, fuzzy
#~ msgid "Warn when the compiler reorders code"
#~ msgstr "Ryari: i ITEGEKONGENGA"

#, fuzzy
#~ msgid "Warn when synthesis behavior differs from Cfront"
#~ msgstr "Ryari: imyitwarire Bivuye"

#, fuzzy
#~ msgid "Don't warn when type converting pointers to member functions"
#~ msgstr "Ryari: Ubwoko Guhindura.... Kuri Imimaro"

#, fuzzy
#~ msgid "Warn about violations of Effective C++ style rules"
#~ msgstr "Ibyerekeye Bya C IMISUSIRE"

#, fuzzy
#~ msgid "Warn when overload promotes from unsigned to signed"
#~ msgstr "Ryari: Bivuye Bitashizweho umukono Kuri"

#, fuzzy
#~ msgid "Warn if a C style cast is used in a program"
#~ msgstr "NIBA a C IMISUSIRE ni in a Porogaramu"

#, fuzzy
#~ msgid "Don't warn when non-templatized friend functions are declared within a template"
#~ msgstr "Ryari: Imimaro muri a Inyandikorugero"

#, fuzzy
#~ msgid "Don't announce deprecation of compiler features"
#~ msgstr "Bya Ibiranga"

# scp/source\cde\unxbasic_cde.lng:STR_BASIC_CDEINT_NETWORK_STRING2.text
#, fuzzy
#~ msgid "note:"
#~ msgstr "Ibisobanuro:"

#, fuzzy
#~ msgid "warning:"
#~ msgstr "Iburira!"

#, fuzzy
#~ msgid "ASSIGN'ed label cannot fit into `%A' at %0 -- using wider sibling"
#~ msgstr "Akarango ku ikoresha"

#, fuzzy
#~ msgid "no INTEGER type can hold a pointer on this configuration"
#~ msgstr "Oya Ubwoko a Mweretsi ku iyi Iboneza"

#, fuzzy
#~ msgid "configuration: REAL, INTEGER, and LOGICAL are %d bits wide,"
#~ msgstr "Iboneza Na"

#, fuzzy
#~ msgid "and pointers are %d bits wide, but g77 doesn't yet work"
#~ msgstr "Na Akazi"

#, fuzzy
#~ msgid "properly unless they all are 32 bits wide"
#~ msgstr "Byose"

#, fuzzy
#~ msgid "Please keep this in mind before you report bugs."
#~ msgstr "Gumana: iyi in Mbere Icyegeranyo"

#, fuzzy
#~ msgid "configuration: char * holds %d bits, but ftnlen only %d"
#~ msgstr "Iboneza INYUGUTI"

#, fuzzy
#~ msgid ""
#~ "configuration: char * holds %d bits, but INTEGER only %d --\n"
#~ " ASSIGN statement might fail"
#~ msgstr "Iboneza INYUGUTI Inyandiko"

#, fuzzy
#~ msgid "In statement function"
#~ msgstr "Inyandiko Umumaro"

#, fuzzy
#~ msgid "Outside of any program unit:\n"
#~ msgstr "Bya Porogaramu Igice:"

#, fuzzy
#~ msgid "%A from %B at %0%C"
#~ msgstr "%ABivuye ku"

#, fuzzy
#~ msgid "directory name must immediately follow -I"
#~ msgstr "bushyinguro Izina: Ako kanya"

#, fuzzy
#~ msgid "At %0, INCLUDE file %A exists, but is not readable"
#~ msgstr "IDOSIYE ni OYA"

#, fuzzy
#~ msgid "At %0, INCLUDE nesting too deep"
#~ msgstr "Njyakuzimu"

#, fuzzy
#~ msgid "Two arithmetic operators in a row at %0 and %1 -- use parentheses"
#~ msgstr "Mukoresha in a Urubariro ku Na Gukoresha %1"

#, fuzzy
#~ msgid "Operator at %0 has lower precedence than that at %1 -- use parentheses"
#~ msgstr "ku Ntoya ku Gukoresha %1"

#, fuzzy
#~ msgid "Use .EQV./.NEQV. instead of .EQ./.NE. at %0 for LOGICAL operands at %1 and %2"
#~ msgstr ""
#~ "Project- Id- Version: basctl\n"
#~ "POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
#~ "PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
#~ "Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
#~ "Content- Type: text/ plain; charset= UTF- 8\n"
#~ "Content- Transfer- Encoding: 8bit\n"
#~ "X- Generator: KBabel 1. 0\n"
#~ ". Project- Id- Version: basctl\n"
#~ "POT- Creation- Date: 2003- 12- 07 17: 13+ 02\n"
#~ "PO- Revision- Date: 2004- 11- 04 10: 13- 0700\n"
#~ "Last- Translator: Language- Team:< en@ li. org> MIME- Version: 1. 0\n"
#~ "Content- Type: text/ plain; charset= UTF- 8\n"
#~ "Content- Transfer- Encoding: 8bit\n"
#~ "X- Generator: KBabel 1. 0\n"
#~ "."

#, fuzzy
#~ msgid "Unsupported operand for ** at %1 -- converting to default INTEGER"
#~ msgstr "kugirango ku Guhindura.... Kuri Mburabuzi"

#, fuzzy
#~ msgid "overflowed output arg list for `%s'"
#~ msgstr "Ibisohoka Urutonde kugirango"

#, fuzzy
#~ msgid "--driver no longer supported"
#~ msgstr "--Musomyi: Oya"

#, fuzzy
#~ msgid "argument to `%s' missing"
#~ msgstr "Kuri Ibuze"

#, fuzzy
#~ msgid "no input files; unwilling to write output files"
#~ msgstr "Oya Iyinjiza Idosiye Kuri Kwandika Ibisohoka Idosiye"

#, fuzzy
#~ msgid "Implicit declaration of `%A' at %0"
#~ msgstr "Bya ku"

#, fuzzy
#~ msgid "Non-ISO-C-standard escape sequence `\\%A' at %0"
#~ msgstr "C Bisanzwe ku"

#, fuzzy
#~ msgid "Unknown escape sequence `\\%A' at %0"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Unterminated escape sequence `\\' at %0"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Unknown escape sequence `\\' followed by char code 0x%A at %0"
#~ msgstr "ku INYUGUTI ITEGEKONGENGA ku"

#, fuzzy
#~ msgid "\\x used at %0 with no following hex digits"
#~ msgstr "\\xku Na: Oya"

#, fuzzy
#~ msgid "Hex escape at %0 out of range"
#~ msgstr "ku Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "Escape sequence at %0 out of range for character"
#~ msgstr "ku Inyuma Bya Urutonde kugirango Inyuguti"

#, fuzzy
#~ msgid "hex escape out of range"
#~ msgstr "Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "non-ANSI-standard escape sequence, `\\%c'"
#~ msgstr "Bisanzwe"

#, fuzzy
#~ msgid "unknown escape sequence `\\%c'"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "unknown escape sequence: `\\' followed by char code 0x%x"
#~ msgstr "Kitazwi ku INYUGUTI ITEGEKONGENGA"

#, fuzzy
#~ msgid "badly formed directive -- no closing quote"
#~ msgstr "Oya Gushyiraho akugarizo"

#, fuzzy
#~ msgid "#-lines for entering and leaving files don't match"
#~ msgstr "#-Imirongo kugirango Na Idosiye BIHUYE"

#, fuzzy
#~ msgid "bad directive -- missing close-quote"
#~ msgstr "Ibuze Gufunga Gushyiraho akugarizo"

#, fuzzy
#~ msgid "invalid #ident"
#~ msgstr "Sibyo"

#, fuzzy
#~ msgid "undefined or invalid # directive"
#~ msgstr "kidasobanuye Cyangwa Sibyo"

#, fuzzy
#~ msgid "invalid #line"
#~ msgstr "Sibyo Umurongo"

#, fuzzy
#~ msgid "use `#line ...' instead of `# ...' in first line"
#~ msgstr "Gukoresha Umurongo Bya in Itangira Umurongo"

#, fuzzy
#~ msgid "invalid #-line"
#~ msgstr "Sibyo Umurongo"

#, fuzzy
#~ msgid "Null character at %0 -- line ignored"
#~ msgstr "Inyuguti ku Umurongo"

#, fuzzy
#~ msgid "INCLUDE at %0 not the only statement on the source line"
#~ msgstr "ku OYA i Inyandiko ku i Inkomoko Umurongo"

#, fuzzy
#~ msgid "ASSIGNed FORMAT specifier is too small"
#~ msgstr "ni Gitoya"

#, fuzzy
#~ msgid "SELECT CASE on CHARACTER type (at %0) not supported -- sorry"
#~ msgstr "ku Ubwoko ku OYA"

#, fuzzy
#~ msgid "SELECT (at %0) has duplicate cases -- check integer overflow of CASE(s)"
#~ msgstr "ku Gusubiramo Kugenzura... Umubare wuzuye Byarenze urugero Bya S"

#, fuzzy
#~ msgid "ASSIGN to variable that is too small"
#~ msgstr "Kuri IMPINDURAGACIRO ni Gitoya"

#, fuzzy
#~ msgid "ASSIGNed GOTO target variable is too small"
#~ msgstr "Intego IMPINDURAGACIRO ni Gitoya"

#, fuzzy
#~ msgid "Local adjustable symbol `%A' at %0"
#~ msgstr "IKIMENYETSO ku"

#, fuzzy
#~ msgid "data initializer on host with different endianness"
#~ msgstr "Ibyatanzwe ku Ubuturo Na:"

#, fuzzy
#~ msgid "%s no longer supported -- try -fvxt"
#~ msgstr "%sOya"

#, fuzzy
#~ msgid "%s no longer supported -- try -fno-vxt -ff90"
#~ msgstr "%sOya"

#, fuzzy
#~ msgid "%s disabled, use normal debugging flags"
#~ msgstr "%sYahagaritswe Gukoresha Bisanzwe Amabendera"

#, fuzzy
#~ msgid "Print g77-specific compiler version info, run internal tests"
#~ msgstr "Verisiyo Ibisobanuro Gukoresha By'imbere"

#, fuzzy
#~ msgid "Program is written in typical FORTRAN 66 dialect"
#~ msgstr "ni in"

#, fuzzy
#~ msgid "Program is written in typical Unix f77 dialect"
#~ msgstr "ni in"

#, fuzzy
#~ msgid "Program does not use Unix-f77 dialectal features"
#~ msgstr "OYA Gukoresha Ibiranga"

#, fuzzy
#~ msgid "Program is written in Fortran-90-ish dialect"
#~ msgstr "ni in"

#, fuzzy
#~ msgid "Treat local vars and COMMON blocks as if they were named in SAVE statements"
#~ msgstr "Na Nka NIBA in"

#, fuzzy
#~ msgid "Allow $ in symbol names"
#~ msgstr "in IKIMENYETSO Amazina"

#, fuzzy
#~ msgid "f2c-compatible code need not be generated"
#~ msgstr "ITEGEKONGENGA OYA"

#, fuzzy
#~ msgid "Unsupported; do not generate libf2c-calling code"
#~ msgstr "OYA ITEGEKONGENGA"

#, fuzzy
#~ msgid "Unsupported; affects code-generation of arrays"
#~ msgstr "ITEGEKONGENGA Bya"

#, fuzzy
#~ msgid "Program is written in Fortran-90-ish free form"
#~ msgstr "ni in Kigenga Ifishi"

#, fuzzy
#~ msgid "Warn about use of (only a few for now) Fortran extensions"
#~ msgstr "Ibyerekeye Gukoresha Bya a kugirango NONEAHA Umigereka"

#, fuzzy
#~ msgid "Program is written in VXT (Digital-like) FORTRAN"
#~ msgstr "ni in nka"

#, fuzzy
#~ msgid "Disallow all ugly features"
#~ msgstr "Byose Ibiranga"

#, fuzzy
#~ msgid "Hollerith and typeless constants not passed as arguments"
#~ msgstr "Na OYA Nka ingingo"

#, fuzzy
#~ msgid "Allow ordinary copying of ASSIGN'ed vars"
#~ msgstr "Bya"

#, fuzzy
#~ msgid "Dummy array dimensioned to (1) is assumed-size"
#~ msgstr "Imbonerahamwe Kuri 1. ni Ingano"

#, fuzzy
#~ msgid "Trailing comma in procedure call denotes null argument"
#~ msgstr "Akitso in NTAGIHARI"

#, fuzzy
#~ msgid "Allow REAL(Z) and AIMAG(Z) given DOUBLE COMPLEX Z"
#~ msgstr "Na"

#, fuzzy
#~ msgid "Initialization via DATA and PARAMETER is type-compatible"
#~ msgstr "Biturutse Na ni Ubwoko"

#, fuzzy
#~ msgid "Allow INTEGER and LOGICAL interchangeability"
#~ msgstr "Na"

#, fuzzy
#~ msgid "Print internal debugging-related info"
#~ msgstr "By'imbere Ibisobanuro"

#, fuzzy
#~ msgid "Initialize local vars and arrays to zero"
#~ msgstr "Na Kuri Zeru"

#, fuzzy
#~ msgid "Backslashes in character/hollerith constants not special (C-style)"
#~ msgstr "in Inyuguti OYA Bidasanzwe C IMISUSIRE"

#, fuzzy
#~ msgid "Have front end emulate COMPLEX arithmetic to avoid bugs"
#~ msgstr "Imbere Impera Kuri"

#, fuzzy
#~ msgid "Disable the appending of underscores to externals"
#~ msgstr "i Bya Kuri"

#, fuzzy
#~ msgid "Never append a second underscore to externals"
#~ msgstr "Kongeraho... a ISEGONDA Kuri"

#, fuzzy
#~ msgid "Intrinsics spelled as e.g. SqRt"
#~ msgstr "g."

#, fuzzy
#~ msgid "Intrinsics in uppercase"
#~ msgstr "in Inyuguti nkuru"

#, fuzzy
#~ msgid "Intrinsics letters in arbitrary cases"
#~ msgstr "in"

#, fuzzy
#~ msgid "Language keywords spelled as e.g. IOStat"
#~ msgstr "g."

#, fuzzy
#~ msgid "Language keywords in uppercase"
#~ msgstr "Amagambo fatizo in Inyuguti nkuru"

#, fuzzy
#~ msgid "Language keyword letters in arbitrary cases"
#~ msgstr "Ijambo- banze in"

#, fuzzy
#~ msgid "Internally convert most source to uppercase"
#~ msgstr "GUHINDURA Inkomoko Kuri Inyuguti nkuru"

#, fuzzy
#~ msgid "Internally preserve source case"
#~ msgstr "Inkomoko"

#, fuzzy
#~ msgid "Symbol names spelled in mixed case"
#~ msgstr "Amazina in Bivanze"

#, fuzzy
#~ msgid "Symbol names in uppercase"
#~ msgstr "Amazina in Inyuguti nkuru"

#, fuzzy
#~ msgid "Symbol names in lowercase"
#~ msgstr "Amazina in Inyuguti nto"

#, fuzzy
#~ msgid "Program written in uppercase"
#~ msgstr "in Inyuguti nkuru"

#, fuzzy
#~ msgid "Program written in lowercase"
#~ msgstr "in Inyuguti nto"

#, fuzzy
#~ msgid "Program written in strict mixed-case"
#~ msgstr "in Bivanze"

#, fuzzy
#~ msgid "Compile as if program written in uppercase"
#~ msgstr "Nka NIBA Porogaramu in Inyuguti nkuru"

#, fuzzy
#~ msgid "Compile as if program written in lowercase"
#~ msgstr "Nka NIBA Porogaramu in Inyuguti nto"

#, fuzzy
#~ msgid "Preserve all spelling (case) used in program"
#~ msgstr "Byose Ivuganyuguti in Porogaramu"

#, fuzzy
#~ msgid "Delete libU77 intrinsics with bad interfaces"
#~ msgstr "Na:"

#, fuzzy
#~ msgid "Disable libU77 intrinsics with bad interfaces"
#~ msgstr "Na:"

#, fuzzy
#~ msgid "Hide libU77 intrinsics with bad interfaces"
#~ msgstr "Na:"

#, fuzzy
#~ msgid "Treat initial values of 0 like non-zero values"
#~ msgstr "Uduciro Bya 0 nka Zeru Uduciro"

#, fuzzy
#~ msgid "Emit special debugging information for COMMON and EQUIVALENCE (disabled)"
#~ msgstr "Bidasanzwe Ibisobanuro kugirango Na Yahagaritswe"

#, fuzzy
#~ msgid "Take at least one trip through each iterative DO loop"
#~ msgstr "ku Gihinguranya"

#, fuzzy
#~ msgid "Print names of program units as they are compiled"
#~ msgstr "Amazina Bya Porogaramu Nka"

#, fuzzy
#~ msgid "Disable fatal diagnostics about inter-procedural problems"
#~ msgstr "Ibyerekeye"

#, fuzzy
#~ msgid "Make prefix-radix non-decimal constants be typeless"
#~ msgstr "Imbanziriza radix NYACUMI"

#, fuzzy
#~ msgid "Generate code to check subscript and substring bounds"
#~ msgstr "ITEGEKONGENGA Kuri Kugenzura... Inyandiko nyesi Na"

#, fuzzy
#~ msgid "Fortran-specific form of -fbounds-check"
#~ msgstr "Ifishi Bya Kugenzura..."

#, fuzzy
#~ msgid "Disable warnings about inter-procedural problems"
#~ msgstr "Iburira Ibyerekeye"

#, fuzzy
#~ msgid "Warn about constructs with surprising meanings"
#~ msgstr "Ibyerekeye Na:"

#, fuzzy
#~ msgid "Add a directory for INCLUDE searching"
#~ msgstr "a bushyinguro kugirango Ishakisha"

#, fuzzy
#~ msgid "Set the maximum line length"
#~ msgstr "i Kinini Umurongo Uburebure"

#, fuzzy
#~ msgid "Missing first operand for binary operator at %0"
#~ msgstr "Itangira kugirango Nyabibiri Mukoresha ku"

#, fuzzy
#~ msgid "Zero-length character constant at %0"
#~ msgstr "Uburebure Inyuguti ku"

#, fuzzy
#~ msgid "Invalid token at %0 in expression or subexpression at %1"
#~ msgstr "ku in imvugo Cyangwa ku"

#, fuzzy
#~ msgid "Missing operand for operator at %1 at end of expression at %0"
#~ msgstr "kugirango Mukoresha ku ku Impera Bya imvugo ku"

#, fuzzy
#~ msgid "Label %A already defined at %1 when redefined at %0"
#~ msgstr "ku Ryari: ku"

#, fuzzy
#~ msgid "Unrecognized character at %0 [info -f g77 M LEX]"
#~ msgstr "Inyuguti ku Ibisobanuro F"

#, fuzzy
#~ msgid "Label definition %A at %0 on empty statement (as of %1)"
#~ msgstr "Insobanuro ku ku ubusa Inyandiko Nka Bya"

#, fuzzy
#~ msgid "Invalid first character at %0 [info -f g77 M LEX]"
#~ msgstr "Itangira Inyuguti ku Ibisobanuro F"

#, fuzzy
#~ msgid "Line too long as of %0 [info -f g77 M LEX]"
#~ msgstr "Nka Bya Ibisobanuro F"

#, fuzzy
#~ msgid "Non-numeric character at %0 in label field [info -f g77 M LEX]"
#~ msgstr "Bikurikije umubare Inyuguti ku in Akarango Umwanya Ibisobanuro F"

#, fuzzy
#~ msgid "Label number at %0 not in range 1-99999"
#~ msgstr "Umubare ku OYA in Urutonde 1."

#, fuzzy
#~ msgid "At %0, '!' and '/*' are not valid comment delimiters"
#~ msgstr "Na OYA Byemewe Icyo wongeraho"

#, fuzzy
#~ msgid "Continuation indicator at %0 must appear in column 6 [info -f g77 M LEX]"
#~ msgstr "ku Kugaragara in Inkingi 6 Ibisobanuro F"

#, fuzzy
#~ msgid "Label at %0 invalid with continuation line indicator at %1 [info -f g77 M LEX]"
#~ msgstr "ku Sibyo Na: Umurongo ku Ibisobanuro F"

#, fuzzy
#~ msgid "Character constant at %0 has no closing apostrophe at %1"
#~ msgstr "ku Oya ku"

#, fuzzy
#~ msgid "Hollerith constant at %0 specified %A more characters than are present as of %1"
#~ msgstr "ku Birenzeho Inyuguti Nka Bya"

#, fuzzy
#~ msgid "Missing close parenthese at %0 needed to match open parenthese at %1"
#~ msgstr "Gufunga ku Kuri BIHUYE Gufungura ku"

#, fuzzy
#~ msgid "Integer at %0 too large"
#~ msgstr "ku Binini"

#, fuzzy
#~ msgid "Period at %0 not followed by digits for floating-point number or by `NOT.', `TRUE.', or `FALSE.'"
#~ msgstr "Igihe ku OYA ku kugirango Bihindagurika Akadomo Umubare Cyangwa ku Cyangwa"

#, fuzzy
#~ msgid "Missing close-period between `.%A' at %0 and %1"
#~ msgstr "Gufunga Igihe hagati ku Na"

#, fuzzy
#~ msgid "Invalid exponent at %0 for real constant at %1; nondigit `%A' in exponent field"
#~ msgstr "ku kugirango ku in Umwanya"

#, fuzzy
#~ msgid "Missing value at %1 for real-number exponent at %0"
#~ msgstr "Agaciro ku kugirango Umubare ku"

#, fuzzy
#~ msgid "Expected binary operator between expressions at %0 and at %1"
#~ msgstr "Itegerejwe Nyabibiri Mukoresha hagati ku Na ku"

#, fuzzy
#~ msgid "Semicolon at %0 is an invalid token"
#~ msgstr "ku ni Sibyo"

#, fuzzy
#~ msgid "Extraneous comma in FORMAT statement at %0"
#~ msgstr "Akitso in Inyandiko ku"

#, fuzzy
#~ msgid "Missing comma in FORMAT statement at %0"
#~ msgstr "Akitso in Inyandiko ku"

#, fuzzy
#~ msgid "Spurious sign in FORMAT statement at %0"
#~ msgstr "IKIMENYETSO in Inyandiko ku"

#, fuzzy
#~ msgid "Spurious number in FORMAT statement at %0"
#~ msgstr "Umubare in Inyandiko ku"

#, fuzzy
#~ msgid "Spurious text trailing number in FORMAT statement at %0"
#~ msgstr "Umwandiko Umubare in Inyandiko ku"

#, fuzzy
#~ msgid "Unrecognized FORMAT specifier at %0"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Missing close-parenthese(s) in FORMAT statement at %0"
#~ msgstr "Gufunga S in Inyandiko ku"

#, fuzzy
#~ msgid "Missing number following period in FORMAT statement at %0"
#~ msgstr "Umubare Igihe in Inyandiko ku"

#, fuzzy
#~ msgid "Missing number following `E' in FORMAT statement at %0"
#~ msgstr "Umubare in Inyandiko ku"

#, fuzzy
#~ msgid "Spurious trailing comma preceding terminator at %0"
#~ msgstr "Akitso ku"

#, fuzzy
#~ msgid "At %0, specify OPERATOR instead of ASSIGNMENT for INTERFACE statement not specifying the assignment operator (=)"
#~ msgstr "Bya kugirango Inyandiko OYA i Igenera Mukoresha"

#, fuzzy
#~ msgid "At %0, specify ASSIGNMENT instead of OPERATOR for INTERFACE statement specifying the assignment operator (=)"
#~ msgstr "Bya kugirango Inyandiko i Igenera Mukoresha"

#, fuzzy
#~ msgid "Cannot specify =initialization-expr at %0 unless `::' appears before list of objects"
#~ msgstr "ku Mbere Urutonde Bya Ibintu"

#, fuzzy
#~ msgid "Reference to label at %1 inconsistent with its definition at %0"
#~ msgstr "Kuri Akarango ku Na: Insobanuro ku"

#, fuzzy
#~ msgid "Reference to label at %1 inconsistent with earlier reference at %0"
#~ msgstr "Kuri Akarango ku Na: Indango ku"

#, fuzzy
#~ msgid "DO-statement reference to label at %1 follows its definition at %0"
#~ msgstr "Inyandiko Indango Kuri Akarango ku Insobanuro ku"

#, fuzzy
#~ msgid "Reference to label at %1 is outside block containing definition at %0"
#~ msgstr "Kuri Akarango ku ni Hanze Funga Insobanuro ku"

#, fuzzy
#~ msgid "DO-statement references to label at %0 and %2 separated by unterminated block starting at %1"
#~ msgstr "Inyandiko Indango Kuri Akarango ku Na ku Funga ku"

#, fuzzy
#~ msgid "DO-statement reference to label at %0 and label definition at %2 separated by unterminated block starting at %1"
#~ msgstr "Inyandiko Indango Kuri Akarango ku Na Akarango Insobanuro ku ku Funga ku"

#, fuzzy
#~ msgid "Label definition at %0 invalid on this kind of statement"
#~ msgstr "Insobanuro ku Sibyo ku iyi Bya Inyandiko"

#, fuzzy
#~ msgid "Statement at %0 invalid in this context"
#~ msgstr "ku Sibyo in iyi Imvugiro"

#, fuzzy
#~ msgid "Statement at %0 invalid in context established by statement at %1"
#~ msgstr "ku Sibyo in Imvugiro ku Inyandiko ku"

#, fuzzy
#~ msgid "Statement at %0 must specify construct name specified at %1"
#~ msgstr "ku Izina: ku"

#, fuzzy
#~ msgid "Construct name at %0 superfluous, no construct name specified at %1"
#~ msgstr "Izina: ku Oya Izina: ku"

#, fuzzy
#~ msgid "Construct name at %0 not the same as construct name at %1"
#~ msgstr "Izina: ku OYA i Nka Izina: ku"

#, fuzzy
#~ msgid "Construct name at %0 does not match construct name for any containing DO constructs"
#~ msgstr "Izina: ku OYA BIHUYE Izina: kugirango"

#, fuzzy
#~ msgid "Label definition missing at %0 for DO construct specifying label at %1"
#~ msgstr "Insobanuro Ibuze ku kugirango Akarango ku"

#, fuzzy
#~ msgid "Statement at %0 follows ELSE block for IF construct at %1"
#~ msgstr "ku Funga kugirango ku"

#, fuzzy
#~ msgid "No label definition for FORMAT statement at %0"
#~ msgstr "Akarango Insobanuro kugirango Inyandiko ku"

#, fuzzy
#~ msgid "Second occurrence of ELSE WHERE at %0 within WHERE at %1"
#~ msgstr "ukugaragara Bya ku muri ku"

#, fuzzy
#~ msgid "END statement at %0 missing `%A' keyword required for internal or module procedure(s) bounded by %1"
#~ msgstr "Inyandiko ku Ibuze Ijambo- banze Bya ngombwa kugirango By'imbere Cyangwa Modire S ku"

#, fuzzy
#~ msgid "MODULE PROCEDURE statement at %0 disallowed because INTERFACE at %1 specifies no generic name, operator, or assignment"
#~ msgstr "Inyandiko ku ku Oya Gifitanye isano Izina: Mukoresha Cyangwa Igenera"

#, fuzzy
#~ msgid "BLOCK DATA name at %0 superfluous, no name specified at %1"
#~ msgstr "Izina: ku Oya Izina: ku"

#, fuzzy
#~ msgid "Program name at %0 superfluous, no PROGRAM statement specified at %1"
#~ msgstr "Izina: ku Oya Inyandiko ku"

#, fuzzy
#~ msgid "Program unit name at %0 not the same as name at %1"
#~ msgstr "Igice: Izina: ku OYA i Nka Izina: ku"

#, fuzzy
#~ msgid "Type name at %0 not the same as name at %1"
#~ msgstr "Izina: ku OYA i Nka Izina: ku"

#, fuzzy
#~ msgid "End of source file before end of block started at %0"
#~ msgstr "Impera Bya Inkomoko IDOSIYE Mbere Impera Bya Funga ku"

#, fuzzy
#~ msgid "Undefined label, first referenced at %0"
#~ msgstr "Akarango Itangira ku"

#, fuzzy
#~ msgid "SAVE statement or attribute at %1 cannot be specified along with SAVE statement or attribute at %0"
#~ msgstr "Inyandiko Cyangwa Ikiranga ku Na: Inyandiko Cyangwa Ikiranga ku"

#, fuzzy
#~ msgid "PUBLIC or PRIVATE statement at %1 cannot be specified along with PUBLIC or PRIVATE statement at %0"
#~ msgstr "Cyangwa Inyandiko ku Na: Cyangwa Inyandiko ku"

#, fuzzy
#~ msgid "RETURN statement at %0 invalid within a main program unit"
#~ msgstr "Inyandiko ku Sibyo muri a Porogaramu Igice:"

#, fuzzy
#~ msgid "Alternate return specifier at %0 invalid within a main program unit"
#~ msgstr "Garuka ku Sibyo muri a Porogaramu Igice:"

#, fuzzy
#~ msgid "Alternate return specifier at %0 invalid within a function"
#~ msgstr "Garuka ku Sibyo muri a Umumaro"

#, fuzzy
#~ msgid "Access specifier or PRIVATE statement at %0 invalid for derived-type definition within other than the specification part of a module"
#~ msgstr "Cyangwa Inyandiko ku Sibyo kugirango Ubwoko Insobanuro muri Ikindi i Bya a Modire"

#, fuzzy
#~ msgid "Access specifier at %0 must immediately follow derived-type statement at %1 with no intervening statements"
#~ msgstr "ku Ako kanya Ubwoko Inyandiko ku Na: Oya"

#, fuzzy
#~ msgid "No components specified as of %0 for derived-type definition beginning at %1"
#~ msgstr "Nka Bya kugirango Ubwoko Insobanuro Itangiriro ku"

#, fuzzy
#~ msgid "No components specified as of %0 for structure definition beginning at %1"
#~ msgstr "Nka Bya kugirango Imiterere Insobanuro Itangiriro ku"

#, fuzzy
#~ msgid "Missing structure name for outer structure definition at %0"
#~ msgstr "Imiterere Izina: kugirango hanze Imiterere Insobanuro ku"

#, fuzzy
#~ msgid "Field names at %0 for outer structure definition -- specify them in a subsequent RECORD statement instead"
#~ msgstr "Amazina ku kugirango hanze Imiterere Insobanuro in a Inyandiko"

#, fuzzy
#~ msgid "Missing field name(s) for structure definition at %0 within structure definition at %1"
#~ msgstr "Umwanya Izina: S kugirango Imiterere Insobanuro ku muri Imiterere Insobanuro ku"

#, fuzzy
#~ msgid "No components specified as of %0 for map beginning at %1"
#~ msgstr "Nka Bya kugirango Itangiriro ku"

#, fuzzy
#~ msgid "Zero or one maps specified as of %0 for union beginning at %1 -- at least two are required"
#~ msgstr "Cyangwa Amakarita Nka Bya kugirango Ihuza Itangiriro ku ku Bya ngombwa"

#, fuzzy
#~ msgid "Missing %A specifier in statement at %0"
#~ msgstr "in Inyandiko ku"

#, fuzzy
#~ msgid "Items in I/O list starting at %0 invalid for namelist-directed I/O"
#~ msgstr "in Urutonde ku Sibyo kugirango"

#, fuzzy
#~ msgid "Conflicting I/O control specifications at %0 and %1"
#~ msgstr "Igenzura ku Na"

#, fuzzy
#~ msgid "No UNIT= specifier in I/O control list at %0"
#~ msgstr "URUGERO in Igenzura Urutonde ku"

#, fuzzy
#~ msgid "Specification at %0 requires ADVANCE=`NO' specification in same I/O control list"
#~ msgstr "ku in Igenzura Urutonde"

#, fuzzy
#~ msgid "Specification at %0 requires explicit FMT= specification in same I/O control list"
#~ msgstr "ku in Igenzura Urutonde"

#, fuzzy
#~ msgid "Second occurrence of CASE DEFAULT at %0 within SELECT CASE at %1"
#~ msgstr "ukugaragara Bya ku muri ku"

#, fuzzy
#~ msgid "Duplicate or overlapping case values/ranges at %0 and %1"
#~ msgstr "Cyangwa iyorosa Uduciro Ibice ku Na"

#, fuzzy
#~ msgid "Type and/or kind-type parameter disagreement between CASE value or value within range at %0 and SELECT CASE at %1"
#~ msgstr "Na Cyangwa Ubwoko hagati Agaciro Cyangwa Agaciro muri Urutonde ku Na ku"

#, fuzzy
#~ msgid "Range specification at %0 invalid for CASE statement within logical-type SELECT CASE statement"
#~ msgstr "ku Sibyo kugirango Inyandiko muri Bijyanye n'inyurabwenge Ubwoko Inyandiko"

#, fuzzy
#~ msgid "Fortran 90 feature at %0 unsupported"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Invalid declaration of or reference to symbol `%A' at %0 [initially seen at %1]"
#~ msgstr "Bya Cyangwa Indango Kuri IKIMENYETSO ku ku"

#, fuzzy
#~ msgid "Null element at %0 for array reference at %1"
#~ msgstr "Ikigize: ku kugirango Imbonerahamwe Indango ku"

#, fuzzy
#~ msgid "Too few elements (%A missing) as of %0 for array reference at %1"
#~ msgstr "Ibintu Ibuze Nka Bya kugirango Imbonerahamwe Indango ku"

#, fuzzy
#~ msgid "Too many elements as of %0 for array reference at %1"
#~ msgstr "Ibintu Nka Bya kugirango Imbonerahamwe Indango ku"

#, fuzzy
#~ msgid "Missing colon as of %0 in substring reference for %1"
#~ msgstr "Nka Bya in Indango kugirango"

#, fuzzy
#~ msgid "Invalid use at %0 of substring operator on %1"
#~ msgstr "Gukoresha %1 ku Bya Mukoresha ku"

#, fuzzy
#~ msgid "Substring begin/end point at %0 out of defined range"
#~ msgstr "Impera Akadomo ku Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "Array element value at %0 out of defined range"
#~ msgstr "Ikigize: Agaciro ku Inyuma Bya Urutonde"

#, fuzzy
#~ msgid "Expression at %0 has incorrect data type or rank for its context"
#~ msgstr "ku Ibyatanzwe Ubwoko Cyangwa IGICE kugirango Imvugiro"

#, fuzzy
#~ msgid "Division by 0 (zero) at %0 (IEEE not yet supported)"
#~ msgstr "ku 0 Zeru ku OYA"

#, fuzzy
#~ msgid "%A step count known to be 0 (zero) at %0"
#~ msgstr "%AIntera IBARA Kuri 0 Zeru ku"

#, fuzzy
#~ msgid "%A end value plus step count known to overflow at %0"
#~ msgstr "%AImpera Agaciro Guteranya Intera IBARA Kuri Byarenze urugero ku"

#, fuzzy
#~ msgid "%A begin, end, and step-count values known to result in implementation-dependent behavior due to overflow(s) in intermediate calculations at %0"
#~ msgstr "%AImpera Na Intera IBARA Uduciro Kuri Igisubizo in imyitwarire Kuri Byarenze urugero S in ku"

#, fuzzy
#~ msgid "%A begin, end, and step-count values known to result in no iterations at %0"
#~ msgstr "%AImpera Na Intera IBARA Uduciro Kuri Igisubizo in Oya Amasubiramo ku"

#, fuzzy
#~ msgid "Type disagreement between expressions at %0 and %1"
#~ msgstr "hagati ku Na"

#, fuzzy
#~ msgid "No specification for implied-DO iterator `%A' at %0"
#~ msgstr "kugirango ku"

#, fuzzy
#~ msgid "Gratuitous parentheses surround implied-DO construct at %0"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Zero-size specification invalid at %0"
#~ msgstr "Ingano Sibyo ku"

#, fuzzy
#~ msgid "Zero-size array at %0"
#~ msgstr "Ingano Imbonerahamwe ku"

#, fuzzy
#~ msgid "Target machine does not support complex entity of kind specified at %0"
#~ msgstr "OYA Gushigikira ITSINDA RY'IMIBARE C Bya ku"

#, fuzzy
#~ msgid "Target machine does not support DOUBLE COMPLEX, specified at %0"
#~ msgstr "OYA Gushigikira ku"

#, fuzzy
#~ msgid "Attempt to raise constant zero to a power at %0"
#~ msgstr "Kuri Zeru Kuri a UMWIKUBE ku"

#, fuzzy
#~ msgid "Reference to generic intrinsic `%A' at %0 could be to form %B or %C"
#~ msgstr "Kuri Gifitanye isano ku Kuri Ifishi Cyangwa"

#, fuzzy
#~ msgid "Ambiguous use of intrinsic `%A' at %0 [info -f g77 M CMPAMBIG]"
#~ msgstr "Gukoresha Bya ku Ibisobanuro F"

#, fuzzy
#~ msgid "Intrinsic `%A' referenced %Bly at %0, %Cly at %1 [info -f g77 M EXPIMP]"
#~ msgstr "ku ku Ibisobanuro F"

#, fuzzy
#~ msgid "Same name `%A' used for %B at %0 and %C at %1 [info -f g77 M INTGLOB]"
#~ msgstr "Izina: kugirango ku Na ku Ibisobanuro F"

#, fuzzy
#~ msgid "Explicit type declaration for intrinsic `%A' disagrees with invocation at %0"
#~ msgstr "Ubwoko kugirango Na: ku"

#, fuzzy
#~ msgid "Unable to open INCLUDE file `%A' at %0"
#~ msgstr "Kuri Gufungura IDOSIYE ku"

#, fuzzy
#~ msgid "Null argument at %0 for statement function reference at %1"
#~ msgstr "ku kugirango Inyandiko Umumaro Indango ku"

#, fuzzy
#~ msgid "Null argument at %0 for procedure invocation at %1"
#~ msgstr "ku kugirango ku"

#, fuzzy
#~ msgid "%A too few arguments (starting with dummy argument `%B') as of %0 for statement function reference at %1"
#~ msgstr "%Aingingo Na: Ishusho Nka Bya kugirango Inyandiko Umumaro Indango ku"

#, fuzzy
#~ msgid "%A too many arguments as of %0 for statement function reference at %1"
#~ msgstr "%Aingingo Nka Bya kugirango Inyandiko Umumaro Indango ku"

#, fuzzy
#~ msgid "Array supplied at %1 for dummy argument `%A' in statement function reference at %0"
#~ msgstr "ku kugirango Ishusho in Inyandiko Umumaro Indango ku"

#, fuzzy
#~ msgid "Unsupported FORMAT specifier at %0"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Variable-expression FORMAT specifier at %0 -- unsupported"
#~ msgstr "imvugo ku"

#, fuzzy
#~ msgid "Unsupported VXT statement at %0"
#~ msgstr "Inyandiko ku"

#, fuzzy
#~ msgid "Attempt to specify second initial value for `%A' at %0"
#~ msgstr "Kuri ISEGONDA Agaciro kugirango ku"

#, fuzzy
#~ msgid "Too few initial values in list of initializers for `%A' at %0"
#~ msgstr "Uduciro in Urutonde Bya kugirango ku"

#, fuzzy
#~ msgid "Too many initial values in list of initializers starting at %0"
#~ msgstr "Uduciro in Urutonde Bya ku"

#, fuzzy
#~ msgid "Array or substring specification for `%A' out of range in statement at %0"
#~ msgstr "Cyangwa kugirango Inyuma Bya Urutonde in Inyandiko ku"

#, fuzzy
#~ msgid "Array subscript #%B out of range for initialization of `%A' in statement at %0"
#~ msgstr "Inyandiko nyesi Inyuma Bya Urutonde kugirango Bya in Inyandiko ku"

#, fuzzy
#~ msgid "Implied do-loop step count of 0 (zero) for iteration variable `%A' in statement at %0"
#~ msgstr "Intera IBARA Bya 0 Zeru kugirango IMPINDURAGACIRO in Inyandiko ku"

#, fuzzy
#~ msgid "Implied do-loop iteration count of 0 (zero) for iteration variable `%A' in statement at %0"
#~ msgstr "IBARA Bya 0 Zeru kugirango IMPINDURAGACIRO in Inyandiko ku"

#, fuzzy
#~ msgid "Not an integer constant expression in implied do-loop in statement at %0"
#~ msgstr "Umubare wuzuye imvugo in in Inyandiko ku"

#, fuzzy
#~ msgid "Attempt to specify second initial value for element of `%A' at %0"
#~ msgstr "Kuri ISEGONDA Agaciro kugirango Ikigize: Bya ku"

#, fuzzy
#~ msgid "Attempt to EQUIVALENCE common areas `%A' and `%B' at %0"
#~ msgstr "Kuri Ubuso Na ku"

#, fuzzy
#~ msgid "Can't place `%A' as directed by EQUIVALENCE due to alignment restrictions"
#~ msgstr "Nka ku Kuri Itunganya Amabwiriza"

#, fuzzy
#~ msgid "Mismatched EQUIVALENCE requirements for placement of `%A' at both %C and %D bytes offset from `%B'"
#~ msgstr "kugirango Ishyira mu mwanya Bya ku Byombi Na Bayite Nta- boneza Bivuye"

#, fuzzy
#~ msgid "Array or substring specification for `%A' out of range in EQUIVALENCE statement"
#~ msgstr "Cyangwa kugirango Inyuma Bya Urutonde in Inyandiko"

#, fuzzy
#~ msgid "Substring of non-CHARACTER entity `%A' in EQUIVALENCE statement"
#~ msgstr "Bya in Inyandiko"

#, fuzzy
#~ msgid "Array reference to scalar variable `%A' in EQUIVALENCE statement"
#~ msgstr "Indango Kuri IMPINDURAGACIRO in Inyandiko"

#, fuzzy
#~ msgid "Array subscript #%B out of range for EQUIVALENCE of `%A'"
#~ msgstr "Inyandiko nyesi Inyuma Bya Urutonde kugirango Bya"

#, fuzzy
#~ msgid "Attempt to extend COMMON area beyond its starting point via EQUIVALENCE of `%A'"
#~ msgstr "Kuri Ubuso Akadomo Biturutse Bya"

#, fuzzy
#~ msgid "Too few elements in reference to array `%A' in EQUIVALENCE statement"
#~ msgstr "Ibintu in Indango Kuri Imbonerahamwe in Inyandiko"

#, fuzzy
#~ msgid "Too many elements in reference to array `%A' in EQUIVALENCE statement"
#~ msgstr "Ibintu in Indango Kuri Imbonerahamwe in Inyandiko"

#, fuzzy
#~ msgid "Mixed CHARACTER and non-CHARACTER types via COMMON/EQUIVALENCE -- for example, `%A' and `%B'"
#~ msgstr "Na Biturutse kugirango Urugero Na"

#, fuzzy
#~ msgid "Return value `%A' for FUNCTION at %0 not referenced in subprogram"
#~ msgstr "Agaciro kugirango ku OYA in"

#, fuzzy
#~ msgid "Common block `%A' is SAVEd, explicitly or implicitly, at %0 but not SAVEd at %1"
#~ msgstr "Funga ni Cyangwa ku OYA ku"

#, fuzzy
#~ msgid "Common block `%A' is %B %D in length at %0 but %C %E at %1"
#~ msgstr "Funga ni in Uburebure ku ku"

#, fuzzy
#~ msgid "Blank common initialized at %0"
#~ msgstr "ku"

#, fuzzy
#~ msgid "Intrinsic `%A' is passed as actual argument at %0 but not explicitly declared INTRINSIC"
#~ msgstr "ni Nka ku OYA"

#, fuzzy
#~ msgid "External procedure `%A' is passed as actual argument at %0 but not explicitly declared EXTERNAL"
#~ msgstr "ni Nka ku OYA"

#, fuzzy
#~ msgid "Character `%A' (for example) is upper-case in symbol name at %0"
#~ msgstr "kugirango Urugero ni Nkuru in IKIMENYETSO Izina: ku"

#, fuzzy
#~ msgid "Character `%A' (for example) is lower-case in symbol name at %0"
#~ msgstr "kugirango Urugero ni Ntoya in IKIMENYETSO Izina: ku"

#, fuzzy
#~ msgid "Character `%A' not followed at some point by lower-case character in symbol name at %0"
#~ msgstr "OYA ku Akadomo ku Ntoya Inyuguti in IKIMENYETSO Izina: ku"

#, fuzzy
#~ msgid "Initial character `%A' is lower-case in symbol name at %0"
#~ msgstr "Inyuguti ni Ntoya in IKIMENYETSO Izina: ku"

#, fuzzy
#~ msgid "NAMELIST not adequately supported by run-time library for source files with case preserved"
#~ msgstr "OYA ku Gukoresha Igihe Isomero kugirango Inkomoko Idosiye Na:"

#, fuzzy
#~ msgid "Nested %% construct (%%VAL, %%REF, or %%DESCR) at %0"
#~ msgstr "Cyangwa ku"

#, fuzzy
#~ msgid "Statement at %0 invalid in BLOCK DATA program unit at %1"
#~ msgstr "ku Sibyo in Porogaramu Igice: ku"

#, fuzzy
#~ msgid "Truncating characters on right side of character constant at %0"
#~ msgstr "Inyuguti ku Iburyo: Bya Inyuguti ku"

#, fuzzy
#~ msgid "Truncating characters on right side of hollerith constant at %0"
#~ msgstr "Inyuguti ku Iburyo: Bya ku"

#, fuzzy
#~ msgid "Truncating non-zero data on left side of numeric constant at %0"
#~ msgstr "Zeru Ibyatanzwe ku Ibumoso: Bya Bikurikije umubare ku"

#, fuzzy
#~ msgid "Truncating non-zero data on left side of typeless constant at %0"
#~ msgstr "Zeru Ibyatanzwe ku Ibumoso: Bya ku"

#, fuzzy
#~ msgid "Typeless constant at %0 too large"
#~ msgstr "ku Binini"

#, fuzzy
#~ msgid "First-column ampersand continuation at %0"
#~ msgstr "Inkingi ku"

#, fuzzy
#~ msgid "Global name `%A' defined at %0 already defined at %1 [info -f g77 M GLOBALS]"
#~ msgstr "Izina: ku ku Ibisobanuro F"

#, fuzzy
#~ msgid "Global name `%A' is %B at %0 but is %C at %1 [info -f g77 M GLOBALS]"
#~ msgstr "Izina: ni ku ni ku Ibisobanuro F"

#, fuzzy
#~ msgid "Global name `%A' at %0 has different type at %1 [info -f g77 M GLOBALS]"
#~ msgstr "Izina: ku Ubwoko ku Ibisobanuro F"

#, fuzzy
#~ msgid "Too %B arguments passed to `%A' at %0 versus definition at %1 [info -f g77 M GLOBALS]"
#~ msgstr "ingingo Kuri ku Insobanuro ku Ibisobanuro F"

#, fuzzy
#~ msgid "Too %B arguments for `%A' at %0 versus invocation at %1 [info -f g77 M GLOBALS]"
#~ msgstr "ingingo kugirango ku ku Ibisobanuro F"

#, fuzzy
#~ msgid "Argument #%B of `%A' is %C at %0 but is %D at %1 [info -f g77 M GLOBALS]"
#~ msgstr "Bya ni ku ni ku Ibisobanuro F"

#, fuzzy
#~ msgid "Array `%A' at %0 is too large to handle"
#~ msgstr "ku ni Binini Kuri"

#, fuzzy
#~ msgid "Statement function `%A' defined at %0 is not used"
#~ msgstr "Umumaro ku ni OYA"

#, fuzzy
#~ msgid "Intrinsic `%A', invoked at %0, known to be non-Y2K-compliant [info -f g77 M Y2KBAD]"
#~ msgstr "ku Kuri Ibisobanuro F"

#, fuzzy
#~ msgid "Internal compiler error -- cannot perform operation"
#~ msgstr "Ikosa"

#, fuzzy
#~ msgid "In unknown kind"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "In function"
#~ msgstr "Umumaro"

#, fuzzy
#~ msgid "In program"
#~ msgstr "Porogaramu"

#, fuzzy
#~ msgid "In block-data unit"
#~ msgstr "Funga Ibyatanzwe Igice:"

#, fuzzy
#~ msgid "In common block"
#~ msgstr "Funga"

#, fuzzy
#~ msgid "internal error in check-init: tree code not implemented: %s"
#~ msgstr "By'imbere Ikosa in Kugenzura... ITEGEKONGENGA OYA"

#, fuzzy
#~ msgid "final field '%s' may not have been initialized"
#~ msgstr "Umwanya Gicurasi OYA"

#, fuzzy
#~ msgid "internal error - too many interface type"
#~ msgstr "By'imbere Ikosa Ubwoko"

#, fuzzy
#~ msgid "bad method signature"
#~ msgstr "Uburyo Isinya"

#, fuzzy
#~ msgid "misplaced ConstantValue attribute (not in any field)"
#~ msgstr "Ikiranga OYA in Umwanya"

#, fuzzy
#~ msgid "duplicate ConstantValue attribute for field '%s'"
#~ msgstr "Gusubiramo Ikiranga kugirango Umwanya"

#, fuzzy
#~ msgid "ConstantValue attribute of field '%s' has wrong type"
#~ msgstr "Ikiranga Bya Umwanya Ubwoko"

#, fuzzy
#~ msgid "field '%s' not found in class"
#~ msgstr "Umwanya OYA Byabonetse in ishuri"

#, fuzzy
#~ msgid "abstract method in non-abstract class"
#~ msgstr "Incamake Uburyo in Incamake ishuri"

#, fuzzy
#~ msgid "non-static method '%s' overrides static method"
#~ msgstr "Uburyo Uburyo"

#, fuzzy
#~ msgid "In %s: overlapped variable and exception ranges at %d"
#~ msgstr "IMPINDURAGACIRO Na Irengayobora(-) Ibice ku"

#, fuzzy
#~ msgid "bad type in parameter debug info"
#~ msgstr "Ubwoko in Kosora amakosa Ibisobanuro"

#, fuzzy
#~ msgid "bad PC range for debug info for local `%s'"
#~ msgstr "Urutonde kugirango Kosora amakosa Ibisobanuro kugirango"

#, fuzzy
#~ msgid "reference `%s' is ambiguous: appears in interface `%s' and interface `%s'"
#~ msgstr "Indango ni in Na"

#, fuzzy
#~ msgid "field `%s' not found"
#~ msgstr "Umwanya OYA Byabonetse"

#, fuzzy
#~ msgid "ret instruction not implemented"
#~ msgstr "OYA"

#, fuzzy
#~ msgid "method '%s' not found in class"
#~ msgstr "Uburyo OYA Byabonetse in ishuri"

#, fuzzy
#~ msgid "failed to find class '%s'"
#~ msgstr "Byanze Kuri Gushaka ishuri"

#, fuzzy
#~ msgid "class '%s' has no method named '%s' matching signature '%s'"
#~ msgstr "ishuri Oya Uburyo Isinya"

#, fuzzy
#~ msgid "invokestatic on non static method"
#~ msgstr "ku Uburyo"

#, fuzzy
#~ msgid "invokestatic on abstract method"
#~ msgstr "ku Incamake Uburyo"

#, fuzzy
#~ msgid "invoke[non-static] on static method"
#~ msgstr "ku Uburyo"

#, fuzzy
#~ msgid "missing field '%s' in '%s'"
#~ msgstr "Ibuze Umwanya in"

#, fuzzy
#~ msgid "mismatching signature for field '%s' in '%s'"
#~ msgstr "Isinya kugirango Umwanya in"

#, fuzzy
#~ msgid "assignment to final field `%s' not in field's class"
#~ msgstr "Igenera Kuri Umwanya OYA in ishuri"

#, fuzzy
#~ msgid "assignment to final static field `%s' not in class initializer"
#~ msgstr "Igenera Kuri Umwanya OYA in ishuri"

#, fuzzy
#~ msgid "assignment to final field `%s' not in constructor"
#~ msgstr "Igenera Kuri Umwanya OYA in"

#, fuzzy
#~ msgid "can't expand %s"
#~ msgstr "Kwagura"

#, fuzzy
#~ msgid "invalid PC in line number table"
#~ msgstr "Sibyo in Umurongo Umubare imbonerahamwe#"

#, fuzzy
#~ msgid "unreachable bytecode from %d to before %d"
#~ msgstr "Bivuye Kuri Mbere"

#, fuzzy
#~ msgid "unreachable bytecode from %d to the end of the method"
#~ msgstr "Bivuye Kuri i Impera Bya i Uburyo"

#, fuzzy
#~ msgid "source file for class `%s' is newer than its matching class file.  Source file `%s' used instead"
#~ msgstr "Inkomoko IDOSIYE kugirango ishuri ni ishuri IDOSIYE IDOSIYE"

#, fuzzy
#~ msgid "bad string constant"
#~ msgstr "Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "bad value constant type %d, index %d"
#~ msgstr "Agaciro Ubwoko Umubarendanga"

#, fuzzy
#~ msgid "can't close %s"
#~ msgstr "Gufunga"

#, fuzzy
#~ msgid "cannot find file for class %s"
#~ msgstr "Gushaka IDOSIYE kugirango ishuri"

#, fuzzy
#~ msgid "not a valid Java .class file"
#~ msgstr "OYA a Byemewe ishuri IDOSIYE"

#, fuzzy
#~ msgid "error while parsing constant pool"
#~ msgstr "Ikosa Itsinda"

#, fuzzy
#~ msgid "error in constant pool entry #%d\n"
#~ msgstr "Ikosa in Itsinda Icyinjijwe"

#, fuzzy
#~ msgid "reading class %s for the second time from %s"
#~ msgstr "ishuri kugirango i ISEGONDA Igihe Bivuye"

#, fuzzy
#~ msgid "error while parsing fields"
#~ msgstr "Ikosa Imyanya"

#, fuzzy
#~ msgid "error while parsing methods"
#~ msgstr "Ikosa"

#, fuzzy
#~ msgid "error while parsing final attributes"
#~ msgstr "Ikosa Ibiranga"

#, fuzzy
#~ msgid "the `java.lang.Object' that was found in `%s' didn't have the special zero-length `gnu.gcj.gcj-compiled' attribute.  This generally means that your classpath is incorrectly set.  Use `info gcj \"Input Options\"' to see the info page describing how to set the classpath"
#~ msgstr "i java Byabonetse in i Bidasanzwe Zeru Uburebure Ikiranga Inzirashuri ni Gushyiraho Ibisobanuro Kuri i Ibisobanuro Ipaji Kuri Gushyiraho i Inzirashuri"

#, fuzzy
#~ msgid "missing Code attribute"
#~ msgstr "Ibuze Ikiranga"

#, fuzzy
#~ msgid "source file seen twice on command line and will be compiled only once"
#~ msgstr "Inkomoko IDOSIYE ku Komandi: Umurongo Na Rimwe"

#, fuzzy
#~ msgid "no input file specified"
#~ msgstr "Oya Iyinjiza IDOSIYE"

#, fuzzy
#~ msgid "can't close input file %s"
#~ msgstr "Gufunga Iyinjiza IDOSIYE"

#, fuzzy
#~ msgid "bad zip/jar file %s"
#~ msgstr "Zipu IDOSIYE"

#, fuzzy
#~ msgid "internal error in generate_bytecode_insn - tree code not implemented: %s"
#~ msgstr "By'imbere Ikosa in ITEGEKONGENGA OYA"

#, fuzzy
#~ msgid "field initializer type mismatch"
#~ msgstr "Umwanya Ubwoko"

#, fuzzy
#~ msgid "can't create directory %s"
#~ msgstr "Kurema bushyinguro"

#, fuzzy
#~ msgid "can't create %s"
#~ msgstr "Kurema"

#, fuzzy
#~ msgid "only one of `--print-main', `--list-class', and `--complexity' allowed"
#~ msgstr "Bya Gucapa Urutonde Na"

#, fuzzy
#~ msgid "can't open output file `%s'"
#~ msgstr "Gufungura Ibisohoka IDOSIYE"

#, fuzzy
#~ msgid "file not found `%s'"
#~ msgstr "Dosiye ntibonetse"

#, fuzzy
#~ msgid "`%s' is not a valid class name"
#~ msgstr "`%s'ni OYA a Byemewe ishuri Izina:"

#, fuzzy
#~ msgid "--resource requires -o"
#~ msgstr "--o"

#, fuzzy
#~ msgid "warning: already-compiled .class files ignored with -C"
#~ msgstr "Iburira ishuri Idosiye Na: C"

#, fuzzy
#~ msgid "cannot specify both -C and -o"
#~ msgstr "Byombi C Na o"

#, fuzzy
#~ msgid "cannot create temporary file"
#~ msgstr "Kurema By'igihe gito IDOSIYE"

#, fuzzy
#~ msgid "using both @FILE with multiple files not implemented"
#~ msgstr "ikoresha Byombi Na: Igikubo Idosiye OYA"

#, fuzzy
#~ msgid "cannot specify `main' class when not linking"
#~ msgstr "ishuri Ryari: OYA Impuza"

#, fuzzy
#~ msgid "can't do dependency tracking with input from stdin"
#~ msgstr "Na: Iyinjiza Bivuye"

#, fuzzy
#~ msgid "couldn't determine target name for dependency tracking"
#~ msgstr "Intego Izina: kugirango"

#, fuzzy
#~ msgid ""
#~ "unknown encoding: `%s'\n"
#~ "This might mean that your locale's encoding is not supported\n"
#~ "by your system's iconv(3) implementation.  If you aren't trying\n"
#~ "to use a particular encoding for your input file, try the\n"
#~ "`--encoding=UTF-8' option"
#~ msgstr "Kitazwi Imisobekere: Impuzandengo- Imisobekere: ni OYA 3. Gukoresha a Imisobekere: kugirango Iyinjiza IDOSIYE Imisobekere: Ihitamo"

#, fuzzy
#~ msgid "internal error - invalid Utf8 name"
#~ msgstr "By'imbere Ikosa Sibyo Izina:"

#, fuzzy
#~ msgid "Missing term"
#~ msgstr "Ijambo"

# starmath/source\smres.src:RID_ERR_LGROUPEXPECTED.text
#, fuzzy
#~ msgid "';' expected"
#~ msgstr "';'ntigatunguranye"

#, fuzzy
#~ msgid "Missing name"
#~ msgstr "Izina:"

# starmath/source\smres.src:RID_ERR_LGROUPEXPECTED.text
#, fuzzy
#~ msgid "'*' expected"
#~ msgstr "'*'ntigatunguranye"

#, fuzzy
#~ msgid "Class or interface declaration expected"
#~ msgstr "Cyangwa Ikitezwe:"

#, fuzzy
#~ msgid "Missing class name"
#~ msgstr "ishuri Izina:"

#~ msgid "'{' expected"
#~ msgstr "'{' ntigatunguranye"

#, fuzzy
#~ msgid "Missing super class name"
#~ msgstr "hejuru ishuri Izina:"

#, fuzzy
#~ msgid "Missing interface name"
#~ msgstr "Izina:"

#, fuzzy
#~ msgid "Missing variable initializer"
#~ msgstr "IMPINDURAGACIRO"

# starmath/source\smres.src:RID_ERR_LGROUPEXPECTED.text
#, fuzzy
#~ msgid "']' expected"
#~ msgstr "']'ntigatunguranye"

#, fuzzy
#~ msgid "Invalid method declaration, method name required"
#~ msgstr "Uburyo Uburyo Izina: Bya ngombwa"

#~ msgid "Identifier expected"
#~ msgstr "Ikiranga ntigitunguranye"

#, fuzzy
#~ msgid "Invalid method declaration, return type required"
#~ msgstr "Uburyo Garuka Ubwoko Bya ngombwa"

#~ msgid "')' expected"
#~ msgstr "')' ntigatunguranye"

#, fuzzy
#~ msgid "Missing formal parameter term"
#~ msgstr "Ijambo"

#, fuzzy
#~ msgid "Missing identifier"
#~ msgstr "Ikiranga"

#, fuzzy
#~ msgid "Missing class type term"
#~ msgstr "ishuri Ubwoko Ijambo"

#, fuzzy
#~ msgid "Invalid interface type"
#~ msgstr "Ubwoko"

# starmath/source\smres.src:RID_ERR_LGROUPEXPECTED.text
#, fuzzy
#~ msgid "':' expected"
#~ msgstr "':'ntigatunguranye"

#, fuzzy
#~ msgid "Invalid expression statement"
#~ msgstr "imvugo Inyandiko"

#~ msgid "'(' expected"
#~ msgstr "'(' ntigatunguranye"

#, fuzzy
#~ msgid "Missing term or ')'"
#~ msgstr "Ijambo Cyangwa"

#, fuzzy
#~ msgid "Missing or invalid constant expression"
#~ msgstr "Cyangwa Sibyo imvugo"

#, fuzzy
#~ msgid "Missing term and ')' expected"
#~ msgstr "Ijambo Na Ikitezwe:"

#, fuzzy
#~ msgid "Invalid control expression"
#~ msgstr "Igenzura imvugo"

#, fuzzy
#~ msgid "Invalid update expression"
#~ msgstr "Kuvugurura imvugo"

#, fuzzy
#~ msgid "Invalid init statement"
#~ msgstr "Inyandiko"

#, fuzzy
#~ msgid "Missing term or ')' expected"
#~ msgstr "Ijambo Cyangwa Ikitezwe:"

#, fuzzy
#~ msgid "'class' or 'this' expected"
#~ msgstr "'Cyangwa Ikitezwe:"

#, fuzzy
#~ msgid "'class' expected"
#~ msgstr "'Ikitezwe:"

#, fuzzy
#~ msgid "')' or term expected"
#~ msgstr "')'Cyangwa Ijambo Ikitezwe:"

# starmath/source\smres.src:RID_ERR_LGROUPEXPECTED.text
#, fuzzy
#~ msgid "'[' expected"
#~ msgstr "'['ntigatunguranye"

#, fuzzy
#~ msgid "Field expected"
#~ msgstr "Ikitezwe:"

#, fuzzy
#~ msgid "Missing term and ']' expected"
#~ msgstr "Ijambo Na Ikitezwe:"

#, fuzzy
#~ msgid "']' expected, invalid type expression"
#~ msgstr "']'Ikitezwe: Sibyo Ubwoko imvugo"

#, fuzzy
#~ msgid "Invalid type expression"
#~ msgstr "Ubwoko imvugo"

#, fuzzy
#~ msgid "Invalid reference type"
#~ msgstr "Indango Ubwoko"

#, fuzzy
#~ msgid "Constructor invocation must be first thing in a constructor"
#~ msgstr "Itangira in a"

#, fuzzy
#~ msgid ": `%s' JDK1.1(TM) feature"
#~ msgstr ":`%s'1."

# desktop/source\app\ssodlg.src:DLG_SSOLOGIN.text
#, fuzzy
#~ msgid ""
#~ "%s.\n"
#~ "%s"
#~ msgstr "%s.%s"

#, fuzzy
#~ msgid "malformed .zip archive in CLASSPATH: %s"
#~ msgstr "Zipu in"

#, fuzzy
#~ msgid "Can't find default package `%s'. Check the CLASSPATH environment variable and the access to the archives"
#~ msgstr "Gushaka Mburabuzi i IMPINDURAGACIRO Na i Kuri i Ubushyinguro"

#, fuzzy
#~ msgid "missing static field `%s'"
#~ msgstr "Ibuze Umwanya"

#, fuzzy
#~ msgid "not a static field `%s'"
#~ msgstr "OYA a Umwanya"

#, fuzzy
#~ msgid "No case for %s"
#~ msgstr "kugirango"

#, fuzzy
#~ msgid "unregistered operator %s"
#~ msgstr "Mukoresha"

#, fuzzy
#~ msgid "junk at end of signature string"
#~ msgstr "Umwanda ku Impera Bya Isinya Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "bad pc in exception_table"
#~ msgstr "in"

#, fuzzy
#~ msgid "exception handler inside code that is being protected"
#~ msgstr "Irengayobora(-) Mo Imbere ITEGEKONGENGA ni Birinzwe"

#, fuzzy
#~ msgid "unknown opcode %d@pc=%d during verification"
#~ msgstr "Kitazwi"

#, fuzzy
#~ msgid "verification error at PC=%d"
#~ msgstr "Ikosa ku"

#, fuzzy
#~ msgid "Disable automatic array bounds checking"
#~ msgstr "Byikoresha Imbonerahamwe"

#, fuzzy
#~ msgid "Disable assignability checks for stores into object arrays"
#~ msgstr "kugirango Igikoresho"

#, fuzzy
#~ msgid "Assume native functions are implemented using JNI"
#~ msgstr "Imimaro ikoresha"

#, fuzzy
#~ msgid "Replace system path"
#~ msgstr "Sisitemu Inzira"

#, fuzzy
#~ msgid "Set class path"
#~ msgstr "ishuri Inzira"

#, fuzzy
#~ msgid "Set class path (deprecated: use --classpath instead)"
#~ msgstr "ishuri Inzira Bitemewe. Gukoresha Inzirashuri"

#, fuzzy
#~ msgid "Choose class whose main method should be used"
#~ msgstr "ishuri bya Uburyo"

#, fuzzy
#~ msgid "Choose input encoding (default comes from locale)"
#~ msgstr "Iyinjiza Imisobekere: Mburabuzi Bivuye Umwanya"

#, fuzzy
#~ msgid "Add directory to class path"
#~ msgstr "bushyinguro Kuri ishuri Inzira"

#, fuzzy
#~ msgid "Directory where class files should be written"
#~ msgstr "ishuri Idosiye"

#, fuzzy
#~ msgid "Warn if modifiers are specified when not necessary"
#~ msgstr "NIBA Ryari: OYA"

#, fuzzy
#~ msgid "Warn if deprecated empty statements are found"
#~ msgstr "NIBA Bitemewe. ubusa Byabonetse"

#, fuzzy
#~ msgid "Warn if .class files are out of date"
#~ msgstr "NIBA ishuri Idosiye Inyuma Bya Itariki"

#, fuzzy
#~ msgid "Always check for non gcj generated classes archives"
#~ msgstr "Kugenzura... kugirango Inzego Ubushyinguro"

#, fuzzy
#~ msgid "Never optimize static class initialization code"
#~ msgstr "Kugeza ku ndunduro ishuri ITEGEKONGENGA"

#, fuzzy
#~ msgid "Use offset tables for virtual method calls"
#~ msgstr "Nta- boneza Imbonerahamwe kugirango Kitaboneka Uburyo Amahamagara:"

#, fuzzy
#~ msgid "object does not conform to the `%s' protocol"
#~ msgstr "Igikoresho OYA Kuri i Porotokole"

#, fuzzy
#~ msgid "class `%s' does not implement the `%s' protocol"
#~ msgstr "ishuri OYA i Porotokole"

#, fuzzy
#~ msgid "unexpected type for `id' (%s)"
#~ msgstr "Ubwoko kugirango"

#, fuzzy
#~ msgid "undefined type `id', please import <objc/objc.h>"
#~ msgstr "kidasobanuye Ubwoko Kuzana h"

#, fuzzy
#~ msgid "protocol `%s' has circular dependency"
#~ msgstr "Porotokole Cy'uruziga"

#, fuzzy
#~ msgid "cannot find protocol declaration for `%s'"
#~ msgstr "Gushaka Porotokole kugirango"

#, fuzzy
#~ msgid "cannot find interface declaration for `%s'"
#~ msgstr "Gushaka kugirango"

#, fuzzy
#~ msgid "cannot find reference tag for class `%s'"
#~ msgstr "Gushaka Indango Itagi: kugirango ishuri"

#, fuzzy
#~ msgid "creating selector for non existant method %s"
#~ msgstr "kugirango Uburyo"

#, fuzzy
#~ msgid "cannot find class `%s'"
#~ msgstr "Gushaka ishuri"

#, fuzzy
#~ msgid "class `%s' already exists"
#~ msgstr "ishuri"

#, fuzzy
#~ msgid "cannot find interface declaration for `%s', superclass of `%s'"
#~ msgstr "Gushaka kugirango Bya"

#, fuzzy
#~ msgid "circular inheritance in interface declaration for `%s'"
#~ msgstr "Cy'uruziga in kugirango"

#, fuzzy
#~ msgid "inconsistent instance variable specification"
#~ msgstr "Urugero IMPINDURAGACIRO"

#, fuzzy
#~ msgid "can not use an object as parameter to a method\n"
#~ msgstr "OYA Gukoresha Igikoresho Nka Kuri a"

#, fuzzy
#~ msgid "multiple declarations for method `%s'"
#~ msgstr "Igikubo kugirango Uburyo"

#, fuzzy
#~ msgid "invalid receiver type `%s'"
#~ msgstr "Sibyo Mwakirizi Ubwoko"

#, fuzzy
#~ msgid "`%s' does not respond to `%s'"
#~ msgstr "`%s'OYA Kuri"

#, fuzzy
#~ msgid "no super class declared in interface for `%s'"
#~ msgstr "Oya hejuru ishuri in kugirango"

#, fuzzy
#~ msgid "cannot find class (factory) method"
#~ msgstr "Gushaka ishuri Uburyo"

#, fuzzy
#~ msgid "return type for `%s' defaults to id"
#~ msgstr "Garuka Ubwoko kugirango Kuri ID"

#, fuzzy
#~ msgid "method `%s' not implemented by protocol"
#~ msgstr "Uburyo OYA ku Porotokole"

#, fuzzy
#~ msgid "return type defaults to id"
#~ msgstr "Garuka Ubwoko Kuri ID"

#, fuzzy
#~ msgid "cannot find method"
#~ msgstr "Gushaka Uburyo"

#, fuzzy
#~ msgid "instance variable `%s' accessed in class method"
#~ msgstr "Urugero IMPINDURAGACIRO birabonetse in ishuri Uburyo"

#, fuzzy
#~ msgid "duplicate definition of class method `%s'"
#~ msgstr "Gusubiramo Insobanuro Bya ishuri Uburyo"

#, fuzzy
#~ msgid "duplicate declaration of class method `%s'"
#~ msgstr "Gusubiramo Bya ishuri Uburyo"

#, fuzzy
#~ msgid "duplicate definition of instance method `%s'"
#~ msgstr "Gusubiramo Insobanuro Bya Urugero Uburyo"

#, fuzzy
#~ msgid "duplicate declaration of instance method `%s'"
#~ msgstr "Gusubiramo Bya Urugero Uburyo"

#, fuzzy
#~ msgid "duplicate interface declaration for category `%s(%s)'"
#~ msgstr "Gusubiramo kugirango Icyiciro"

#, fuzzy
#~ msgid "instance variable `%s' is declared private"
#~ msgstr "Urugero IMPINDURAGACIRO ni By'umwihariko"

#, fuzzy
#~ msgid "instance variable `%s' is declared %s"
#~ msgstr "Urugero IMPINDURAGACIRO ni"

#, fuzzy
#~ msgid "static access to object of type `id'"
#~ msgstr "Kuri Igikoresho Bya Ubwoko"

#, fuzzy
#~ msgid "incomplete implementation of class `%s'"
#~ msgstr "Bya ishuri"

#, fuzzy
#~ msgid "incomplete implementation of category `%s'"
#~ msgstr "Bya Icyiciro"

#, fuzzy
#~ msgid "method definition for `%c%s' not found"
#~ msgstr "Uburyo Insobanuro kugirango OYA Byabonetse"

#, fuzzy
#~ msgid "%s `%s' does not fully implement the `%s' protocol"
#~ msgstr "%s`%s'OYA i Porotokole"

#, fuzzy
#~ msgid "`@end' missing in implementation context"
#~ msgstr "`@Ibuze in Imvugiro"

#, fuzzy
#~ msgid "reimplementation of class `%s'"
#~ msgstr "Bya ishuri"

#, fuzzy
#~ msgid "conflicting super class name `%s'"
#~ msgstr "hejuru ishuri Izina:"

#, fuzzy
#~ msgid "duplicate interface declaration for class `%s'"
#~ msgstr "Gusubiramo kugirango ishuri"

#, fuzzy
#~ msgid "duplicate declaration for protocol `%s'"
#~ msgstr "Gusubiramo kugirango Porotokole"

#, fuzzy
#~ msgid "[super ...] must appear in a method context"
#~ msgstr "[hejuru Kugaragara in a Uburyo Imvugiro"

#, fuzzy
#~ msgid "potential selector conflict for method `%s'"
#~ msgstr "kugirango Uburyo"

#, fuzzy
#~ msgid "`@end' must appear in an implementation context"
#~ msgstr "`@Kugaragara in Imvugiro"

#, fuzzy
#~ msgid "method definition not in class context"
#~ msgstr "Uburyo Insobanuro OYA in ishuri Imvugiro"

#, fuzzy
#~ msgid "Dump decls to a .decl file"
#~ msgstr "Kuri a IDOSIYE"

#, fuzzy
#~ msgid "Generate code for GNU runtime environment"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Generate code for NeXT runtime environment"
#~ msgstr "ITEGEKONGENGA kugirango"

#, fuzzy
#~ msgid "Warn if a selector has multiple methods"
#~ msgstr "NIBA a Igikubo"

#, fuzzy
#~ msgid "Do not warn if inherited methods are unimplemented"
#~ msgstr "OYA NIBA"

#, fuzzy
#~ msgid "Generate C header of platform specific features"
#~ msgstr "C Umutwempangano Bya Ibiranga"

#, fuzzy
#~ msgid "Specify the name of the class for constant strings"
#~ msgstr "i Izina: Bya i ishuri kugirango Ikurikiranyanyuguti"

#, fuzzy
#~ msgid "(debug) trace parsing process"
#~ msgstr "(Kosora amakosa"

#, fuzzy
#~ msgid "(debug) trace lexical analysis"
#~ msgstr "(Kosora amakosa"

#, fuzzy
#~ msgid "-current_version only allowed with -dynamiclib"
#~ msgstr "-Na:"

#, fuzzy
#~ msgid "-install_name only allowed with -dynamiclib"
#~ msgstr "-Na:"

#, fuzzy
#~ msgid "-bundle not allowed with -dynamiclib"
#~ msgstr "-OYA Na:"

#, fuzzy
#~ msgid "-bundle_loader not allowed with -dynamiclib"
#~ msgstr "-OYA Na:"

#, fuzzy
#~ msgid "-client_name not allowed with -dynamiclib"
#~ msgstr "-OYA Na:"

#, fuzzy
#~ msgid "-force_cpusubtype_ALL not allowed with -dynamiclib"
#~ msgstr "-OYA Na:"

#, fuzzy
#~ msgid "-force_flat_namespace not allowed with -dynamiclib"
#~ msgstr "-OYA Na:"

#, fuzzy
#~ msgid "-keep_private_externs not allowed with -dynamiclib"
#~ msgstr "-OYA Na:"

#, fuzzy
#~ msgid "-private_bundle not allowed with -dynamiclib"
#~ msgstr "-OYA Na:"

#, fuzzy
#~ msgid "GNU C does not support -C without using -E"
#~ msgstr "C OYA Gushigikira C ikoresha E"

#, fuzzy
#~ msgid "GNU C does not support -CC without using -E"
#~ msgstr "C OYA Gushigikira ikoresha E"

#, fuzzy
#~ msgid "`-p' not supported; use `-pg' and gprof(1)"
#~ msgstr "`-OYA Gukoresha Na 1."

#, fuzzy
#~ msgid "may not use both -m32 and -m64"
#~ msgstr "Gicurasi OYA Gukoresha Byombi Na"

#, fuzzy
#~ msgid "The -shared option is not currently supported for VAX ELF."
#~ msgstr "Ihitamo ni OYA kugirango"

#, fuzzy
#~ msgid "profiling not supported with -mg\n"
#~ msgstr "OYA Na:"

#, fuzzy
#~ msgid "-pipe is not supported"
#~ msgstr "-ni OYA"

#, fuzzy
#~ msgid "may not use both -EB and -EL"
#~ msgstr "Gicurasi OYA Gukoresha Byombi Na"

#, fuzzy
#~ msgid "-pg and -fomit-frame-pointer are incompatible"
#~ msgstr "-Na Ikadiri Mweretsi"

#, fuzzy
#~ msgid "mno-cygwin and mno-win32 are not compatible"
#~ msgstr "Na OYA"

#, fuzzy
#~ msgid "shared and mdll are not compatible"
#~ msgstr "Na OYA"

#, fuzzy
#~ msgid "-E required when input is from standard input"
#~ msgstr "-E Bya ngombwa Ryari: Iyinjiza ni Bivuye Bisanzwe Iyinjiza"

#, fuzzy
#~ msgid "compilation of header file requested"
#~ msgstr "Bya Umutwempangano IDOSIYE"

#, fuzzy
#~ msgid " conflicting code gen style switches are used"
#~ msgstr "ITEGEKONGENGA IMISUSIRE"

#, fuzzy
#~ msgid "-pg or -p and -fomit-frame-pointer are incompatible"
#~ msgstr "-Cyangwa P Na Ikadiri Mweretsi"

#, fuzzy
#~ msgid "choose either big or little endian, not both"
#~ msgstr "Guhitamo Cyangwa OYA Byombi"

#, fuzzy
#~ msgid "choose either m340 or m210 not both"
#~ msgstr "Guhitamo Cyangwa OYA Byombi"

#, fuzzy
#~ msgid "the m210 does not have little endian support"
#~ msgstr "i OYA Gushigikira"

#, fuzzy
#~ msgid "-mapcs-26 and -mapcs-32 may not be used together"
#~ msgstr "-Na Gicurasi OYA"

#, fuzzy
#~ msgid "-msoft-float and -mhard_float may not be used together"
#~ msgstr "-Kureremba Na Gicurasi OYA"

#, fuzzy
#~ msgid "-mbig-endian and -mlittle-endian may not be used together"
#~ msgstr "-Na Gicurasi OYA"

#, fuzzy
#~ msgid "-mhard-float not supported"
#~ msgstr "-Kureremba OYA"

#, fuzzy
#~ msgid "-msingle-float and -msoft-float can not both be specified"
#~ msgstr "-Kureremba Na Kureremba OYA Byombi"

#, fuzzy
#~ msgid "-c or -S required for Ada"
#~ msgstr "-C Cyangwa Bya ngombwa kugirango"

#, fuzzy
#~ msgid "-fjni and -femit-class-files are incompatible"
#~ msgstr "-Na ishuri Idosiye"

#, fuzzy
#~ msgid "-fjni and -femit-class-file are incompatible"
#~ msgstr "-Na ishuri IDOSIYE"

#, fuzzy
#~ msgid "-femit-class-file should used along with -fsyntax-only"
#~ msgstr "-ishuri IDOSIYE Na:"

#, fuzzy
#~ msgid "-static not valid with -mcoff"
#~ msgstr "-OYA Byemewe Na:"

#, fuzzy
#~ msgid "-shared not valid with -mcoff"
#~ msgstr "-OYA Byemewe Na:"

#, fuzzy
#~ msgid "-symbolic not valid with -mcoff"
#~ msgstr "-OYA Byemewe Na:"

#, fuzzy
#~ msgid "-fpic is not valid with -mcoff"
#~ msgstr "-ni OYA Byemewe Na:"

#, fuzzy
#~ msgid "-fPIC is not valid with -mcoff"
#~ msgstr "-ni OYA Byemewe Na:"

#, fuzzy
#~ msgid "-fpic not valid with -mcoff"
#~ msgstr "-OYA Byemewe Na:"

#, fuzzy
#~ msgid "-fPIC not valid with -mcoff"
#~ msgstr "-OYA Byemewe Na:"
