# Traditional Chinese translations for R.
# Copyright (C) 2005, 06 The R Foundation
# This file is distributed under the same license as the R package.
# 陈斐 <FeiChen@FairIsaac.com>, 2005.
# Wei-Lun Chao <bluebat@member.fsf.org>, 2005, 06, 11, 18.
#
msgid ""
msgstr ""
"Project-Id-Version: R 3.5.1\n"
"Report-Msgid-Bugs-To: bugs.r-project.org\n"
"POT-Creation-Date: 2022-01-14 11:27+0000\n"
"PO-Revision-Date: 2018-09-16 23:30+0800\n"
"Last-Translator: Wei-Lun Chao <bluebat@member.fsf.org>\n"
"Language-Team: Chinese (traditional) <zh-l10n@linux.org.tw>\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: src/appl/optim.c:60
msgid "non-finite value supplied by 'optim'"
msgstr "optim 回傳了非有限值"

#: src/appl/optim.c:67
#, c-format
msgid "candidate point in 'optim' evaluated to length %d not %d"
msgstr "optim 內的候選點長度被評估為 %d，而不是 %d"

#: src/appl/optim.c:136
msgid "REPORT must be > 0 (method = \"BFGS\")"
msgstr "REPORT 必須 > 0 (method = \"BFGS\")"

#: src/appl/optim.c:147
msgid "initial value in 'vmmin' is not finite"
msgstr "'vmmin' 的初始值不能為無限大"

#: src/appl/optim.c:297
msgid "function cannot be evaluated at initial parameters"
msgstr "不可使用初始參數來評估函式"

#: src/appl/optim.c:497
msgid "unknown 'type' in \"CG\" method of 'optim'"
msgstr "optim 的 \"CG\" 方法中沒有這種類型"

#: src/appl/optim.c:510
msgid "Function cannot be evaluated at initial parameters"
msgstr "不可使用初始參數來評估函式"

#: src/appl/optim.c:565
msgid "unknown type in \"CG\" method of 'optim'"
msgstr "optim 的 \"CG\" 方法中沒有這種類型"

#: src/appl/optim.c:662
msgid "REPORT must be > 0 (method = \"L-BFGS-B\")"
msgstr "REPORT必須 > 0 (method = \"L-BFGS-B\")"

#: src/appl/optim.c:685
msgid "L-BFGS-B needs finite values of 'fn'"
msgstr "L-BFGS-B 不能有 'fn' 的無限值"

#: src/appl/optim.c:741
msgid "trace, REPORT must be >= 0 (method = \"SANN\")"
msgstr "追蹤，REPORT 必須 >= 0 (方法 = \"SANN\")"

#: src/appl/pretty.c:127
#, c-format
msgid "R_pretty(): infinite range; *ndiv=%d, should have ndiv >= 2"
msgstr ""

#: src/appl/pretty.c:142
#, fuzzy, c-format
msgid "R_pretty(): very small range 'cell'=%g, corrected to %g"
msgstr "內部(pretty()): 範圍太小.. 已修正"

#: src/appl/pretty.c:146
#, fuzzy, c-format
msgid "R_pretty(): very large range 'cell'=%g, corrected to %g"
msgstr "內部(pretty()): 範圍太大.. 已修正"

#: src/gnuwin32/dynload.c:144
#, c-format
msgid "DLL attempted to change FPU control word from %x to %x"
msgstr "DLL 試圖把 FPU 控制詞從 %x 改成 %x"

#: src/gnuwin32/dynload.c:185
msgid "cannot get working directory"
msgstr "找不到工作目錄"

#: src/gnuwin32/extra.c:63 src/gnuwin32/extra.c:92 src/gnuwin32/extra.c:131
msgid "R_HOME not set"
msgstr "沒有設定 R_HOME"

#: src/gnuwin32/extra.c:71
#, c-format
msgid "'%s' not found"
msgstr "'%s' 找不到"

#: src/gnuwin32/extra.c:73
#, c-format
msgid "file association for '%s' not available or invalid"
msgstr "'%s' 的檔案關聯無法使用或無效"

#: src/gnuwin32/extra.c:76
#, c-format
msgid "access to '%s' denied"
msgstr "存取'%s' 被拒絕"

#: src/gnuwin32/extra.c:77
#, c-format
msgid "problem in displaying '%s'"
msgstr "顯示'%s' 時發生問題"

#: src/gnuwin32/extra.c:102
#, c-format
msgid "'%ls' not found"
msgstr "'%ls' 找不到"

#: src/gnuwin32/extra.c:104
#, c-format
msgid "file association for '%ls' not available or invalid"
msgstr "'%ls' 的檔案關聯無法使用或無效"

#: src/gnuwin32/extra.c:107
#, c-format
msgid "access to '%ls' denied"
msgstr "存取 '%ls' 被拒絕"

#: src/gnuwin32/extra.c:108
#, c-format
msgid "problem in displaying '%ls'"
msgstr "顯示 '%ls' 時發生問題"

#: src/gnuwin32/extra.c:119 src/gnuwin32/extra.c:161 src/gnuwin32/extra.c:297
#: src/gnuwin32/extra.c:871 src/gnuwin32/extra.c:896
#: src/gnuwin32/sys-win32.c:249 src/main/Rdynload.c:1298 src/main/agrep.c:131
#: src/main/agrep.c:135 src/main/agrep.c:776 src/main/agrep.c:781
#: src/main/apply.c:345 src/main/apply.c:347 src/main/apply.c:350
#: src/main/array.c:94 src/main/array.c:1750 src/main/array.c:1889
#: src/main/array.c:1891 src/main/array.c:1892 src/main/array.c:2273
#: src/main/array.c:2275 src/main/array.c:2277 src/main/attrib.c:202
#: src/main/builtin.c:88 src/main/builtin.c:97 src/main/builtin.c:116
#: src/main/builtin.c:118 src/main/builtin.c:154 src/main/builtin.c:160
#: src/main/builtin.c:582 src/main/builtin.c:598 src/main/builtin.c:786
#: src/main/builtin.c:788 src/main/builtin.c:790 src/main/character.c:321
#: src/main/character.c:324 src/main/character.c:329 src/main/character.c:930
#: src/main/character.c:933 src/main/character.c:1455 src/main/character.c:1459
#: src/main/character.c:1709 src/main/character.c:1713
#: src/main/character.c:1780 src/main/character.c:1783
#: src/main/connections.c:1437 src/main/connections.c:1443
#: src/main/connections.c:1446 src/main/connections.c:1450
#: src/main/connections.c:1602 src/main/connections.c:1618
#: src/main/connections.c:1623 src/main/connections.c:2259
#: src/main/connections.c:2265 src/main/connections.c:2269
#: src/main/connections.c:2273 src/main/connections.c:2278
#: src/main/connections.c:2962 src/main/connections.c:2967
#: src/main/connections.c:2970 src/main/connections.c:2973
#: src/main/connections.c:3379 src/main/connections.c:3384
#: src/main/connections.c:3390 src/main/connections.c:3393
#: src/main/connections.c:3397 src/main/connections.c:3412
#: src/main/connections.c:3462 src/main/connections.c:3467
#: src/main/connections.c:3471 src/main/connections.c:3483
#: src/main/connections.c:3487 src/main/connections.c:3493
#: src/main/connections.c:3553 src/main/connections.c:3559
#: src/main/connections.c:3563 src/main/connections.c:3615
#: src/main/connections.c:3618 src/main/connections.c:3944
#: src/main/connections.c:3947 src/main/connections.c:3950
#: src/main/connections.c:3956 src/main/connections.c:4069
#: src/main/connections.c:4075 src/main/connections.c:4078
#: src/main/connections.c:4233 src/main/connections.c:4236
#: src/main/connections.c:4240 src/main/connections.c:4243
#: src/main/connections.c:4359 src/main/connections.c:4483
#: src/main/connections.c:4486 src/main/connections.c:4825
#: src/main/connections.c:4856 src/main/connections.c:4891
#: src/main/connections.c:4906 src/main/connections.c:4914
#: src/main/connections.c:4940 src/main/connections.c:5093
#: src/main/connections.c:5097 src/main/connections.c:5227
#: src/main/connections.c:5229 src/main/connections.c:5231
#: src/main/connections.c:5259 src/main/connections.c:5400
#: src/main/connections.c:5449 src/main/connections.c:5454
#: src/main/connections.c:5459 src/main/connections.c:5483
#: src/main/connections.c:6251 src/main/connections.c:6278
#: src/main/connections.c:6285 src/main/context.c:645 src/main/context.c:654
#: src/main/context.c:658 src/main/datetime.c:780 src/main/datetime.c:869
#: src/main/datetime.c:872 src/main/datetime.c:876 src/main/datetime.c:1057
#: src/main/datetime.c:1059 src/main/datetime.c:1264 src/main/debug.c:246
#: src/main/deparse.c:449 src/main/dotcode.c:496 src/main/dotcode.c:500
#: src/main/dotcode.c:505 src/main/dounzip.c:334 src/main/dounzip.c:341
#: src/main/dounzip.c:351 src/main/dounzip.c:356 src/main/dounzip.c:360
#: src/main/dounzip.c:364 src/main/envir.c:1878 src/main/envir.c:1881
#: src/main/envir.c:1995 src/main/envir.c:2000 src/main/envir.c:2091
#: src/main/envir.c:2107 src/main/envir.c:2113 src/main/envir.c:2224
#: src/main/envir.c:2232 src/main/envir.c:2239 src/main/envir.c:2250
#: src/main/envir.c:2490 src/main/envir.c:2611 src/main/envir.c:2908
#: src/main/envir.c:3172 src/main/envir.c:3186 src/main/envir.c:3193
#: src/main/envir.c:3209 src/main/envir.c:3979 src/main/errors.c:1284
#: src/main/eval.c:501 src/main/eval.c:511 src/main/eval.c:514
#: src/main/grep.c:1189 src/main/grep.c:1194 src/main/grep.c:1483
#: src/main/grep.c:1485 src/main/grep.c:1487 src/main/grep.c:1964
#: src/main/grep.c:1968 src/main/grep.c:1973 src/main/grep.c:2839
#: src/main/grep.c:2844 src/main/grep.c:3159 src/main/grep.c:3164
#: src/main/memory.c:4599 src/main/paste.c:124 src/main/paste.c:467
#: src/main/paste.c:481 src/main/paste.c:486 src/main/paste.c:491
#: src/main/paste.c:496 src/main/paste.c:499 src/main/paste.c:507
#: src/main/paste.c:512 src/main/paste.c:694 src/main/paste.c:699
#: src/main/platform.c:478 src/main/platform.c:480 src/main/platform.c:482
#: src/main/platform.c:494 src/main/platform.c:505 src/main/platform.c:564
#: src/main/platform.c:566 src/main/platform.c:874 src/main/platform.c:876
#: src/main/platform.c:971 src/main/platform.c:1349 src/main/platform.c:1355
#: src/main/platform.c:1358 src/main/platform.c:1361 src/main/platform.c:1364
#: src/main/platform.c:1367 src/main/platform.c:1370 src/main/platform.c:1373
#: src/main/platform.c:1473 src/main/platform.c:1476 src/main/platform.c:1479
#: src/main/platform.c:1521 src/main/platform.c:1581 src/main/platform.c:1584
#: src/main/platform.c:1809 src/main/platform.c:1812 src/main/platform.c:1815
#: src/main/platform.c:1818 src/main/platform.c:1863 src/main/platform.c:1866
#: src/main/platform.c:1869 src/main/platform.c:1872 src/main/platform.c:1917
#: src/main/platform.c:1950 src/main/platform.c:1952 src/main/platform.c:2031
#: src/main/platform.c:2116 src/main/platform.c:2381 src/main/platform.c:2441
#: src/main/platform.c:2650 src/main/platform.c:2653 src/main/platform.c:2656
#: src/main/platform.c:2659 src/main/platform.c:2662 src/main/platform.c:2665
#: src/main/platform.c:2912 src/main/platform.c:2915 src/main/platform.c:2918
#: src/main/platform.c:2921 src/main/platform.c:2924 src/main/platform.c:2927
#: src/main/platform.c:2930 src/main/platform.c:3017 src/main/platform.c:3025
#: src/main/platform.c:3061 src/main/platform.c:3105 src/main/platform.c:3196
#: src/main/print.c:250 src/main/print.c:279 src/main/print.c:287
#: src/main/print.c:301 src/main/random.c:470 src/main/random.c:474
#: src/main/random.c:481 src/main/random.c:509 src/main/saveload.c:2012
#: src/main/saveload.c:2054 src/main/saveload.c:2057 src/main/saveload.c:2060
#: src/main/saveload.c:2176 src/main/saveload.c:2356 src/main/saveload.c:2361
#: src/main/saveload.c:2364 src/main/saveload.c:2473 src/main/scan.c:694
#: src/main/scan.c:867 src/main/scan.c:881 src/main/scan.c:885
#: src/main/scan.c:887 src/main/scan.c:898 src/main/scan.c:925
#: src/main/scan.c:928 src/main/scan.c:931 src/main/scan.c:986
#: src/main/seq.c:671 src/main/seq.c:678 src/main/seq.c:688 src/main/seq.c:694
#: src/main/seq.c:739 src/main/seq.c:744 src/main/seq.c:747 src/main/seq.c:751
#: src/main/seq.c:756 src/main/seq.c:763 src/main/seq.c:767 src/main/seq.c:773
#: src/main/sort.c:276 src/main/sysutils.c:609 src/main/sysutils.c:613
#: src/main/sysutils.c:617 src/main/sysutils.c:623 src/main/sysutils.c:627
#: src/main/sysutils.c:2091 src/main/sysutils.c:2095 src/main/unique.c:1541
#: src/main/unique.c:1847 src/main/unique.c:1851 src/main/unique.c:1861
#: src/main/unique.c:2253 src/main/util.c:662 src/main/util.c:665
#: src/main/util.c:1612 src/main/util.c:1626 src/main/util.c:2370
#: src/main/util.c:2610 src/main/util.c:2611 src/main/util.c:2612
#: src/main/util.c:2628 src/main/util.c:2670 src/main/util.c:2674
#: src/main/util.c:2676 src/main/util.c:2704 src/main/util.c:2706
#: src/main/util.c:2708 src/main/util.c:2711 src/main/util.c:2714
#: src/main/util.c:2718 src/main/util.c:2720 src/main/util.c:2722
#: src/modules/X11/devX11.c:3348 src/modules/X11/devX11.c:3351
#: src/modules/X11/devX11.c:3354 src/modules/X11/devX11.c:3378
#: src/modules/internet/internet.c:324 src/modules/internet/internet.c:330
#: src/modules/internet/internet.c:336 src/modules/internet/internet.c:339
#: src/modules/internet/internet.c:343 src/modules/internet/internet.c:347
#: src/modules/internet/internet.c:351 src/modules/internet/libcurl.c:534
#: src/modules/internet/libcurl.c:538 src/modules/internet/libcurl.c:543
#: src/modules/internet/libcurl.c:546 src/modules/internet/libcurl.c:550
#: src/modules/internet/libcurl.c:553 src/modules/lapack/Lapack.c:170
#: src/modules/lapack/Lapack.c:275 src/modules/lapack/Lapack.c:724
#: src/modules/lapack/Lapack.c:833 src/modules/lapack/Lapack.c:895
#: src/modules/lapack/Lapack.c:1234 src/unix/sys-std.c:1366
#: src/unix/sys-std.c:1389 src/unix/sys-unix.c:691
#, c-format
msgid "invalid '%s' argument"
msgstr "'%s' 引數無效"

#: src/gnuwin32/extra.c:186
msgid "unsupported version of Windows"
msgstr "不支援的 Windows 版本"

#: src/gnuwin32/extra.c:681 src/gnuwin32/extra.c:825 src/main/util.c:988
msgid "'path' must be a character vector"
msgstr "'path' 必須是字元向量"

#: src/gnuwin32/extra.c:873 src/gnuwin32/extra.c:875 src/gnuwin32/extra.c:898
#: src/gnuwin32/extra.c:900 src/gnuwin32/extra.c:935 src/main/gevents.c:63
#: src/main/gevents.c:105
msgid "invalid device"
msgstr "無效裝置"

#: src/gnuwin32/extra.c:876
msgid "requires SDI mode"
msgstr "需要用 SDI 模式"

#: src/gnuwin32/extra.c:929 src/main/gevents.c:60 src/main/gevents.c:99
#: src/main/gevents.c:102
msgid "invalid graphical device number"
msgstr "無效的繪圖裝置號碼"

#: src/gnuwin32/extra.c:939
msgid "bad device"
msgstr "不當裝置"

#: src/gnuwin32/extra.c:1066 src/main/platform.c:1556
msgid "file choice cancelled"
msgstr "已取消檔案選擇"

#: src/gnuwin32/run.c:374
#, c-format
msgid "'CreateProcess' failed to run '%s'"
msgstr "CreateProcess 無法運行 '%s'"

#: src/gnuwin32/run.c:531
msgid "Child process not responding.  R will terminate it."
msgstr "子進程沒有反應。 R 將會終止它。"

#: src/gnuwin32/run.c:623
#, c-format
msgid "Exit code was %d"
msgstr "離開代碼是 %d"

#: src/gnuwin32/run.c:656
msgid "Insufficient memory (rpipeOpen)"
msgstr "沒有足夠的記憶體 (rpipeOpen)"

#: src/gnuwin32/run.c:899 src/main/dounzip.c:491
msgid "seek not enabled for this connection"
msgstr "這個連接上不能使用搜索"

#: src/gnuwin32/run.c:905
msgid "truncate not enabled for this connection"
msgstr "這個連接不能使用截短"

#: src/gnuwin32/run.c:965 src/main/connections.c:440 src/main/connections.c:459
#: src/main/connections.c:3229 src/main/printutils.c:938
#: src/main/printutils.c:955
msgid "printing of extremely long output is truncated"
msgstr "截短了需要列印的特長輸出"

#: src/gnuwin32/run.c:979 src/gnuwin32/run.c:983 src/gnuwin32/run.c:996
#: src/gnuwin32/run.c:1024 src/main/connections.c:1553
#: src/main/connections.c:1557 src/main/connections.c:1564
#: src/main/connections.c:1579
msgid "allocation of pipe connection failed"
msgstr "管道連接配置失敗"

#: src/gnuwin32/run.c:1038
msgid "'names' is not a character vector"
msgstr "'names' 並非字元向量"

#: src/gnuwin32/sys-win32.c:230
msgid "character string expected as first argument"
msgstr "第一個引數應當是字串"

#: src/gnuwin32/sys-win32.c:239
msgid "character string expected as third argument"
msgstr "第三個引數應當是字串"

#: src/gnuwin32/sys-win32.c:291 src/modules/internet/libcurl.c:330
#: src/modules/internet/libcurl.c:333 src/modules/internet/libcurl.c:336
#: src/modules/internet/libcurl.c:341 src/modules/internet/libcurl.c:367
#, c-format
msgid "invalid %s argument"
msgstr "%s 引數無效"

#: src/gnuwin32/sys-win32.c:317 src/unix/sys-unix.c:800 src/unix/sys-unix.c:835
#, c-format
msgid "command '%s' timed out after %ds"
msgstr "命令 '%s' 於 %d 秒之後逾時"

#: src/gnuwin32/sys-win32.c:320 src/unix/sys-unix.c:673
#, c-format
msgid "running command '%s' had status %d"
msgstr "執行中命令 '%s' 已有狀態 %d"

#: src/gnuwin32/system.c:125 src/main/sysutils.c:2050
msgid "reached session elapsed time limit"
msgstr "達到了作業階段經過時間的限制"

#: src/gnuwin32/system.c:127 src/main/sysutils.c:2052
msgid "reached elapsed time limit"
msgstr "達到了經過時間的限制"

#: src/gnuwin32/system.c:133 src/main/sysutils.c:2058
msgid "reached session CPU time limit"
msgstr "達到了作業階段 CPU 時間的限制"

#: src/gnuwin32/system.c:135 src/main/sysutils.c:2060
msgid "reached CPU time limit"
msgstr "達到了 CPU 時間的限制"

#: src/gnuwin32/system.c:161
#, c-format
msgid "Fatal error: %s\n"
msgstr "嚴重錯誤：%s\n"

#: src/gnuwin32/system.c:339 src/unix/sys-std.c:982
#, c-format
msgid "encoding '%s' is not recognised"
msgstr "編碼 '%s' 無法確認"

#: src/gnuwin32/system.c:345 src/unix/sys-std.c:989
#, c-format
msgid "<ERROR: re-encoding failure from encoding '%s'>\n"
msgstr "<錯誤：從編碼 '%s' 重新編碼時失敗>\n"

#: src/gnuwin32/system.c:567 src/gnuwin32/system.c:1066
#: src/gnuwin32/system.c:1078 src/main/connections.c:786
#: src/main/connections.c:791 src/main/dounzip.c:180 src/main/saveload.c:2065
#: src/main/serialize.c:2941 src/main/serialize.c:2946
#: src/main/serialize.c:3040 src/main/serialize.c:3087 src/unix/system.c:423
#, c-format
msgid "cannot open file '%s': %s"
msgstr "無法開啟檔案 '%s' ：%s"

#: src/gnuwin32/system.c:582
#, c-format
msgid "file.show(): file '%s' does not exist\n"
msgstr "file.show(): 檔案 '%s' 不存在\n"

#: src/gnuwin32/system.c:883
#, fuzzy, c-format
msgid "Workspace name '%s' is too long\n"
msgstr "DLLname '%s' 太長"

#: src/gnuwin32/system.c:899 src/unix/system.c:459
#, c-format
msgid "ARGUMENT '%s' __ignored__\n"
msgstr "引數 '%s' 忽略不用\n"

#: src/gnuwin32/system.c:1056
#, c-format
msgid "option '%s' requires an argument"
msgstr "選項 '%s' 需要一個引數"

#: src/gnuwin32/system.c:1089
#, c-format
msgid "option '%s' requires a non-empty argument"
msgstr "選項 '%s' 需要一個非空引數"

#: src/gnuwin32/system.c:1097 src/unix/system.c:442
#, c-format
msgid "WARNING: '-e %s' omitted as input is too long\n"
msgstr "警告：'-e %s' 因為輸入太長而被省略\n"

#: src/gnuwin32/system.c:1101 src/unix/system.c:455
#, c-format
msgid "WARNING: unknown option '%s'\n"
msgstr "警告: 沒有 '%s' 這樣的選項\n"

#: src/gnuwin32/system.c:1113 src/unix/system.c:470
msgid "cannot use -e with -f or --file"
msgstr "無法將 -e 與 -f 或 --file 共同使用"

#: src/gnuwin32/system.c:1131
msgid "creation of tmpfile failed -- set TMPDIR suitably?"
msgstr "建立暫存檔時失敗 -- 已適當設定了 TMPDIR？"

#: src/gnuwin32/system.c:1151 src/unix/system.c:540
msgid "you must specify '--save', '--no-save' or '--vanilla'"
msgstr "您必須指定 '--save'、'--no-save' 或 '--vanilla' 其中的一個"

#: src/gnuwin32/system.c:1156
msgid ""
"impossible to create 'reader thread'; you must free some system resources"
msgstr "無法建立 'reader thread'；您必須釋放一些系統資源"

#: src/include/Errormsg.h:27
msgid "subscript out of bounds"
msgstr "下標超出邊界"

#: src/include/Errormsg.h:28
#, c-format
msgid "object of type '%s' is not subsettable"
msgstr "'%s' 類型的物件無法具有子集合"

#: src/main/CommandLineArgs.c:176
msgid "WARNING: no value given for --encoding"
msgstr "警告：沒有設定 --enconding 的值"

#: src/main/CommandLineArgs.c:201
#, c-format
msgid "WARNING: option '%s' no longer supported"
msgstr "警告：不再支援選項 '%s'"

#: src/main/CommandLineArgs.c:212
#, c-format
msgid "WARNING: no value given for '%s'"
msgstr "警告：沒有設定 '%s' 的值"

#: src/main/CommandLineArgs.c:222
#, c-format
msgid "WARNING: '%s' value is invalid: ignored"
msgstr "警告：'%s' 值無效：已忽略"

#: src/main/CommandLineArgs.c:226
#, c-format
msgid "WARNING: %s: too large and ignored"
msgstr "警告：%s：過大因而忽略"

#: src/main/CommandLineArgs.c:240
msgid "WARNING: no value given for '--max-ppsize'"
msgstr "警告：沒有設定 '--max-ppsize' 的值"

#: src/main/CommandLineArgs.c:245
msgid "WARNING: '--max-ppsize' value is negative: ignored"
msgstr "警告：'--max-ppsize' 值是負數：已忽略"

#: src/main/CommandLineArgs.c:247
msgid "WARNING: '--max-ppsize' value is too small: ignored"
msgstr "警告：'--max-ppsize' 的值太小：已忽略"

#: src/main/CommandLineArgs.c:249
msgid "WARNING: '--max-ppsize' value is too large: ignored"
msgstr "警告：'--max-ppsize' 的值太大：已忽略"

#: src/main/RNG.c:180
#, c-format
msgid "unif_rand: unimplemented RNG kind %d"
msgstr "unif_rand: RNG 類型 %d 尚未實作"

#: src/main/RNG.c:265
#, c-format
msgid "FixupSeeds: unimplemented RNG kind %d"
msgstr "FixupSeeds: RNG 類型 %d 尚未實作"

#: src/main/RNG.c:305
msgid "'user_unif_rand' not in load table"
msgstr "'user_unif_rand' 在載入表中並不存在"

#: src/main/RNG.c:313
msgid "cannot read seeds unless 'user_unif_nseed' is supplied"
msgstr "只有在設定了 'user_unif_nseed' 以後才能讀隨機種子"

#: src/main/RNG.c:318
msgid "seed length must be in 0...625; ignored"
msgstr "隨機種子的長度必須在 0 到 625 之間; 忽略不用"

#: src/main/RNG.c:326
#, c-format
msgid "RNG_Init: unimplemented RNG kind %d"
msgstr "RNG_Init: RNG 類型 %d 尚未實作"

#: src/main/RNG.c:355
msgid "'.Random.seed' is a missing argument with no default"
msgstr ".Random.seed 這個引數沒有設定也沒有預設值"

#: src/main/RNG.c:356
#, c-format
msgid "'.Random.seed' is not an integer vector but of type '%s', so ignored"
msgstr ".Random.seed 不是整數向量而是類型 '%s'，忽略不用"

#: src/main/RNG.c:364
msgid "'.Random.seed[1]' is not a valid integer, so ignored"
msgstr ".Random.seed[1] 不是有效的整數，忽略不用"

#: src/main/RNG.c:371
msgid "'.Random.seed[1]' is not a valid Normal type, so ignored"
msgstr ".Random.seed[0] 不是有效的 Normal 類別，忽略不用"

#: src/main/RNG.c:385
msgid "'.Random.seed[1] = 5' but no user-supplied generator, so ignored"
msgstr ".Random.seed[1] = 5 但沒有使用者提供的產生器，忽略不用"

#: src/main/RNG.c:390
msgid "'.Random.seed[1]' is not a valid RNG kind so ignored"
msgstr ".Random.seed[1] 不是有效的 RNGkind，忽略不用"

#: src/main/RNG.c:419
msgid "'.Random.seed' has wrong length"
msgstr ".Random.seed 的長度不正確"

#: src/main/RNG.c:463
msgid "RNGkind: Marsaglia-Multicarry has poor statistical properties"
msgstr ""

#: src/main/RNG.c:473
#, c-format
msgid "RNGkind: unimplemented RNG kind %d"
msgstr "RNGkind: RNG 類型 %d 尚未實作"

#: src/main/RNG.c:492
msgid ""
"RNGkind: severe deviations from normality for Kinderman-Ramage + Marsaglia-"
"Multicarry"
msgstr ""

#: src/main/RNG.c:495
msgid ""
"RNGkind: deviations from normality for Ahrens-Dieter + Marsaglia-Multicarry"
msgstr ""

#: src/main/RNG.c:499
msgid "invalid Normal type in 'RNGkind'"
msgstr "RNGkind 中的 Normal 類別無效"

#: src/main/RNG.c:502
msgid "'user_norm_rand' not in load table"
msgstr "'user_norm_rand' 不在載入表中"

#: src/main/RNG.c:517
#, fuzzy
msgid "invalid sample type in 'RNGkind'"
msgstr "RNGkind 中的 Normal 類別無效"

#: src/main/RNG.c:563
msgid "supplied seed is not a valid integer"
msgstr "提供的隨機種子不是有效的整數"

#: src/main/Rdynload.c:188
#, c-format
msgid "R_MAX_NUM_DLLS must be at least %d"
msgstr "R_MAX_NUM_DLLS 必須至少是 %d"

#: src/main/Rdynload.c:194
#, c-format
msgid "R_MAX_NUM_DLLS cannot be bigger than %d"
msgstr "R_MAX_NUM_DLLS 不可大於 %d"

#: src/main/Rdynload.c:203
#, c-format
msgid "R_MAX_NUM_DLLS cannot be bigger than %d when fd limit is not known"
msgstr "R_MAX_NUM_DLLS 當 fd 限制未知時不可大於 %d"

#: src/main/Rdynload.c:209 src/main/Rdynload.c:228
msgid "the limit on the number of open files is too low"
msgstr "開啟檔案數目的限制太低"

#: src/main/Rdynload.c:212
#, c-format
msgid "R_MAX_NUM_DLLS bigger than %d may exhaust open files limit"
msgstr "R_MAX_NUM_DLLS 如果大於 %d 可能會耗盡開啟檔案的限制"

#: src/main/Rdynload.c:235
msgid "could not allocate space for DLL table"
msgstr "無法為 DLL 表格配置空間"

#: src/main/Rdynload.c:360
msgid "R_RegisterRoutines called with invalid DllInfo object."
msgstr "R_RegisterRoutines 呼叫時 DllInfo 物件無效。"

#: src/main/Rdynload.c:706
msgid "`maximal number of DLLs reached..."
msgstr "已達到了 DLL 數目的上限…"

#: src/main/Rdynload.c:756
msgid "could not allocate space for 'path'"
msgstr "無法為 'path' 配置空間"

#: src/main/Rdynload.c:768
#, c-format
msgid "DLLname '%s' is too long"
msgstr "DLLname '%s' 太長"

#: src/main/Rdynload.c:797
msgid "could not allocate space for 'name'"
msgstr "無法為 'name' 配置空間"

#: src/main/Rdynload.c:807
#, fuzzy
msgid "could not allocate space for 'DllInfo'"
msgstr "無法為 'name' 配置空間"

#: src/main/Rdynload.c:1075 src/main/Rdynload.c:1091 src/main/util.c:788
msgid "character argument expected"
msgstr "需要字元引數"

#: src/main/Rdynload.c:1081 src/main/Rdynload.c:1113 src/main/Rdynload.c:1133
#, c-format
msgid ""
"unable to load shared object '%s':\n"
"  %s"
msgstr ""
"無法載入共享物件 '%s' ：\n"
" %s"

#: src/main/Rdynload.c:1094
#, c-format
msgid "shared object '%s' was not loaded"
msgstr "沒有載入共享物件 '%s'"

#: src/main/Rdynload.c:1173
#, c-format
msgid "cannot allocate memory for registered native symbol (%d byte)"
msgid_plural "cannot allocate memory for registered native symbol (%d bytes)"
msgstr[0] "無法給已登記的原生符號 (%d 位元組) 配置記憶體"

#: src/main/Rdynload.c:1308 src/main/Rdynload.c:1507
msgid "NULL value passed for DllInfo"
msgstr "傳給 DllInfo 一個 NULL 值"

#: src/main/Rdynload.c:1312
msgid "must pass package name or DllInfo reference"
msgstr "必須傳給套件名稱或 DllInfo 參照"

#: src/main/Rdynload.c:1422
#, c-format
msgid "unimplemented type %d in 'createRSymbolObject'"
msgstr "createRSymbolObject 中的類型 %d 尚未實作"

#: src/main/Rdynload.c:1504
msgid "R_getRegisteredRoutines() expects a DllInfo reference"
msgstr "R_getRegisteredRoutines() 需要 DllInfo 參考"

#: src/main/Rdynload.c:1593
#, c-format
msgid "function '%s' not provided by package '%s'"
msgstr "函式 '%s' 未由套件 '%s' 所提供"

#: src/main/Rdynload.c:1595
msgid "table entry must be an external pointer"
msgstr "表格條目必須是一個外部指標"

#: src/main/Renviron.c:250
#, c-format
msgid "problem in setting variable '%s' in Renviron"
msgstr "設定 Renviron 中的變數 '%s' 時發生問題"

#: src/main/Renviron.c:446 src/main/objects.c:1307 src/main/raw.c:207
#, c-format
msgid "argument '%s' must be a character string"
msgstr "引數 '%s' 必須是字串"

#: src/main/Renviron.c:450
#, c-format
msgid "file '%s' cannot be opened for reading"
msgstr "檔案 '%s' 無法開啟以讀取"

#: src/main/Rstrptime.h:526 src/main/Rstrptime.h:1008
#, c-format
msgid "use of %s for input is not supported"
msgstr "使用 %s 做為輸入未被支援"

#: src/main/Rstrptime.h:1293
msgid "input string is too long"
msgstr "輸入字串太長"

#: src/main/Rstrptime.h:1295
msgid "invalid multibyte input string"
msgstr "無效的多位元組輸入字串"

#: src/main/Rstrptime.h:1298
msgid "format string is too long"
msgstr "格式字串太長"

#: src/main/Rstrptime.h:1300
msgid "invalid multibyte format string"
msgstr "無效的多位元組格式字串"

#: src/main/agrep.c:133 src/main/agrep.c:778 src/main/character.c:1457
#: src/main/character.c:1461 src/main/grep.c:1191 src/main/grep.c:1966
#: src/main/grep.c:1970 src/main/grep.c:2841 src/main/grep.c:3161
#, c-format
msgid "argument '%s' has length > 1 and only the first element will be used"
msgstr "引數 '%s' 長度 > 1 且只有第一個元素將被使用"

#: src/main/agrep.c:190 src/main/agrep.c:820
msgid "'pattern' must be a non-empty character string"
msgstr "'pattern' 必須是非空字串"

#: src/main/agrep.c:201 src/main/agrep.c:829 src/main/grep.c:1241
#: src/main/grep.c:2877 src/main/grep.c:3190
msgid "regular expression is invalid in this locale"
msgstr "正規表示式不適用於此語區環境"

#: src/main/agrep.c:207 src/main/agrep.c:624
#, c-format
msgid "regcomp error:  '%s'"
msgstr "正規表示式編譯錯誤：'%s'"

#: src/main/agrep.c:239 src/main/agrep.c:875 src/main/grep.c:562
#: src/main/grep.c:659 src/main/grep.c:769 src/main/grep.c:957
#: src/main/grep.c:1285 src/main/grep.c:2071 src/main/grep.c:2987
#: src/main/grep.c:3067 src/main/grep.c:3227
#, c-format
msgid "input string %d is invalid in this locale"
msgstr "輸入的字串 %d 不適用於此語區環境"

#: src/main/agrep.c:526 src/main/agrep.c:766 src/main/connections.c:2382
#: src/main/grep.c:503 src/main/grep.c:1182 src/main/grep.c:1184
#: src/main/grep.c:1469 src/main/grep.c:1477 src/main/grep.c:1957
#: src/main/grep.c:1959 src/main/grep.c:2831 src/main/grep.c:2833
#: src/main/grep.c:3149
#, c-format
msgid "argument '%s' will be ignored"
msgstr "引數 '%s' 將被忽略"

#: src/main/agrep.c:615
#, c-format
msgid "input string x[%d] is invalid in this locale"
msgstr "輸入字串 x[%d] 在這個語區中無效"

#: src/main/agrep.c:662
#, c-format
msgid "input string y[%d] is invalid in this locale"
msgstr "輸入字串 y[%d] 在這個語區無效"

#: src/main/agrep.c:835 src/main/grep.c:3196
#, c-format
msgid "regcomp error: '%s'"
msgstr "正規表示式編譯錯誤：'%s'"

#: src/main/apply.c:111
msgid "'FUN.VALUE' must be a vector"
msgstr "FUN.VALUE 必須是向量"

#: src/main/apply.c:114 src/main/array.c:528 src/main/character.c:989
#: src/main/character.c:1843 src/main/connections.c:3952 src/main/context.c:696
#: src/main/context.c:710 src/main/datetime.c:680 src/main/datetime.c:782
#: src/main/datetime.c:1061 src/main/dotcode.c:222 src/main/errors.c:1179
#: src/main/errors.c:1200 src/main/errors.c:1318 src/main/errors.c:1325
#: src/main/errors.c:1629 src/main/identical.c:45 src/main/platform.c:3500
#: src/main/seq.c:252 src/main/seq.c:259 src/main/seq.c:263 src/main/seq.c:368
#: src/main/seq.c:375 src/main/seq.c:378 src/main/seq.c:380 src/main/seq.c:437
#: src/main/seq.c:441 src/main/seq.c:445 src/main/sort.c:1428
#: src/main/sort.c:1512 src/main/sort.c:1516 src/main/sort.c:1523
#: src/main/source.c:221 src/main/summary.c:1200 src/main/sysutils.c:264
#: src/main/util.c:1115 src/main/util.c:1120 src/main/util.c:1127
#: src/main/util.c:1130 src/main/util.c:2430 src/modules/X11/devX11.c:3241
#: src/modules/X11/devX11.c:3268 src/modules/X11/devX11.c:3273
#: src/modules/X11/devX11.c:3278 src/modules/X11/devX11.c:3288
#: src/modules/X11/devX11.c:3293 src/modules/X11/devX11.c:3297
#: src/modules/X11/devX11.c:3301 src/modules/X11/devX11.c:3306
#, c-format
msgid "invalid '%s' value"
msgstr "'%s' 值無效"

#: src/main/apply.c:117 src/main/complex.c:760
msgid "invalid length"
msgstr "長度無效"

#: src/main/apply.c:122
msgid "long vectors are not supported for matrix/array results"
msgstr "矩陣/陣列的結果不支援長整數向量"

#: src/main/apply.c:129
#, c-format
msgid "type '%s' is not supported"
msgstr "類型 '%s' 未被支援"

#: src/main/apply.c:177
#, c-format
msgid ""
"values must be length %d,\n"
" but FUN(X[[%d]]) result is length %d"
msgstr ""
"值的長度必須是 %d，\n"
"但是 FUN(X[[%d]]) 的結果長度是 %d"

#: src/main/apply.c:189
#, c-format
msgid ""
"values must be type '%s',\n"
" but FUN(X[[%d]]) result is type '%s'"
msgstr ""
"值的類型必須是 '%s'，\n"
"但是 FUN(X[[%d]]) 的結果類型是 '%s'"

#: src/main/apply.c:266
#, c-format
msgid "dimnames(<value>) is neither NULL nor list of length %d"
msgstr "dimnames(<值>) 既不是空值也不是長度 %d 的串列"

#: src/main/apply.c:343 src/main/coerce.c:2721
#, fuzzy, c-format
msgid "'%s' must be a list or expression"
msgstr "'args' 必須是串列或運算式"

#: src/main/arithmetic.c:44 src/main/eval.c:4477
msgid "NaNs produced"
msgstr "產生了 NaNs"

#: src/main/arithmetic.c:45
msgid "non-numeric argument to mathematical function"
msgstr "數學函式中使用了非數值引數"

#: src/main/arithmetic.c:210
msgid "probable complete loss of accuracy in modulus"
msgstr "係數的精確度很可能完全損失"

#: src/main/arithmetic.c:328
msgid "NAs produced by integer overflow"
msgstr "整數向上溢位產生了 NA"

#: src/main/arithmetic.c:527
msgid "operator needs one or two arguments"
msgstr "運算子需要一或兩個引數"

#: src/main/arithmetic.c:543
msgid "non-numeric argument to binary operator"
msgstr "二元運算子中有非數值引數"

#: src/main/arithmetic.c:598
msgid ""
"Recycling array of length 1 in array-vector arithmetic is deprecated.\n"
"  Use c() or as.vector() instead.\n"
msgstr ""
"於陣列-向量算法中回收長度為 1 的陣列已過時。\n"
" 請使用 c() 或 as.vector() 做為替代。\n"

#: src/main/arithmetic.c:606
msgid ""
"Recycling array of length 1 in vector-array arithmetic is deprecated.\n"
"  Use c() or as.vector() instead.\n"
msgstr ""
"於向量-陣列算法中回收長度為 1 的陣列已過時。\n"
" 請使用 c() 或 as.vector() 做為替代。\n"

#: src/main/arithmetic.c:620 src/main/logic.c:93 src/main/relop.c:180
msgid "non-conformable arrays"
msgstr "非調和陣列"

#: src/main/arithmetic.c:680 src/main/logic.c:136 src/main/relop.c:224
msgid "longer object length is not a multiple of shorter object length"
msgstr "較長的物件長度並非較短物件長度的倍數"

#: src/main/arithmetic.c:746
msgid "invalid argument to unary operator"
msgstr "一元運算子的引數無效"

#: src/main/arithmetic.c:778 src/main/arithmetic.c:804
#: src/main/arithmetic.c:825
msgid "invalid unary operator"
msgstr "一元運算子無效"

#: src/main/arithmetic.c:1322
msgid "unimplemented real function of 1 argument"
msgstr "單引數的實數函式目前還沒有實作"

#: src/main/arithmetic.c:1336 src/main/complex.c:643 src/main/complex.c:714
msgid "unimplemented complex function"
msgstr "尚未實作複數功能"

#: src/main/arithmetic.c:1626 src/main/arithmetic.c:2031
#: src/main/arithmetic.c:2205 src/main/arithmetic.c:2308
#, c-format
msgid "unimplemented real function of %d numeric arguments"
msgstr "%d 個數值引數的實數函式尚未實作"

#: src/main/arithmetic.c:1654
#, fuzzy, c-format
msgid "%d argument passed to '%s' which requires 1 or 2 arguments"
msgid_plural "%d arguments passed to '%s' which requires 1 or 2 arguments"
msgstr[0] "%d 個引數傳遞給 '%s'，但它只需要一或兩個引數"

#: src/main/arithmetic.c:1665 src/main/arithmetic.c:1777
#: src/main/arithmetic.c:1795 src/main/envir.c:1584 src/main/envir.c:2118
#: src/main/eval.c:762 src/main/eval.c:5141
#, c-format
msgid "argument \"%s\" is missing, with no default"
msgstr "缺少引數 \"%s\"，也沒有預設值"

#: src/main/arithmetic.c:1680
msgid "invalid second argument of length 0"
msgstr "第二引數長度為 0，無效"

#: src/main/arithmetic.c:1801
msgid "invalid argument 'base' of length 0"
msgstr "長度為 0 的無效引數 'base'"

#: src/main/array.c:86 src/main/array.c:2069
#, c-format
msgid "'data' must be of a vector type, was '%s'"
msgstr "'data' 必須是向量類型，但卻是 '%s'"

#: src/main/array.c:106 src/main/array.c:114
msgid "non-numeric matrix extent"
msgstr "非數值的矩陣範圍"

#: src/main/array.c:109 src/main/array.c:2175
msgid "invalid 'nrow' value (too large or NA)"
msgstr "無效的 'nrow' 值 (太大或無法取得)"

#: src/main/array.c:111 src/main/array.c:2177
msgid "invalid 'nrow' value (< 0)"
msgstr "無效的 'nrow' 值 (< 0)"

#: src/main/array.c:117 src/main/array.c:2180
msgid "invalid 'ncol' value (too large or NA)"
msgstr "無效的 'ncol' 值 (太大或無法取得)"

#: src/main/array.c:119 src/main/array.c:2182
msgid "invalid 'ncol' value (< 0)"
msgstr "無效的 'ncol' 值 (< 0)"

#: src/main/array.c:143
#, c-format
msgid ""
"data length [%d] is not a sub-multiple or multiple of the number of rows [%d]"
msgstr "資料長度 [%d] 並非列數量 [%d] 的因子或倍數"

#: src/main/array.c:146
#, c-format
msgid ""
"data length [%d] is not a sub-multiple or multiple of the number of columns "
"[%d]"
msgstr "資料長度 [%d] 並非欄位數量 [%d] 的因子或倍數"

#: src/main/array.c:149 src/main/array.c:151
#, fuzzy, c-format
msgid "data length differs from size of matrix: [%d != %d x %d]"
msgstr "資料長度超過矩陣的大小"

#: src/main/array.c:155
msgid "non-empty data for zero-extent matrix"
msgstr ""

#: src/main/array.c:160 src/main/array.c:2081 src/main/array.c:2189
msgid "too many elements specified"
msgstr "指定了太多的元素"

#: src/main/array.c:218
msgid "negative extents to matrix"
msgstr "矩陣的範圍不能是負值"

#: src/main/array.c:221
msgid "allocMatrix: too many elements specified"
msgstr "allocMatrix: 指定了太多的元素"

#: src/main/array.c:249
msgid "negative extents to 3D array"
msgstr "負值延伸到 3D 陣列"

#: src/main/array.c:252
#, fuzzy
msgid "'alloc3DArray': too many elements specified"
msgstr "alloc3Darray：指定了太多的元素"

#: src/main/array.c:279
msgid "'allocArray': too many elements specified by 'dims'"
msgstr "allocArray: 'dims' 指定了太多的元素"

#: src/main/array.c:546
#, c-format
msgid "'%s' must be a list or atomic vector"
msgstr "'%s' 必須是串列或純量向量"

#: src/main/array.c:590
#, c-format
msgid "a matrix-like object is required as argument to '%s'"
msgstr "'%s' 需要一個類矩陣物件做為引數"

#: src/main/array.c:1254
msgid "requires numeric/complex matrix/vector arguments"
msgstr "需要數值/複數矩陣/向量引數"

#: src/main/array.c:1364 src/main/array.c:1368 src/main/array.c:1372
msgid "non-conformable arguments"
msgstr "非調和引數"

#: src/main/array.c:1671
msgid "argument is not a matrix"
msgstr "引數不是矩陣"

#: src/main/array.c:1706 src/main/attrib.c:1215
#, fuzzy, c-format
msgid "invalid first argument, must be %s"
msgstr "第一個引數無效, 必須是陣列"

#: src/main/array.c:1720
#, c-format
msgid "'perm' is of wrong length %d (!= %d)"
msgstr "'perm' 的長度 %d (!= %d) 不正確"

#: src/main/array.c:1725 src/main/array.c:1728
msgid "'a' does not have named dimnames"
msgstr "'a' 沒有具名的維度名稱"

#: src/main/array.c:1735
#, c-format
msgid "'perm[%d]' does not match a dimension name"
msgstr "perm[%d] 不符合維度名稱"

#: src/main/array.c:1748
msgid "value out of range in 'perm'"
msgstr "'perm' 的值在範圍外"

#: src/main/array.c:1830
msgid "'resize' must be TRUE or FALSE"
msgstr "'resize' 必須為真或假"

#: src/main/array.c:1900
msgid "'x' must be numeric"
msgstr "'x' 必須是數值"

#: src/main/array.c:1903
msgid "'x' is too short"
msgstr "'x' 太短"

#: src/main/array.c:2077
msgid "'dims' cannot be of length 0"
msgstr "'dims' 的長度不可為 0"

#: src/main/array.c:2185
msgid "'x' must have positive length"
msgstr "'x' 的長度必須是正值"

#: src/main/array.c:2286
#, c-format
msgid "singular matrix in 'backsolve'. First zero in diagonal [%d]"
msgstr "'backsolve' 中的奇異矩陣。第一個零值位於對角 [%d]"

#: src/main/attrib.c:40 src/main/attrib.c:249 src/main/attrib.c:281
#: src/main/attrib.c:305 src/main/attrib.c:429 src/main/attrib.c:476
#: src/main/attrib.c:527
msgid "attempt to set an attribute on NULL"
msgstr "試圖在 NULL 上設定屬性"

#: src/main/attrib.c:77
#, c-format
msgid "row names must be 'character' or 'integer', not '%s'"
msgstr "列名稱必須是 '字元' 或 '整數' ，而不是 '%s'"

#: src/main/attrib.c:137
#, c-format
msgid "getAttrib: invalid type (%s) for TAG"
msgstr "getAttrib: 標記的類型 (%s) 無效"

#: src/main/attrib.c:355
msgid "cannot set attribute on a symbol"
msgstr "無法為符號設定屬性"

#: src/main/attrib.c:403
#, fuzzy, c-format
msgid "invalid type (%s) for 'names': must be vector or NULL"
msgstr "'names' 的類型 (%s) 無效: 必須是向量"

#: src/main/attrib.c:406
#, c-format
msgid "'names' attribute [%d] must be the same length as the vector [%d]"
msgstr "'names' 屬性 [%d] 必須和向量的長度 [%d] 一樣"

#: src/main/attrib.c:411
msgid "names() applied to a non-vector"
msgstr "names() 被用於非向量"

#: src/main/attrib.c:419
msgid "invalid time series parameters specified"
msgstr "時間序列參數設定無效"

#: src/main/attrib.c:433
msgid "'tsp' attribute must be numeric"
msgstr "'tsp' 屬性必須是數值"

#: src/main/attrib.c:439
msgid "'tsp' attribute must be numeric of length three"
msgstr "'tsp' 屬性必須是長度為三的數值"

#: src/main/attrib.c:456
msgid "cannot assign 'tsp' to zero-length vector"
msgstr "零長度向量不能指派為 'tsp'"

#: src/main/attrib.c:487
msgid "attempt to set invalid 'comment' attribute"
msgstr "試圖設定無效的 'comment' 屬性"

#: src/main/attrib.c:536
msgid "adding class \"factor\" to an invalid object"
msgstr "加入 \"factor\" 類別到無效的物件"

#: src/main/attrib.c:567
msgid "attempt to set invalid 'class' attribute"
msgstr "試圖設定無效的 'class' 屬性"

#: src/main/attrib.c:916
#, c-format
msgid "invalid to use names()<- on an S4 object of class '%s'"
msgstr "在類別 '%s' 的 S4 物件中使用 names()<- 是無效的"

#: src/main/attrib.c:959
msgid "incompatible 'names' argument"
msgstr "不相容的 'names' 引數"

#: src/main/attrib.c:1010
#, c-format
msgid "invalid type (%s) to set 'names' attribute"
msgstr "以無效的類型 (%s) 設定 'names' 屬性"

#: src/main/attrib.c:1088
msgid "'dimnames' applied to non-array"
msgstr "'dimnames' 被應用於非陣列"

#: src/main/attrib.c:1093 src/main/coerce.c:2724
#, c-format
msgid "'%s' must be a list"
msgstr "'%s' 必須是串列"

#: src/main/attrib.c:1096 src/main/attrib.c:1124
#, c-format
msgid "length of 'dimnames' [%d] must match that of 'dims' [%d]"
msgstr "'dimnames' 的長度 [%d] 必須同 'dims' 的長度 [%d] 相等"

#: src/main/attrib.c:1130
#, c-format
msgid "invalid type (%s) for 'dimnames' (must be a vector)"
msgstr "設 'dimnames' 時的類型 (%s) 無效 (必須是向量)"

#: src/main/attrib.c:1133
#, c-format
msgid "length of 'dimnames' [%d] not equal to array extent"
msgstr "'dimnames' 的長度 [%d] 必須與陣列範圍相等"

#: src/main/attrib.c:1217
#, fuzzy, c-format
msgid "invalid second argument, must be %s"
msgstr "第二個引數無效"

#: src/main/attrib.c:1225
msgid "length-0 dimension vector is invalid"
msgstr "長度為零的維度向量無效"

#: src/main/attrib.c:1230
msgid "the dims contain missing values"
msgstr "維度包含缺少值"

#: src/main/attrib.c:1232
msgid "the dims contain negative values"
msgstr "維度包含負值"

#: src/main/attrib.c:1237
msgid "dims do not match the length of object"
msgstr "維度不符合物件的長度"

#: src/main/attrib.c:1239
#, c-format
msgid "dims [product %d] do not match the length of object [%d]"
msgstr "維度 [product %d] 不符合物件 [%d] 的長度"

#: src/main/attrib.c:1314
#, c-format
msgid "factor level [%d] is duplicated"
msgstr "因子層次 [%d] 已重複"

#: src/main/attrib.c:1342
msgid "attributes must be a list or NULL"
msgstr "屬性必須是串列或空值"

#: src/main/attrib.c:1347
msgid "attributes must be named"
msgstr "屬性必須命名"

#: src/main/attrib.c:1351
#, c-format
msgid "all attributes must have names [%d does not]"
msgstr "所有的屬性都必須有名稱 [%d 卻沒有]"

#: src/main/attrib.c:1456
msgid "'which' must be of mode character"
msgstr "'which' 的模式必須是字元"

#: src/main/attrib.c:1458
msgid "exactly one attribute 'which' must be given"
msgstr "必須給定 'which' 剛好一個屬性"

#: src/main/attrib.c:1519 src/main/attrib.c:1542 src/main/subscript.c:288
#: src/main/subscript.c:292 src/main/subset.c:1318 src/main/subset.c:1376
#, c-format
msgid "partial match of '%s' to '%s'"
msgstr "'%s' 部分匹配到 '%s'"

#: src/main/attrib.c:1588
#, c-format
msgid "invalid type '%s' for slot name"
msgstr "類型 '%s' 做為插槽名稱無效"

#: src/main/attrib.c:1635
msgid "'name' must be non-null character string"
msgstr "'name' 必須是非空字串"

#: src/main/attrib.c:1761 src/main/attrib.c:1832 src/main/attrib.c:1866
msgid "invalid type or length for slot name"
msgstr "名稱插槽的類型或長度無效"

#: src/main/attrib.c:1795
#, c-format
msgid "cannot get a slot (\"%s\") from an object of type \"%s\""
msgstr "類型 \"%2$s\" 的物件中沒有 \"%1$s\" 這樣一個插槽"

#: src/main/attrib.c:1806
#, c-format
msgid "no slot of name \"%s\" for this object of class \"%s\""
msgstr "\"%1$s\" 插槽名不存在於 \"%2$s\" 類型物件中"

#: src/main/attrib.c:1823
msgid "attempt to set slot on NULL object"
msgstr "試圖設在空值物件上定插槽"

#: src/main/attrib.c:1861
msgid "formal classes cannot be used without the 'methods' package"
msgstr "一定要有 'methods' 套件才能使用形式類別"

#: src/main/attrib.c:1873
#, c-format
msgid ""
"trying to get slot \"%s\" from an object of a basic class (\"%s\") with no "
"slots"
msgstr "無法從沒有插槽的基本類別 (\"%2$s\") 的物件中取得 \"%1$s\" 插槽"

#: src/main/attrib.c:1877
#, c-format
msgid ""
"trying to get slot \"%s\" from an object (class \"%s\") that is not an S4 "
"object "
msgstr "嘗試從一個不是 S4 物件的物件 (類別 \"%2$s\") 中獲取插槽 \"%1$s\" "

#: src/main/bind.c:165
#, c-format
msgid "resulting vector exceeds vector length limit in '%s'"
msgstr "所產生的向量超出 '%s' 中的向量長度限制"

#: src/main/bind.c:295 src/main/bind.c:331 src/main/bind.c:380
#: src/main/bind.c:453 src/main/bind.c:481
#, c-format
msgid "type '%s' is unimplemented in '%s'"
msgstr "'%2$s' 中尚未實作類型 '%1$s'"

#: src/main/bind.c:729
msgid "repeated formal argument 'recursive'"
msgstr "形式引數 'recursive' 出現重複"

#: src/main/bind.c:740
msgid "repeated formal argument 'use.names'"
msgstr "形式引數 'use.names' 出現重複"

#: src/main/bind.c:943
msgid "argument not a list"
msgstr "引數不是串列"

#: src/main/bind.c:1094 src/main/names.c:1321 src/main/names.c:1326
#: src/main/names.c:1331 src/main/names.c:1336
#, c-format
msgid "class name too long in '%s'"
msgstr "'%s' 中的類別名稱太長"

#: src/main/bind.c:1163
#, c-format
msgid "cannot create a matrix from type '%s'"
msgstr "無法從類型 '%s' 建立矩陣"

#: src/main/bind.c:1233
#, c-format
msgid "number of rows of matrices must match (see arg %d)"
msgstr "矩陣的列數必須相符 (參看引數 %d)"

#: src/main/bind.c:1397
#, fuzzy, c-format
msgid "cannot create a matrix of type '%s'"
msgstr "無法從類型 '%s' 建立矩陣"

#: src/main/bind.c:1498
#, c-format
msgid "number of columns of matrices must match (see arg %d)"
msgstr "矩陣的行數必須相符 (參看引數 %d)"

#: src/main/builtin.c:43
msgid "vector size cannot be NA"
msgstr "向量大小不能是 NA"

#: src/main/builtin.c:49 src/main/builtin.c:57 src/main/sort.c:1508
msgid "vector size cannot be NA/NaN"
msgstr "向量大小不能是 NA/NaN"

#: src/main/builtin.c:50 src/main/builtin.c:58 src/main/sort.c:1509
msgid "vector size cannot be infinite"
msgstr "向量大小不能是無限大"

#: src/main/builtin.c:51 src/main/builtin.c:59 src/main/builtin.c:954
#: src/main/sort.c:1510
msgid "vector size specified is too large"
msgstr "指定的向量大小太大"

#: src/main/builtin.c:75 src/main/builtin.c:112 src/main/envir.c:1866
#: src/main/envir.c:1987 src/main/envir.c:2076 src/main/envir.c:2210
#: src/main/paste.c:93 src/main/paste.c:339 src/main/random.c:479
#: src/main/random.c:508 src/main/unique.c:2252
msgid "invalid first argument"
msgstr "第一個引數無效"

#: src/main/builtin.c:84 src/main/builtin.c:93 src/main/builtin.c:317
#: src/main/builtin.c:351 src/main/builtin.c:404 src/main/builtin.c:418
#: src/main/coerce.c:1616 src/main/connections.c:3388 src/main/engine.c:3234
#: src/main/envir.c:1004 src/main/envir.c:1058 src/main/envir.c:1224
#: src/main/envir.c:1257 src/main/envir.c:1875 src/main/envir.c:1992
#: src/main/envir.c:2027 src/main/envir.c:2085 src/main/envir.c:2217
#: src/main/envir.c:2944 src/main/envir.c:3031 src/main/envir.c:3334
#: src/main/envir.c:3363 src/main/envir.c:3384 src/main/envir.c:3407
#: src/main/envir.c:3442 src/main/envir.c:3463 src/main/envir.c:3510
#: src/main/envir.c:3969 src/main/envir.c:3974 src/main/eval.c:8079
#: src/main/objects.c:243 src/main/objects.c:251 src/main/saveload.c:2174
#: src/main/saveload.c:2471 src/main/serialize.c:3110
msgid "use of NULL environment is defunct"
msgstr "NULL 環境的使用已經廢止"

#: src/main/builtin.c:259 src/main/builtin.c:274
msgid "argument is not a function"
msgstr "引數不是函式"

#: src/main/builtin.c:331
msgid "replacement object is not an environment"
msgstr "替換物件不是環境物件"

#: src/main/builtin.c:355
msgid "'enclos' must be an environment"
msgstr "'enclos' 必須是環境物件"

#: src/main/builtin.c:373 src/main/builtin.c:409
msgid "argument is not an environment"
msgstr "引數不是環境物件"

#: src/main/builtin.c:375
msgid "the empty environment has no parent"
msgstr "空環境沒有上一層"

#: src/main/builtin.c:411
msgid "can not set parent of the empty environment"
msgstr "無法設定空環境的上層"

#: src/main/builtin.c:413
msgid "can not set the parent environment of a namespace"
msgstr "無法設定命名空間的上層環境"

#: src/main/builtin.c:415
msgid "can not set the parent environment of package imports"
msgstr "無法設定套件匯入的上層環境"

#: src/main/builtin.c:423
msgid "'parent' is not an environment"
msgstr "'parent' 不是環境物件"

#: src/main/builtin.c:569 src/main/connections.c:4094
#: src/main/connections.c:4477 src/main/connections.c:4514
#: src/main/connections.c:4897 src/main/connections.c:4967
#: src/main/connections.c:5185 src/main/connections.c:5189
#: src/main/connections.c:5667 src/main/deparse.c:414 src/main/deparse.c:500
#: src/main/serialize.c:2381
msgid "cannot write to this connection"
msgstr "無法寫入此連接"

#: src/main/builtin.c:574 src/main/builtin.c:604
#, c-format
msgid "invalid '%s' specification"
msgstr "'%s' 設定無效"

#: src/main/builtin.c:591
msgid "non-positive 'fill' argument will be ignored"
msgstr "非正數的 'fill' 引數將會被忽略"

#: src/main/builtin.c:666
#, c-format
msgid "argument %d (type '%s') cannot be handled by 'cat'"
msgstr "'cat' 目前還不能用 %d 引數 (類型 '%s')"

#: src/main/builtin.c:810
#, c-format
msgid "vector: cannot make a vector of mode '%s'."
msgstr "向量：無法建立模式為 '%s' 的向量。"

#: src/main/builtin.c:836
msgid "cannot set length of non-(vector or list)"
msgstr "無法設定非(向量或串列)的長度"

#: src/main/builtin.c:837 src/main/character.c:665 src/main/coerce.c:3090
msgid "invalid value"
msgstr "無效的值"

#: src/main/builtin.c:839
msgid "length of NULL cannot be changed"
msgstr "NULL 的長度無法改變"

#: src/main/builtin.c:950 src/main/envir.c:2227 src/main/envir.c:2235
#, c-format
msgid "wrong length for '%s' argument"
msgstr "'%s' 引數的長度錯誤"

#: src/main/builtin.c:980 src/main/coerce.c:2794 src/main/coerce.c:2837
#: src/main/eval.c:752 src/main/eval.c:882 src/main/eval.c:3065
#: src/main/eval.c:3154 src/main/eval.c:3225 src/main/eval.c:3567
#: src/main/eval.c:7066 src/main/eval.c:7213
msgid "'...' used in an incorrect context"
msgstr "'...' 的上下文用得不正確"

#: src/main/builtin.c:1002
#, c-format
msgid "duplicate 'switch' defaults: '%s' and '%s'"
msgstr "複製 'switch' 的預設值：'%s' 和 '%s'"

#: src/main/builtin.c:1035
msgid "'EXPR' is missing"
msgstr "缺少 'EXPR'"

#: src/main/builtin.c:1039 src/main/eval.c:7629
msgid "EXPR must be a length 1 vector"
msgstr "EXPR 必須是長度為 1 的向量"

#: src/main/builtin.c:1042 src/main/eval.c:7632
#, c-format
msgid ""
"EXPR is a \"factor\", treated as integer.\n"
" Consider using '%s' instead."
msgstr ""
"EXPR 是一個 \"factor\"，視為整數。\n"
" 請考慮使用 '%s' 做為替代。"

#: src/main/builtin.c:1099 src/main/eval.c:7642 src/main/eval.c:7671
msgid "'switch' with no alternatives"
msgstr "switch 而無替代方案"

#: src/main/character.c:117 src/main/character.c:305
#, c-format
msgid "%d argument passed to '%s' which requires %d to %d"
msgid_plural "%d arguments passed to '%s' which requires %d to %d"
msgstr[0] "傳遞了 %d 個引數給 '%s' 但它需要 %d 到 %d 個"

#: src/main/character.c:124 src/main/character.c:127 src/main/character.c:314
#: src/main/character.c:317
#, c-format
msgid "'%s' requires a character vector"
msgstr "'%s' 需要字元向量"

#: src/main/character.c:176 src/main/character.c:202 src/main/character.c:216
#: src/main/character.c:281 src/main/character.c:388 src/main/character.c:593
#: src/main/character.c:598
#, c-format
msgid "invalid multibyte string, %s"
msgstr "多位元組字串 %s 無效"

#: src/main/character.c:192
#, c-format
msgid "number of characters is not computable in \"bytes\" encoding, %s"
msgstr "對於 \"bytes\" 編碼中的元素 %s 而言，字元數量並非可計算的"

#: src/main/character.c:245
#, c-format
msgid "width is not computable for %s in \"bytes\" encoding"
msgstr "對於 \"bytes\" 編碼中的元素 %s 而言，寬度並非可計算的"

#: src/main/character.c:345
#, fuzzy, c-format
msgid "invalid multibyte string, element %ld"
msgstr "多位元組字串 %d 無效"

#: src/main/character.c:348
#, fuzzy, c-format
msgid ""
"number of characters is not computable in \"bytes\" encoding, element %ld"
msgstr "對於 \"bytes\" 編碼中的元素 %s 而言，字元數量並非可計算的"

#: src/main/character.c:351
#, fuzzy, c-format
msgid "width is not computable in \"bytes\" encoding, element %ld"
msgstr "對於 \"bytes\" 編碼中的元素 %s 而言，寬度並非可計算的"

#: src/main/character.c:429
msgid "extracting substrings from a non-character object"
msgstr "從非字元物件中抽取子字串"

#: src/main/character.c:440 src/main/character.c:662
msgid "invalid substring arguments"
msgstr "無效的子字串引數"

#: src/main/character.c:485
msgid "non-character object(s)"
msgstr "非字元物件"

#: src/main/character.c:657
msgid "replacing substrings in a non-character object"
msgstr "在非字元的物件中替換子字串"

#: src/main/character.c:927
msgid "the first argument must be a character vector"
msgstr "第一個引數必須是字元向量"

#: src/main/character.c:964
msgid "abbreviate used with non-ASCII chars"
msgstr "abbreviate 不適用於非 ASCII 字元"

#: src/main/character.c:985
msgid "non-character names"
msgstr "不能有非字元名稱"

#: src/main/character.c:1038 src/main/character.c:1167
#, c-format
msgid "invalid multibyte string %d"
msgstr "多位元組字串 %d 無效"

#: src/main/character.c:1080 src/main/grep.c:507
msgid "non-character argument"
msgstr "非字元引數"

#: src/main/character.c:1223
#, c-format
msgid "decreasing range specification ('%lc-%lc')"
msgstr "正在遞減範圍設定 ('%lc-%lc')"

#: src/main/character.c:1309
#, c-format
msgid "decreasing range specification ('%c-%c')"
msgstr "正在遞減範圍設定 ('%c-%c')"

#: src/main/character.c:1499 src/main/character.c:1505
msgid "invalid UTF-8 string 'old'"
msgstr "無效的 UTF-8 字串 'old'"

#: src/main/character.c:1511
msgid "invalid multibyte string 'old'"
msgstr "多位元組字串 'old' 無效"

#: src/main/character.c:1524 src/main/character.c:1530
msgid "invalid UTF-8 string 'new'"
msgstr "無效的 UTF-8 字串 'new'"

#: src/main/character.c:1536
msgid "invalid multibyte string 'new'"
msgstr "多位元組字串 'new' 無效"

#: src/main/character.c:1564 src/main/character.c:1653
msgid "'old' is longer than 'new'"
msgstr "'old' 比 'new' 要長"

#: src/main/character.c:1596
#, c-format
msgid "invalid input multibyte string %d"
msgstr "輸入的多位元組字串 %d 無效"

#: src/main/character.c:1702
msgid "strtrim() requires a character vector"
msgstr "strtrim() 需要字元向量"

#: src/main/coerce.c:33
msgid "invalid 'mode' argument"
msgstr "無效的 'mode' 引數"

#: src/main/coerce.c:34
msgid "applies only to lists and vectors"
msgstr "只能用於串列和向量"

#: src/main/coerce.c:81 src/main/errors.c:1440
msgid "NAs introduced by coercion"
msgstr "強制變更過程中產生了 NA"

#: src/main/coerce.c:83
msgid "NAs introduced by coercion to integer range"
msgstr "強制變更為整數範圍的過程中產生了 NA"

#: src/main/coerce.c:85 src/main/errors.c:1442
msgid "imaginary parts discarded in coercion"
msgstr "強制變更時丟棄了虛數部分"

#: src/main/coerce.c:87
msgid "out-of-range values treated as 0 in coercion to raw"
msgstr "在強制變更成純量值時，任何溢位值當作 0 來處理"

#: src/main/coerce.c:418
#, c-format
msgid "invalid data of mode '%s' (too short)"
msgstr "無效的模式 '%s' 資料 (太短)"

#: src/main/coerce.c:1019 src/main/coerce.c:1141 src/main/coerce.c:1164
#, fuzzy, c-format
msgid "'%s' object cannot be coerced to type '%s'"
msgstr "'pairlist' 物件無法強制變更成 '%s'"

#: src/main/coerce.c:1194 src/main/coerce.c:1564
msgid "no method for coercing this S4 class to a vector"
msgstr "沒有方法可將這個 S4 類別強制變更成向量"

#: src/main/coerce.c:1263
msgid "environments cannot be coerced to other types"
msgstr "環境物件不能被強制變更成其它類型"

#: src/main/coerce.c:1423
msgid "attempting to coerce non-factor"
msgstr "試圖強制變更非因子"

#: src/main/coerce.c:1428 src/main/coerce.c:1438
msgid "malformed factor"
msgstr "異常的因子"

#: src/main/coerce.c:1612
msgid "list argument expected"
msgstr "需要串列引數"

#: src/main/coerce.c:1620 src/main/eval.c:8083
msgid "invalid environment"
msgstr "環境物件無效"

#: src/main/coerce.c:1624
msgid "argument must have length at least 1"
msgstr "引數的長度至少要為 1"

#: src/main/coerce.c:1646
msgid "invalid body for function"
msgstr "函式本體無效"

#: src/main/coerce.c:1672
#, fuzzy
msgid "argument must be character"
msgstr "引數 '%s' 必須是字串"

#: src/main/coerce.c:1677
#, fuzzy
msgid "argument must be a character string"
msgstr "引數 '%s' 必須是字串"

#: src/main/coerce.c:1718
#, c-format
msgid "parsing result not of length one, but %d"
msgstr ""

#: src/main/coerce.c:1750
msgid "invalid length 0 argument"
msgstr "長度為 0 的引數是無效的"

#: src/main/coerce.c:1766
msgid "as.call(<character>) not feasible; consider str2lang(<char.>)"
msgstr ""

#: src/main/coerce.c:1769
msgid "invalid argument list"
msgstr "引數串列無效"

#: src/main/coerce.c:1790
#, c-format
msgid "'length(x) = %lld > 1' in coercion to '%s'"
msgstr ""

#: src/main/coerce.c:2134
msgid "type \"single\" unimplemented in R"
msgstr "類型 \"single\" 目前在 R 中還沒有實作"

#: src/main/coerce.c:2136
msgid "unimplemented predicate"
msgstr "尚未實作的述詞"

#: src/main/coerce.c:2325
#, c-format
msgid "%s() applied to non-(list or vector) of type '%s'"
msgstr "%s() 套用到非串列或向量類型 '%s'"

#: src/main/coerce.c:2521 src/main/coerce.c:2582 src/main/coerce.c:2658
#, c-format
msgid "default method not implemented for type '%s'"
msgstr "預設方法尚未於類型 '%s' 中實作"

#: src/main/coerce.c:2678
msgid "'name' is missing"
msgstr "缺少 'name'"

#: src/main/coerce.c:2685
msgid "first argument must be a character string"
msgstr "第一個引數必須是字串"

#: src/main/coerce.c:2717
msgid "'what' must be a function or character string"
msgstr "'what' 必須是函式或字串"

#: src/main/coerce.c:2728 src/main/unique.c:1855
msgid "'envir' must be an environment"
msgstr "'envir' 必須是環境物件"

#: src/main/coerce.c:2888
msgid "invalid environment specified"
msgstr "環境設定無效"

#: src/main/coerce.c:2957
msgid "Setting class(x) to NULL;   result will no longer be an S4 object"
msgstr "設定 class(x) 為空值； 結果將不再是 S4 物件"

#: src/main/coerce.c:2960
#, c-format
msgid ""
"Setting class(x) to multiple strings (\"%s\", \"%s\", ...); result will no "
"longer be an S4 object"
msgstr "設定 class(x) 為多重字串 (\"%s\", \"%s\", ...)；結果將不再是 S4 物件"

#: src/main/coerce.c:2964
#, c-format
msgid ""
"Setting class(x) to \"%s\" sets attribute to NULL; result will no longer be "
"an S4 object"
msgstr "設定 class(x) 為 \"%s\" 設定屬性為空值；結果將不再是 S4 物件"

#: src/main/coerce.c:2995
msgid "invalid replacement object to be a class string"
msgstr "字串類別的替換物件無效"

#: src/main/coerce.c:3013
#, c-format
msgid ""
"\"%s\" can only be set as the class if the object has this type; found \"%s\""
msgstr "只有在物件有此一類別的情況下才能設 \"%s\"；不應該有 \"%s\""

#: src/main/coerce.c:3031
#, c-format
msgid ""
"invalid to set the class to matrix unless the dimension attribute is of "
"length 2 (was %d)"
msgstr "除非維度的長度為 2(目前是 %d)，否則不能設為矩陣類別"

#: src/main/coerce.c:3039
msgid ""
"cannot set class to \"array\" unless the dimension attribute has length > 0"
msgstr "除非維度的長度 >0，否則不能設為 \"array\" 類別"

#: src/main/coerce.c:3081
msgid "'value' must be non-null character string"
msgstr "'value' 必須是非空字串"

#: src/main/coerce.c:3094
msgid "invalid to change the storage mode of a factor"
msgstr "變更因子的儲存體模式無效"

#: src/main/complex.c:95
msgid "invalid complex unary operator"
msgstr "單一複數運算子無效"

#: src/main/complex.c:227
msgid "unimplemented complex operation"
msgstr "複數運算目前還沒有實作"

#: src/main/complex.c:347
msgid "non-numeric argument to function"
msgstr "函式不能有非數值引數"

#: src/main/complex.c:838
msgid "invalid polynomial coefficient"
msgstr "多項式係數無效"

#: src/main/complex.c:843
msgid "root finding code failed"
msgstr "求根運算執行失敗"

#: src/main/connections.c:153
msgid "all connections are in use"
msgstr "所有連接都已在使用"

#: src/main/connections.c:164
msgid "connection not found"
msgstr "找不到連接"

#: src/main/connections.c:175 src/main/connections.c:5681
msgid "invalid connection"
msgstr "連接無效"

#: src/main/connections.c:207
#, c-format
msgid "closing unused connection %d (%s)\n"
msgstr "關閉未使用的連接 %d (%s)\n"

#: src/main/connections.c:232 src/main/serialize.c:1686
#: src/main/serialize.c:1709 src/main/sysutils.c:645 src/main/sysutils.c:889
#: src/main/sysutils.c:904 src/main/sysutils.c:1111 src/main/sysutils.c:1177
#: src/main/sysutils.c:1258 src/main/sysutils.c:1268 src/main/sysutils.c:1281
#: src/main/sysutils.c:1698
#, c-format
msgid "unsupported conversion from '%s' to '%s'"
msgstr "不支援從 '%s' 到 '%s' 的轉換"

#: src/main/connections.c:395 src/main/connections.c:410
#: src/main/connections.c:582 src/main/connections.c:587
#: src/main/connections.c:592 src/main/connections.c:603
#: src/main/connections.c:609
#, c-format
msgid "%s not enabled for this connection"
msgstr "%s 未於此連接啟用"

#: src/main/connections.c:482
msgid "invalid char string in output conversion"
msgstr "輸出轉換字串無效"

#: src/main/connections.c:563
#, c-format
msgid "invalid input found on input connection '%s'"
msgstr "輸入連接 '%s' 中的輸入無效"

#: src/main/connections.c:761 src/main/platform.c:1076
#, c-format
msgid "cannot open file '%ls': %s"
msgstr "無法開啟檔案 '%ls'：%s"

#: src/main/connections.c:765
#, fuzzy, c-format
msgid "cannot open file '%ls': it is a directory"
msgstr "無法開啟檔案 '%ls'：%s"

#: src/main/connections.c:795 src/main/connections.c:1702
#: src/main/connections.c:1853 src/main/connections.c:2049
#, fuzzy, c-format
msgid "cannot open file '%s': it is a directory"
msgstr "無法開啟檔案 '%s' ：%s"

#: src/main/connections.c:908
msgid "connection is not open for reading"
msgstr "連接沒有開啟而不能讀"

#: src/main/connections.c:913
msgid "connection is not open for writing"
msgstr "連接沒有開啟而不能寫"

#: src/main/connections.c:951 src/main/connections.c:2509
msgid "can only truncate connections open for writing"
msgstr "只能截短已經開啟之可以寫入的連接"

#: src/main/connections.c:955 src/main/connections.c:957
msgid "file truncation failed"
msgstr "未能截短檔案"

#: src/main/connections.c:959
msgid "file truncation unavailable on this platform"
msgstr "本平臺上沒有檔案截短功能"

#: src/main/connections.c:1005 src/main/connections.c:1009
#: src/main/connections.c:1016 src/main/connections.c:1034
msgid "allocation of file connection failed"
msgstr "檔案連接配置失敗"

#: src/main/connections.c:1086 src/main/connections.c:1261
#, c-format
msgid "cannot create fifo '%s', reason '%s'"
msgstr "無法建立先進先出 '%s'，原因是 '%s'"

#: src/main/connections.c:1092
#, c-format
msgid "'%s' exists but is not a fifo"
msgstr "'%s' 存在但不是先進先出"

#: src/main/connections.c:1106
#, c-format
msgid "fifo '%s' is not ready"
msgstr "先進先出 '%s' 還沒有準備好"

#: src/main/connections.c:1107
#, c-format
msgid "cannot open fifo '%s'"
msgstr "無法開啟先進先出 '%s'"

#: src/main/connections.c:1148 src/main/connections.c:1159
#: src/main/connections.c:1320 src/main/connections.c:1339
#: src/main/connections.c:1768 src/main/connections.c:1778
#: src/main/connections.c:1908 src/main/connections.c:1968
#: src/main/connections.c:2526 src/main/connections.c:2542
#: src/main/connections.c:2864 src/main/connections.c:5853
#: src/main/connections.c:5917
msgid "too large a block specified"
msgstr "指定的區塊太大"

#: src/main/connections.c:1222
msgid "allocation of fifo name failed"
msgstr "先進先出名稱配置失敗"

#: src/main/connections.c:1283
#, c-format
msgid "cannot open fifo '%s', reason '%s'"
msgstr "無法開啟先進先出裝置 '%s' ，原因是 '%s'"

#: src/main/connections.c:1323 src/main/connections.c:1347
msgid "allocation of fifo buffer failed"
msgstr "先進先出緩衝區配置失敗"

#: src/main/connections.c:1355
#, c-format
msgid "cannot write FIFO '%s'"
msgstr "無法寫入先進先出裝置 '%s'"

#: src/main/connections.c:1391 src/main/connections.c:1395
#: src/main/connections.c:1402 src/main/connections.c:1419
msgid "allocation of fifo connection failed"
msgstr "先進先出連接配置失敗"

#: src/main/connections.c:1439 src/main/connections.c:1604
#: src/main/connections.c:2261 src/main/connections.c:3555
#: src/main/connections.c:5402
msgid "only first element of 'description' argument used"
msgstr "只用了 'description' 引數的第一個元素"

#: src/main/connections.c:1456
msgid ""
"fifo(\"\") only supports open = \"w+\" and open = \"w+b\": using the former"
msgstr "fifo (\"\") 只有支援開啟= \"w+\" 和開啟= \"w+b\"：使用前項"

#: src/main/connections.c:1471 src/main/connections.c:1642
#: src/main/connections.c:2329 src/main/connections.c:3523
#: src/main/connections.c:3577 src/main/connections.c:3625
#: src/main/connections.c:3964 src/main/connections.c:4086
#: src/main/connections.c:4251 src/main/connections.c:4507
#: src/main/connections.c:4834 src/main/connections.c:4960
#: src/main/connections.c:5181 src/main/connections.c:5648 src/main/dcf.c:93
#: src/main/deparse.c:406 src/main/deparse.c:492 src/main/saveload.c:2371
#: src/main/saveload.c:2456 src/main/scan.c:947 src/main/serialize.c:2552
#: src/main/serialize.c:2601 src/main/source.c:290
msgid "cannot open the connection"
msgstr "無法開啟連接"

#: src/main/connections.c:1486
msgid "fifo connections are not available on this system"
msgstr "本系統沒有先進先出連接這個功能"

#: src/main/connections.c:1517
#, c-format
msgid "cannot pipe() cmd '%ls': %s"
msgstr "無法使用 pipe() 命令 '%ls'：%s"

#: src/main/connections.c:1524
#, c-format
msgid "cannot open pipe() cmd '%s': %s"
msgstr "無法開啟 pipe() 命令 '%s'：%s"

#: src/main/connections.c:1707 src/main/connections.c:2044
#, c-format
msgid "cannot open compressed file '%s', probable reason '%s'"
msgstr "無法開啟壓縮過的檔案 '%s'，可能的原因是 '%s'"

#: src/main/connections.c:1748
msgid "whence = \"end\" is not implemented for gzfile connections"
msgstr "whence = \"end\" 不適用於 gz 檔案連接"

#: src/main/connections.c:1753
msgid "seek on a gzfile connection returned an internal error"
msgstr "讀取 gz 檔案連接時內部發生錯誤"

#: src/main/connections.c:1787 src/main/connections.c:1791
#: src/main/connections.c:1798 src/main/connections.c:1816
msgid "allocation of gzfile connection failed"
msgstr "配置 gz 檔案連接失敗"

#: src/main/connections.c:1848
#, c-format
msgid "cannot open bzip2-ed file '%s', probable reason '%s'"
msgstr "無法開啟 bzip2 壓縮過的檔案 '%s'，可能的原因是 '%s'"

#: src/main/connections.c:1862
#, c-format
msgid "file '%s' appears not to be compressed by bzip2"
msgstr "檔案 '%s' 看起來不像是 bzip2 類別"

#: src/main/connections.c:1871
#, c-format
msgid "initializing bzip2 compression for file '%s' failed"
msgstr "初始化 bzip2 壓縮檔案 '%s' 時失敗"

#: src/main/connections.c:1926
msgid "allocation of overflow buffer for bzfile failed"
msgstr "為 bzfile 的溢位緩衝區配置時失敗"

#: src/main/connections.c:1933
#, c-format
msgid ""
"file '%s' has trailing content that appears not to be compressed by bzip2"
msgstr "檔案 '%s' 有尾隨的內容，看起來並非由 bzip2 壓縮過"

#: src/main/connections.c:1979 src/main/connections.c:1983
#: src/main/connections.c:1990 src/main/connections.c:2008
msgid "allocation of bzfile connection failed"
msgstr "配置 bz 檔案連接失敗"

#: src/main/connections.c:2062 src/main/connections.c:6626
#, c-format
msgid "cannot initialize lzma decoder, error %d"
msgstr "無法初始化 lzma 解碼器，錯誤 %d"

#: src/main/connections.c:2078
#, c-format
msgid "cannot initialize lzma encoder, error %d"
msgstr "無法初始化 lzma 編碼器，錯誤 %d"

#: src/main/connections.c:2207 src/main/connections.c:2211
#: src/main/connections.c:2218 src/main/connections.c:2237
msgid "allocation of xzfile connection failed"
msgstr "xzfile 連接配置時失敗"

#: src/main/connections.c:2298
#, c-format
msgid "this is a %s-compressed file which this build of R does not support"
msgstr "這是 %s 壓縮過的檔案，這版組建的 R 並不支援它"

#: src/main/connections.c:2404 src/modules/X11/devX11.c:3482
msgid "memory allocation to copy clipboard failed"
msgstr "複製剪貼簿時記憶體配置失敗"

#: src/main/connections.c:2409 src/modules/X11/devX11.c:3461
#: src/modules/X11/devX11.c:3466
msgid "clipboard cannot be opened or contains no text"
msgstr "打不開剪貼簿，或是剪貼簿不含文字"

#: src/main/connections.c:2420
msgid "memory allocation to open clipboard failed"
msgstr "開啟剪貼簿時記憶體配置失敗"

#: src/main/connections.c:2454
msgid "unable to open the clipboard"
msgstr "無法開啟剪貼簿"

#: src/main/connections.c:2458
msgid "unable to write to the clipboard"
msgstr "無法寫入剪貼簿"

#: src/main/connections.c:2498
msgid "attempt to seek outside the range of the clipboard"
msgstr "無法檢索剪貼簿範圍外的內容"

#: src/main/connections.c:2540
msgid "clipboard connection is open for reading only"
msgstr "開啟了唯讀剪貼簿連接"

#: src/main/connections.c:2571
msgid "clipboard buffer is full and output lost"
msgstr "剪貼簿緩衝區已滿，輸出資料丟失"

#: src/main/connections.c:2592
msgid "'mode' for the clipboard must be 'r' or 'w'"
msgstr "剪貼簿 'mode' 必須是 'r' 或 'w'"

#: src/main/connections.c:2595
msgid "'mode' for the clipboard must be 'r' on Unix"
msgstr "Unix 作業系統上剪貼簿 'mode' 必須是 'r'"

#: src/main/connections.c:2598 src/main/connections.c:2604
#: src/main/connections.c:2611 src/main/connections.c:2629
msgid "allocation of clipboard connection failed"
msgstr "剪貼簿連接配置失敗"

#: src/main/connections.c:2699 src/main/connections.c:2703
#: src/main/connections.c:2710
msgid "allocation of terminal connection failed"
msgstr "終端機連接配置失敗"

#: src/main/connections.c:2841
msgid "attempting to add too many elements to raw vector"
msgstr "試圖加入太多元素到純量向量"

#: src/main/connections.c:2893
msgid "attempt to seek outside the range of the raw connection"
msgstr "試圖尋指原始連接以外的範圍"

#: src/main/connections.c:2904 src/main/connections.c:2908
#: src/main/connections.c:2915 src/main/connections.c:2942
msgid "allocation of raw connection failed"
msgstr "原始連接的配置失敗"

#: src/main/connections.c:2994
#, fuzzy, c-format
msgid "'%s' is not a %s"
msgstr "先進先出 '%s' 還沒有準備好"

#: src/main/connections.c:2998
#, fuzzy, c-format
msgid "internal connection is not a %s"
msgstr "連接未開啟"

#: src/main/connections.c:3011
msgid "'con' is not an output rawConnection"
msgstr "'con' 不是個輸出的 rawConnection"

#: src/main/connections.c:3051
msgid "too many characters for text connection"
msgstr "文字連接使用太多字元"

#: src/main/connections.c:3056
msgid "cannot allocate memory for text connection"
msgstr "無法給文字連接配置記憶體"

#: src/main/connections.c:3106
msgid "seek is not relevant for text connection"
msgstr "讀取對文字連接無用"

#: src/main/connections.c:3115 src/main/connections.c:3119
#: src/main/connections.c:3126 src/main/connections.c:3140
#: src/main/connections.c:3328 src/main/connections.c:3332
#: src/main/connections.c:3339 src/main/connections.c:3353
#: src/main/connections.c:3360
msgid "allocation of text connection failed"
msgstr "文字連接配置失敗"

#: src/main/connections.c:3303
msgid "text connection: appending to a non-existent char vector"
msgstr "文字連接: 不能附加給不存在的字元向量"

#: src/main/connections.c:3415
msgid "unsupported mode"
msgstr "不支援的狀態"

#: src/main/connections.c:3438
msgid "'con' is not an output textConnection"
msgstr "'con' 不是個輸出 textConnection"

#: src/main/connections.c:3605 src/main/connections.c:3654
#: src/main/connections.c:3665 src/main/connections.c:3749
#: src/main/connections.c:3779 src/main/connections.c:3802
#: src/main/connections.c:3814 src/main/connections.c:3940
#: src/main/connections.c:4071 src/main/connections.c:5957
msgid "'con' is not a connection"
msgstr "'con' 不是個連接"

#: src/main/connections.c:3608
msgid "cannot open standard connections"
msgstr "無法開啟標準連接"

#: src/main/connections.c:3610
msgid "connection is already open"
msgstr "連接已開啟"

#: src/main/connections.c:3643
msgid "unknown 'rw' value"
msgstr "不明的 'rw' 值"

#: src/main/connections.c:3678
#, c-format
msgid "Problem closing connection:  %s"
msgstr "關閉連接時發生問題：%s"

#: src/main/connections.c:3680
msgid "Problem closing connection"
msgstr "關閉連接時發生問題"

#: src/main/connections.c:3751
msgid "cannot close standard connections"
msgstr "無法關閉標準連接"

#: src/main/connections.c:3754
msgid "cannot close 'output' sink connection"
msgstr "無法關閉 'output' 匯集連接"

#: src/main/connections.c:3756
msgid "cannot close 'message' sink connection"
msgstr "無法關閉 'message' 匯集連接"

#: src/main/connections.c:3781 src/main/connections.c:5666
#: src/main/connections.c:5674 src/main/serialize.c:2371
#: src/main/serialize.c:2379
msgid "connection is not open"
msgstr "連接未開啟"

#: src/main/connections.c:3879 src/main/connections.c:3892
#, c-format
msgid "line longer than buffer size %lu"
msgstr "列長大於緩衝區尺寸 %lu"

#: src/main/connections.c:3910
#, c-format
msgid "Error writing to connection:  %s"
msgstr "寫入連接：%s 時發生了錯誤"

#: src/main/connections.c:3912
msgid "Error writing to connection"
msgstr "寫入連接時發生了錯誤"

#: src/main/connections.c:3971 src/main/connections.c:3973
#: src/main/connections.c:4259 src/main/connections.c:4817
#: src/main/connections.c:4842 src/main/connections.c:5675 src/main/dcf.c:100
#: src/main/scan.c:950 src/main/scan.c:954 src/main/serialize.c:2373
#: src/main/source.c:293
msgid "cannot read from this connection"
msgstr "無法從此連接讀取"

#: src/main/connections.c:3985 src/main/connections.c:4007
msgid "cannot allocate buffer in readLines"
msgstr "無法給 readLines 配置緩衝區"

#: src/main/connections.c:4025
#, c-format
msgid "line %d appears to contain an embedded nul"
msgstr "第 %d 列看來包含嵌入的空值"

#: src/main/connections.c:4043
#, c-format
msgid "incomplete final line found on '%s'"
msgstr "於 '%s' 找到不完整的最後一列"

#: src/main/connections.c:4049
msgid "too few lines read in readLines"
msgstr "readLines 讀的列數不夠"

#: src/main/connections.c:4156
msgid "incomplete string at end of file has been discarded"
msgstr "忽略檔案末端不完整的字串"

#: src/main/connections.c:4162
msgid "null terminator not found: breaking string at 10000 bytes"
msgstr "空值終止符找不到：中斷字串於 10000 位元組"

#: src/main/connections.c:4227
msgid "can only read from a binary connection"
msgstr "無法讀取二進位連接"

#: src/main/connections.c:4275 src/main/connections.c:4576
msgid "size changing is not supported for complex vectors"
msgstr "不支援複數向量大小的變更"

#: src/main/connections.c:4320 src/main/connections.c:4354
#: src/main/connections.c:4398 src/main/connections.c:4429
#: src/main/connections.c:4449 src/main/connections.c:4570
#: src/main/connections.c:4628 src/main/connections.c:4659
#, c-format
msgid "size %d is unknown on this machine"
msgstr "本系統沒有 %d 這樣大小的值"

#: src/main/connections.c:4339
msgid "raw is always of size 1"
msgstr "純量的大小只能是 1"

#: src/main/connections.c:4362
msgid "'signed = FALSE' is only valid for integers of sizes 1 and 2"
msgstr "'signed = FALSE' 用對於大小為 1 和 2 的整數有效"

#: src/main/connections.c:4468
msgid "'x' is not an atomic vector type"
msgstr "'x' 非基元向量類型"

#: src/main/connections.c:4475
msgid "can only write to a binary connection"
msgstr "只能寫入二進位連接"

#: src/main/connections.c:4495
msgid "only 2^31-1 bytes can be written to a raw vector"
msgstr "只有 2^31-1 位元組可以被寫入純量向量"

#: src/main/connections.c:4497
msgid "only 2^31-1 bytes can be written in a single writeBin() call"
msgstr "只有 2^31-1 位元組可以被寫入單一 writeBin() 呼叫"

#: src/main/connections.c:4549 src/main/connections.c:4687
#: src/main/connections.c:4991 src/main/connections.c:5031
msgid "problem writing to connection"
msgstr "寫入連接有問題"

#: src/main/connections.c:4581
msgid "size changing is not supported for raw vectors"
msgstr "不支援純量向量大小的變更"

#: src/main/connections.c:4727 src/main/connections.c:4731
#: src/main/connections.c:4778
msgid "invalid UTF-8 input in readChar()"
msgstr "readChar() 的 UTF-8 輸入無效"

#: src/main/connections.c:4734 src/main/connections.c:4744
#, fuzzy
msgid "truncating string with embedded nuls"
msgstr "不允許以 \"bytes\" 編碼的翻譯字串"

#: src/main/connections.c:4845
msgid "can only read in bytes in a non-UTF-8 MBCS locale"
msgstr "在非 UTF-8 MBCS 語區中只能以位元組為單位讀取"

#: src/main/connections.c:4851 src/main/connections.c:4972
#, c-format
msgid "text connection used with %s(), results may be incorrect"
msgstr ""

#: src/main/connections.c:4923
msgid "'object' is too short"
msgstr "'object' 太短"

#: src/main/connections.c:4980
msgid "writeChar: more bytes requested than are in the string - will zero-pad"
msgstr "writeChar：要求的位元組比字串中的還多 - 將用零填補"

#: src/main/connections.c:5005
msgid ""
"writeChar: more characters requested than are in the string - will zero-pad"
msgstr "writeChar：字串的長度比需要的位元組數目短 - 將用零填補"

#: src/main/connections.c:5062
msgid "maximum number of pushback lines exceeded"
msgstr "推回的列數已超過最大值"

#: src/main/connections.c:5068 src/main/connections.c:5072
#: src/main/connections.c:5109 src/main/connections.c:5117
msgid "could not allocate space for pushback"
msgstr "無法為推回配置空間"

#: src/main/connections.c:5100
msgid "can only push back on open readable connections"
msgstr "只能推回已開啟的可讀連接"

#: src/main/connections.c:5102
msgid "can only push back on text-mode connections"
msgstr "只能推回文字狀態的連接"

#: src/main/connections.c:5166 src/main/connections.c:5236
msgid "sink stack is full"
msgstr "匯集堆疊已滿"

#: src/main/connections.c:5169
msgid "cannot switch output to stdin"
msgstr "無法將輸出轉往stdin"

#: src/main/connections.c:5196
msgid "no sink to remove"
msgstr "沒有可以除去的匯集"

#: src/main/connections.c:5319
msgid "there is no connection NA"
msgstr "沒有任何連接 NA"

#: src/main/connections.c:5321
#, c-format
msgid "there is no connection %d"
msgstr "沒有任何連接 %d"

#: src/main/connections.c:5472
msgid "method = \"wininet\" is only supported on Windows"
msgstr "method = \"wininet\" 只有 Windows 才支援"

#: src/main/connections.c:5539 src/modules/internet/internet.c:225
msgid "the 'internal' method of url() is defunct for http:// and ftp:// URLs"
msgstr ""

#: src/main/connections.c:5552
msgid ""
"file(\"\") only supports open = \"w+\" and open = \"w+b\": using the former"
msgstr "file(\"\") 只支援 open = \"w+\" 與 open = \"w+b\": 使用前者"

#: src/main/connections.c:5573
#, c-format
msgid "using 'raw = TRUE' because '%s' is a fifo or pipe"
msgstr ""

#: src/main/connections.c:5580
#, c-format
msgid "'raw = FALSE' but '%s' is not a regular file"
msgstr ""

#: src/main/connections.c:5624
msgid "URL scheme unsupported by this method"
msgstr "這個方法不支援網址方案"

#: src/main/connections.c:5721
msgid "file stream does not have gzip magic number"
msgstr "檔案串流沒有 gzip 魔術數字"

#: src/main/connections.c:5732
msgid "file stream does not have valid gzip header"
msgstr "檔案串流的 gzip 表頭無效"

#: src/main/connections.c:5797
msgid "writing error whilst flushing 'gzcon' connection"
msgstr "清除 'gzcon' 連接時寫入發生錯誤"

#: src/main/connections.c:5899
#, c-format
msgid "crc error %x %x\n"
msgstr "crc 錯誤 %x %x\n"

#: src/main/connections.c:5926
msgid "write error on 'gzcon' connection"
msgstr "'gzcon' 連接寫入發生錯誤"

#: src/main/connections.c:5961
msgid "'level' must be one of 0 ... 9"
msgstr "'level' 必須是 0...9 之一"

#: src/main/connections.c:5964
msgid "'allowNonCompression' must be TRUE or FALSE"
msgstr "'allowNonCompression' 的值必須是 TRUE 或是 FALSE"

#: src/main/connections.c:5967
msgid "'text' must be TRUE or FALSE"
msgstr "'text' 必須是 TRUE 或 FALSE"

#: src/main/connections.c:5970
msgid "this is already a 'gzcon' connection"
msgstr "這已經是 gzcon 連接"

#: src/main/connections.c:5976
msgid "can only use read- or write- binary connections"
msgstr "只用讀或寫的二元連接"

#: src/main/connections.c:5979
msgid "using a text-mode 'file' connection may not work correctly"
msgstr "使用某個文字模式 'file' 連接可能不會正確作用"

#: src/main/connections.c:5982
msgid ""
"cannot create a 'gzcon' connection from a writable textConnection; maybe use "
"rawConnection"
msgstr "無法從可寫入的 textConnection 建立 gzcon 連接；也許使用 rawConnection"

#: src/main/connections.c:5985 src/main/connections.c:5989
#: src/main/connections.c:5997 src/main/connections.c:6012
msgid "allocation of 'gzcon' connection failed"
msgstr "配置 'gzcon' 連接失敗"

#: src/main/connections.c:6201
msgid "not a list of sockets"
msgstr "非承接座串列"

#: src/main/connections.c:6206
msgid "bad write indicators"
msgstr "寫入指示器不正確"

#: src/main/connections.c:6228
#, fuzzy
msgid "a server socket connection cannot be writeable"
msgstr "無法載入承接座常式"

#: src/main/connections.c:6230
msgid "not a socket connection"
msgstr "非承接座連接"

#: src/main/connections.c:6523
msgid "unknown compression, assuming none"
msgstr "不明壓縮，假設為沒有"

#: src/main/connections.c:6688 src/main/connections.c:6692
#: src/main/connections.c:6699
#, c-format
msgid "allocation of %s connection failed"
msgstr "%s 連接的配置失敗"

#: src/main/context.c:339
msgid "no loop for break/next, jumping to top level"
msgstr "沒有可中斷/下一個的迴圈，跳到頂層"

#: src/main/context.c:347
msgid "no function to return from, jumping to top level"
msgstr "沒有可回返的函式, 跳到最高層"

#: src/main/context.c:362
msgid "target context is not on the stack"
msgstr "目的上下文不在堆疊上"

#: src/main/context.c:377
msgid "NA argument is invalid"
msgstr "NA 引數無效"

#: src/main/context.c:385 src/main/context.c:400 src/main/context.c:483
#: src/main/context.c:495 src/main/context.c:506 src/main/context.c:518
msgid "not that many frames on the stack"
msgstr "堆疊上沒有這麼多的框格"

#: src/main/context.c:417
msgid "only positive values of 'n' are allowed"
msgstr "'n' 只允許是正數"

#: src/main/context.c:556
msgid "number of contexts must be positive"
msgstr "狀態組合數量必須是正值"

#: src/main/context.c:569
msgid "no browser context to query"
msgstr "無瀏覽器狀態組合到查詢"

#: src/main/context.c:587
msgid "not that many calls to browser are active"
msgstr "無法有那麼多對於瀏覽器的呼叫作用中"

#: src/main/context.c:602
msgid "not that many functions on the call stack"
msgstr "無法有那麼多函式在呼叫堆疊之上"

#: src/main/context.c:606
msgid "debug flag in compiled function has no effect"
msgstr "已編譯函式中的除錯旗標沒有作用"

#: src/main/context.c:608
msgid "debug will apply when function leaves compiled code"
msgstr "函式離開已編譯碼時才會套用除錯"

#: src/main/context.c:699
msgid "internal error in 'do_sys'"
msgstr "'do_sys' 發生內部錯誤"

#: src/main/cum.c:48
msgid "integer overflow in 'cumsum'; use 'cumsum(as.numeric(.))'"
msgstr "'cumsum' 中的整數溢位；使用 'cumsum(as.numeric(.))'"

#: src/main/cum.c:175
msgid "'cummax' not defined for complex numbers"
msgstr "cummax 不能用於複數"

#: src/main/cum.c:178
msgid "'cummin' not defined for complex numbers"
msgstr "cummin 不能用於複數"

#: src/main/cum.c:205 src/main/cum.c:232
msgid "unknown cumxxx function"
msgstr "不明的 cumxxx 功能"

#: src/main/datetime.c:552 src/main/datetime.c:560 src/main/datetime.c:574
#: src/main/datetime.c:579
msgid "problem with setting timezone"
msgstr "設定時區時發生問題"

#: src/main/datetime.c:564
msgid "cannot set timezones on this system"
msgstr "無法為本系統設定時區"

#: src/main/datetime.c:586 src/main/datetime.c:588
msgid "problem with unsetting timezone"
msgstr "解除設定時區發生問題"

#: src/main/datetime.c:809 src/main/datetime.c:812 src/main/datetime.c:912
#: src/main/datetime.c:1272 src/main/datetime.c:1275
#, c-format
msgid "zero-length component [[%d]] in non-empty \"POSIXlt\" structure"
msgstr "非空的 POSIXlt 結構內含長度為零的成分 [[%d]]"

#: src/main/datetime.c:924
msgid "invalid component [[10]] in \"POSIXlt\" should be 'zone'"
msgstr "POSIXlt 中的無效成分 [[10]] 應為 'zone'"

#: src/main/datetime.c:927
#, fuzzy
msgid "More than 9 list components in \"POSIXlt\" without timezone"
msgstr "POSIXlt 中的無效成分 [[10]] 應為 'zone'"

#: src/main/datetime.c:952
msgid "Timezone specified in the object field cannot be used on this system."
msgstr ""

#: src/main/dcf.c:112 src/main/dcf.c:187 src/main/dcf.c:268
msgid "could not allocate memory for 'read.dcf'"
msgstr "無法為 'read.dcf' 配置記憶體"

#: src/main/dcf.c:158
#, c-format
msgid "Found continuation line starting '%s ...' at begin of record."
msgstr "於記錄開始找到起始 '%s…' 的連續列。"

#: src/main/dcf.c:297
#, c-format
msgid "Line starting '%s ...' is malformed!"
msgstr "起始 '%s…' 的列異常！"

#: src/main/debug.c:46 src/main/debug.c:76
msgid "argument must be a function"
msgstr "引數必須是個函式"

#: src/main/debug.c:111
#, c-format
msgid "Value for '%s' must be TRUE or FALSE"
msgstr "'%s' 的值必須是 TRUE 或 FALSE"

#: src/main/debug.c:139 src/main/debug.c:167 src/main/debug.c:242
msgid "argument must not be a function"
msgstr "引數必須不是函式"

#: src/main/debug.c:142
msgid "cannot trace NULL"
msgstr "無法追蹤空值"

#: src/main/debug.c:146
msgid "'tracemem' is not useful for promise and environment objects"
msgstr "'tracemem' 對於約定和環境物件不太有用"

#: src/main/debug.c:149
msgid "'tracemem' is not useful for weak reference or external pointer objects"
msgstr "'tracemem' 對於弱型參考或外部指標物件不太有用"

#: src/main/debug.c:180 src/main/debug.c:187
msgid "R was not compiled with support for memory profiling"
msgstr "R 未被編譯以支援記憶體側寫"

#: src/main/deparse.c:176
msgid "invalid 'cutoff' value for 'deparse', using default"
msgstr "deparse的 'cutoff' 值無效，用預設值"

#: src/main/deparse.c:305
msgid "deparse may be incomplete"
msgstr "反解析可能不完整"

#: src/main/deparse.c:308
msgid "deparse may be not be source()able in R < 2.7.0"
msgstr "反解析也許無法在 R < 2.7.0 中進行 source()"

#: src/main/deparse.c:396 src/main/deparse.c:441 src/main/source.c:203
msgid "'file' must be a character string or connection"
msgstr "'file' 必須是字串或連接"

#: src/main/deparse.c:420 src/main/deparse.c:516 src/main/deparse.c:522
msgid "wrote too few characters"
msgstr "寫入的字元不足"

#: src/main/deparse.c:443
msgid "character arguments expected"
msgstr "需要字元引數"

#: src/main/deparse.c:446
msgid "zero-length argument"
msgstr "引數長度為零"

#: src/main/deparse.c:453
msgid "'opts' should be small non-negative integer"
msgstr "'opts' 應該是小的非負值整數"

#: src/main/deparse.c:463 src/main/envir.c:2017 src/main/envir.c:2129
#: src/main/envir.c:3825 src/main/eval.c:758 src/main/eval.c:2127
#: src/main/eval.c:5150 src/main/saveload.c:2082 src/main/saveload.c:2417
#: src/main/serialize.c:3128
#, c-format
msgid "object '%s' not found"
msgstr "找不到物件 '%s'"

#: src/main/deparse.c:1901
msgid "badly formed function expression"
msgstr "不當形式的函式敘述"

#: src/main/devices.c:44
msgid "the base graphics system is not registered"
msgstr "基本繪圖系統未登記"

#: src/main/devices.c:166 src/main/devices.c:174
msgid "no active or default device"
msgstr "沒有在使用中的或預設的裝置"

#: src/main/devices.c:176
msgid "no active device and default getOption(\"device\") is invalid"
msgstr "沒有在使用中的裝置，而預設的 getOption(\"device\") 無效"

#: src/main/devices.c:390 src/main/devices.c:452
msgid "too many open devices"
msgstr "太多已經開啟的裝置"

#: src/main/devices.c:493
msgid "not enough memory to allocate device (in GEcreateDevDesc)"
msgstr "所需記憶體不足以配置裝置 (在 GEcreateDevDesc 中)"

#: src/main/devices.c:545
msgid "Hit <Return> to see next plot: "
msgstr "按 <return> 鍵來看下一張圖: "

#: src/main/dotcode.c:127 src/main/dotcode.c:157
msgid "NULL value passed as symbol address"
msgstr "NULL 值被當作符號位址"

#: src/main/dotcode.c:148
#, c-format
msgid "Unimplemented type %d in createRSymbolObject"
msgstr "createRSymbolObject 中的類型 %d 尚未被實作"

#: src/main/dotcode.c:162 src/main/dotcode.c:260
#, c-format
msgid "symbol '%s' is too long"
msgstr "符號 '%s' 太長"

#: src/main/dotcode.c:174
msgid ""
"first argument must be a string (of length 1) or native symbol reference"
msgstr "第一個引數必須是字串 (長度為 1) 或是原生符號參照"

#: src/main/dotcode.c:224 src/main/dotcode.c:1272
msgid "too many arguments in foreign function call"
msgstr "外接函式呼叫時引數太多"

#: src/main/dotcode.c:236
msgid "PACKAGE = \"\" is invalid"
msgstr "PACKAGE = \"\" 無效"

#: src/main/dotcode.c:292 src/main/dotcode.c:297 src/main/dotcode.c:302
#: src/main/dotcode.c:307
#, c-format
msgid "\"%s\" not available for %s() for package \"%s\""
msgstr "\"%1$s\" 無法於套件 \"%3$s\" 的 %2$s() 中使用"

#: src/main/dotcode.c:312
#, c-format
msgid "%s symbol name \"%s\" not in DLL for package \"%s\""
msgstr "套件 \"%3$s\" 的 DLL 中沒有 %1$s 的符號名稱 \"%2$s\""

#: src/main/dotcode.c:317
#, c-format
msgid "%s symbol name \"%s\" not in load table"
msgstr "載入表中沒有 %s 的符號名稱 \"%s\""

#: src/main/dotcode.c:368 src/main/dotcode.c:370 src/main/dotcode.c:380
#: src/main/dotcode.c:445 src/main/dotcode.c:452
#, c-format
msgid "'%s' used more than once"
msgstr "'%s' 被使用超過一次"

#: src/main/dotcode.c:376
msgid "DLL name is too long"
msgstr "DLL 的名稱太長"

#: src/main/dotcode.c:421
msgid "PACKAGE argument must be a single character string"
msgstr "PACKAGE 引數必須是單字串"

#: src/main/dotcode.c:427
msgid "PACKAGE argument is too long"
msgstr "PACKAGE 引數太長"

#: src/main/dotcode.c:492
msgid "no arguments supplied"
msgstr "沒有提供引數"

#: src/main/dotcode.c:493 src/main/seq.c:1043
msgid "too many arguments"
msgstr "引數太多"

#: src/main/dotcode.c:554 src/main/dotcode.c:1264 src/main/dotcode.c:1519
msgid "'.NAME' is missing"
msgstr "缺少 '.NAME'"

#: src/main/dotcode.c:563 src/main/dotcode.c:1279 src/main/dotcode.c:1540
#, c-format
msgid "Incorrect number of arguments (%d), expecting %d for '%s'"
msgstr "不正確的引數數量 (%d)，預期為 %d 用於 '%s'"

#: src/main/dotcode.c:1247 src/main/dotcode.c:2390
msgid "too many arguments, sorry"
msgstr "對不起，引數太多"

#: src/main/dotcode.c:1367 src/main/dotcode.c:1398 src/main/engine.c:3270
msgid "invalid graphics state"
msgstr "繪圖狀態無效"

#: src/main/dotcode.c:1480
msgid "NULL value for DLLInfoReference when looking for DLL"
msgstr "尋找 DLL 時 DLLInfoReference 的值是 NULL"

#: src/main/dotcode.c:1579
#, c-format
msgid "wrong type for argument %d in call to %s"
msgstr "呼叫 %2$s 時引數 %1$d 的類型不正確"

#: src/main/dotcode.c:1608
#, c-format
msgid "long vectors (argument %d) are not supported in %s"
msgstr "長整數向量 (引數 %d) 於平臺 %s 不支援"

#: src/main/dotcode.c:1639
#, c-format
msgid "NAs in foreign function call (arg %d)"
msgstr "外部函式呼叫時不能有 NA (引數 %d)"

#: src/main/dotcode.c:1662
#, c-format
msgid "NA/NaN/Inf in foreign function call (arg %d)"
msgstr "外部函式呼叫時不能有 NA/NaN/Inf (引數 %d)"

#: src/main/dotcode.c:1692
#, c-format
msgid "complex NA/NaN/Inf in foreign function call (arg %d)"
msgstr "外部函式呼叫時不能有複數的 NA/NaN/Inf (引數 %d)"

#: src/main/dotcode.c:1759 src/main/dotcode.c:1775 src/main/dotcode.c:1786
#, c-format
msgid "invalid mode (%s) to pass to Fortran (arg %d)"
msgstr "傳給 Fortran 的狀態 (%s) 無效 (引數 %d)"

#: src/main/dotcode.c:1780
#, c-format
msgid "invalid mode (%s) to pass to C or Fortran (arg %d)"
msgstr "傳給 C 或 Fortran 的狀態 (%s) 無效 (引數 %d)"

#: src/main/dotcode.c:1791
msgid "pairlists are passed as SEXP as from R 2.15.0"
msgstr "從 R 2.15.0 開始，成對串列做為 SEXP 傳遞"

#: src/main/dotcode.c:2606
#, c-format
msgid "type \"%s\" not supported in interlanguage calls"
msgstr "語言間呼叫不支援此一類型 \"%s\""

#: src/main/dotcode.c:2711
#, c-format
msgid "mode '%s' is not supported in call_R"
msgstr "call_R 不支援 '%s' 型式"

#: src/main/dounzip.c:172
#, c-format
msgid " not overwriting file '%s"
msgstr " 無法覆寫檔案 '%s"

#: src/main/dounzip.c:262
#, c-format
msgid "zip file '%s' cannot be opened"
msgstr "zip 檔案 '%s' 無法開啟"

#: src/main/dounzip.c:324
msgid "invalid zip name argument"
msgstr "zip 名稱引數無效"

#: src/main/dounzip.c:327 src/main/dounzip.c:419
msgid "zip path is too long"
msgstr "zip 路徑太長"

#: src/main/dounzip.c:344
msgid "'exdir' is too long"
msgstr "'exdir' 太長"

#: src/main/dounzip.c:347
msgid "'exdir' does not exist"
msgstr "'exdir' 不存在"

#: src/main/dounzip.c:372
msgid "requested file not found in the zip file"
msgstr "您所要求的檔案在 zip 檔案中沒有"

#: src/main/dounzip.c:375
msgid "zip file is corrupt"
msgstr "zip 檔案有損壞"

#: src/main/dounzip.c:378
msgid "CRC error in zip file"
msgstr "zip 檔案出現 CRC 錯誤"

#: src/main/dounzip.c:385
msgid "write error in extracting from zip file"
msgstr "抽取 zip 檔案時出了寫入錯誤"

#: src/main/dounzip.c:388
#, c-format
msgid "error %d in extracting from zip file"
msgstr "從 zip 檔案中解開 %d 時發生錯誤"

#: src/main/dounzip.c:414
msgid "unz connections can only be opened for reading"
msgstr "unz 連接可讀不可寫"

#: src/main/dounzip.c:425
msgid "invalid description of 'unz' connection"
msgstr "unz 連接的描述無效"

#: src/main/dounzip.c:431
#, c-format
msgid "cannot open zip file '%s'"
msgstr "無法開啟 zip 檔案 '%s'"

#: src/main/dounzip.c:435
#, c-format
msgid "cannot locate file '%s' in zip file '%s'"
msgstr "找不到在 zip 檔案 '%2$s' 中的 %1$s 檔案"

#: src/main/dounzip.c:480
msgid "printing not enabled for this connection"
msgstr "此連接無法列印"

#: src/main/dounzip.c:486
msgid "write not enabled for this connection"
msgstr "無法寫入這個連接"

#: src/main/dounzip.c:504 src/main/dounzip.c:508 src/main/dounzip.c:515
#: src/main/dounzip.c:533
msgid "allocation of 'unz' connection failed"
msgstr "配置 unz 連接失敗"

#: src/main/dstruct.c:90
msgid "invalid formal arguments for 'function'"
msgstr "無效的形式引數用於 'function'"

#: src/main/dstruct.c:100
msgid "invalid body argument for 'function'"
msgstr "無效的主體引數用於 'function'"

#: src/main/edit.c:111
msgid "invalid argument to edit()"
msgstr "edit() 引數無效"

#: src/main/edit.c:122 src/main/saveload.c:2180
msgid "unable to open file"
msgstr "無法開啟檔案"

#: src/main/edit.c:135
msgid "argument 'editor' type not valid"
msgstr "引數 'editor' 的類型無效"

#: src/main/edit.c:137
msgid "argument 'editor' is not set"
msgstr "引數 'editor' 還沒有被設定"

#: src/main/edit.c:142
msgid "'title' must be a string"
msgstr "'title' 必須是字串"

#: src/main/edit.c:160
#, c-format
msgid "unable to run editor '%s'"
msgstr "無法啟動編輯器 '%s'"

#: src/main/edit.c:162
msgid "editor ran but returned error status"
msgstr "啟動了編輯器但回傳錯誤狀態"

#: src/main/edit.c:172
#, c-format
msgid "problem with running editor %s"
msgstr "啟動編輯器 %s 時出了問題"

#: src/main/edit.c:190
msgid "unable to open file to read"
msgstr "無法開啟檔案來讀取資料"

#: src/main/edit.c:197
#, c-format
msgid ""
"%s occurred on line %d\n"
" use a command like\n"
" x <- edit()\n"
" to recover"
msgstr ""
"%s 發生於第 %d 列\n"
"請使用命令類似\n"
"x <- edit()\n"
"以回復原來狀態"

#: src/main/engine.c:41
msgid "Graphics API version mismatch"
msgstr "繪圖 API 版本不相符"

#: src/main/engine.c:114 src/main/engine.c:119 src/main/engine.c:183
msgid "unable to allocate memory (in GEregister)"
msgstr "無法配置記憶體 (於 GEregister)"

#: src/main/engine.c:154
msgid "too many graphics systems registered"
msgstr "登記了太多的繪圖系統"

#: src/main/engine.c:207
msgid "no graphics system to unregister"
msgstr "沒有可以取消登記的繪圖系統"

#: src/main/engine.c:444 src/main/engine.c:449 src/main/engine.c:457
#: src/main/engine.c:464 src/main/engine.c:478 src/modules/X11/devX11.c:1166
msgid "invalid line end"
msgstr "線條終點發生錯誤"

#: src/main/engine.c:509 src/main/engine.c:514 src/main/engine.c:522
#: src/main/engine.c:529 src/main/engine.c:543 src/modules/X11/devX11.c:1184
msgid "invalid line join"
msgstr "線條接合發生錯誤"

#: src/main/engine.c:775 src/main/engine.c:884 src/main/engine.c:1230
#: src/main/engine.c:1340 src/main/engine.c:1452 src/main/engine.c:1506
msgid "'lwd' must be non-negative and finite"
msgstr "'lwd' 必須是有限的正整數"

#: src/main/engine.c:817
msgid "out of memory while clipping polyline"
msgstr "剪裁多邊形的時候記憶體不足"

#: src/main/engine.c:1113
msgid "Clipping polygon that does not need clipping"
msgstr ""

#: src/main/engine.c:1500
msgid "path rendering is not implemented for this device"
msgstr "路徑潤算尚未於這個裝置上實作"

#: src/main/engine.c:1520
msgid "Invalid graphics path"
msgstr "無效的圖形路徑"

#: src/main/engine.c:1539
msgid "raster rendering is not implemented for this device"
msgstr "柵格潤算尚未於這個裝置上實作"

#: src/main/engine.c:1563
msgid "raster capture is not available for this device"
msgstr "柵格擷取於這個裝置上無法使用"

#: src/main/engine.c:1782
#, c-format
msgid "font face %d not supported for font family '%s'"
msgstr "字模家族 '%2$s' 中沒有字模 %1$d"

#: src/main/engine.c:2102
msgid "no graphics device is active"
msgstr "沒有作用中的繪圖裝置"

#: src/main/engine.c:2179
#, c-format
msgid "pch value '%d' is invalid in this locale"
msgstr "pch 值 '%d' 在這個語區中無效"

#: src/main/engine.c:2437
#, c-format
msgid "unimplemented pch value '%d'"
msgstr "尚未實作pch '%d' 的值"

#: src/main/engine.c:2454
#, c-format
msgid "invalid axis extents [GEPretty(.,.,n=%d)"
msgstr "座標範圍無效 [GEPretty(.,.,n=%d)"

#: src/main/engine.c:2456
#, fuzzy, c-format
msgid "non-finite axis extents [GEPretty(%g,%g, n=%d)]"
msgstr "無限的座標範圍值 [GEPretty(%g,%g,%d)]"

#: src/main/engine.c:2499
#, fuzzy, c-format
msgid " new *lo = %g < %g = x1"
msgstr " .. GEPretty(.): new *lo =%g <%g = x1"

#: src/main/engine.c:2501
#, fuzzy, c-format
msgid " new *up = %g > %g = x2"
msgstr " .. GEPretty(.): new *up =%g >%g = x2"

#: src/main/engine.c:3021
msgid "display list redraw incomplete"
msgstr "顯示串列重新整理時不完整"

#: src/main/engine.c:3025
msgid "invalid display list"
msgstr "顯示串列無效"

#: src/main/engine.c:3137
#, c-format
msgid ""
"snapshot recorded with different graphics engine version (pre 11 - this is "
"version %d)"
msgstr "依不同繪圖引擎版本 (pre 11 - 表示版本 %d) 所記錄的快照"

#: src/main/engine.c:3141
#, c-format
msgid ""
"snapshot recorded with different graphics engine version (%d - this is "
"version %d)"
msgstr "依不同繪圖引擎版本 (%d - 表示版本 %d) 所記錄的快照"

#: src/main/engine.c:3230
msgid "'expr' argument must be an expression"
msgstr "'expr' 引數必須是運算式"

#: src/main/engine.c:3232
msgid "'list' argument must be a list"
msgstr "'list' 引數必須是串列"

#: src/main/engine.c:3238
msgid "'env' argument must be an environment"
msgstr "'env' 引數必須是環境物件"

#: src/main/engine.c:3337 src/main/engine.c:3345
msgid "invalid multibyte char in pch=\"c\""
msgstr "pch=\"c\" 中的多位元組字元無效"

#: src/main/engine.c:3392
msgid "invalid hex digit in 'color' or 'lty'"
msgstr "十六進位 'color' 設定或 'lty' 設定無效"

#: src/main/engine.c:3415
msgid "invalid line type: must be length 2, 4, 6 or 8"
msgstr "無效的列類型: 長度必須是 2, 4, 6 或 8"

#: src/main/engine.c:3419
msgid "invalid line type: zeroes are not allowed"
msgstr "無效的線條類型：不允許多個零"

#: src/main/engine.c:3428 src/main/engine.c:3436 src/main/engine.c:3443
msgid "invalid line type"
msgstr "無效的列類型"

#: src/main/engine.c:3790
msgid "Stroke ignored (device is appending path)"
msgstr ""

#: src/main/engine.c:3802
msgid "Fill ignored (device is appending path)"
msgstr ""

#: src/main/engine.c:3814
msgid "FillStroke ignored (device is appending path)"
msgstr ""

#: src/main/envir.c:130 src/main/envir.c:144
#, c-format
msgid "cannot change value of locked binding for '%s'"
msgstr "無法變更用於 '%s' 的鎖定繫結值"

#: src/main/envir.c:267 src/main/envir.c:1658
msgid "cannot add bindings to a locked environment"
msgstr "無法給鎖定環境加上繫結"

#: src/main/envir.c:836
msgid "cannot unbind in the base namespace"
msgstr "無法在基本命名空間中切斷繫結"

#: src/main/envir.c:838
msgid "unbind in the base environment is unimplemented"
msgstr "尚未實作在基本環境中解除繫結"

#: src/main/envir.c:840 src/main/envir.c:1946 src/main/envir.c:3602
msgid "cannot remove bindings from a locked environment"
msgstr "無法從鎖定的環境中刪除繫結"

#: src/main/envir.c:1227 src/main/envir.c:1260 src/main/envir.c:2030
#, c-format
msgid "argument to '%s' is not an environment"
msgstr "用於 '%s' 的引數不是環境物件"

#: src/main/envir.c:1418
#, c-format
msgid "indexing '...' with non-positive index %d"
msgstr "以非正值索引 %d 為 '...' 製作索引"

#: src/main/envir.c:1427
#, fuzzy, c-format
msgid "the ... list contains fewer than %d element"
msgid_plural "the ... list contains fewer than %d elements"
msgstr[0] "... 串列不包含 %d 個元素"

#: src/main/envir.c:1431
#, c-format
msgid "..%d used in an incorrect context, no ... to look in"
msgstr "..%d 所用的上下文發生錯誤, 找不到…"

#: src/main/envir.c:1450
#, fuzzy
msgid "indexing '...' with an invalid index"
msgstr "以非正值索引 %d 為 '...' 製作索引"

#: src/main/envir.c:1460 src/main/envir.c:1471
msgid "incorrect context: the current call has no '...' to look in"
msgstr "錯誤的上下文：目前的呼叫沒有 '...' 可查找"

#: src/main/envir.c:1590
#, c-format
msgid "could not find function \"%s\""
msgstr "沒有這個函式 \"%s\""

#: src/main/envir.c:1620
msgid "cannot assign values in the empty environment"
msgstr "無法在空環境中指派值"

#: src/main/envir.c:1626 src/main/envir.c:1756
msgid "cannot assign variables to this database"
msgstr "無法給這個資料庫指派變數"

#: src/main/envir.c:1840
#, c-format
msgid "cannot add binding of '%s' to the base environment"
msgstr "無法將繫結的 '%s' 加入基本環境"

#: src/main/envir.c:1869
msgid "only the first element is used as variable name"
msgstr "只用了第一個元素做為變數名"

#: src/main/envir.c:1901
msgid "first argument must be a named list"
msgstr "第一個引數必須是具名串列"

#: src/main/envir.c:1907
msgid "names(x) must be a character vector of the same length as x"
msgstr "names(x) 必須是與 x 相同長度的字元向量"

#: src/main/envir.c:1910
msgid "'envir' argument must be an environment"
msgstr "'envir' 引數必須是環境物件"

#: src/main/envir.c:1940
msgid "cannot remove variables from base namespace"
msgstr "無法從基本命名空間刪除變數"

#: src/main/envir.c:1942
msgid "cannot remove variables from the base environment"
msgstr "無法從基本環境移除變數"

#: src/main/envir.c:1944
msgid "cannot remove variables from the empty environment"
msgstr "無法從空環境中刪除變數"

#: src/main/envir.c:1952
msgid "cannot remove variables from this database"
msgstr "無法從這個資料庫中刪除變數"

#: src/main/envir.c:2033 src/main/envir.c:3361 src/main/envir.c:3382
#: src/main/envir.c:3403 src/main/envir.c:3440 src/main/envir.c:3461
#: src/main/envir.c:3508 src/main/envir.c:3598
msgid "not a symbol"
msgstr "不是符號"

#: src/main/envir.c:2072
#, fuzzy
msgid "first argument has length > 1"
msgstr "長度為 0 的引數"

#: src/main/envir.c:2131
#, c-format
msgid "object '%s' of mode '%s' was not found"
msgstr "找不到模式 '%2$s' 的物件 '%1$s'"

#: src/main/envir.c:2213
#, c-format
msgid "invalid name in position %d"
msgstr "在 %d 位置的名稱無效"

#: src/main/envir.c:2219
msgid "second argument must be an environment"
msgstr "第二引數必須是環境物件"

#: src/main/envir.c:2372
msgid "invalid use of 'missing'"
msgstr "無效的 'missing' 使用"

#: src/main/envir.c:2400
msgid "'missing' can only be used for arguments"
msgstr "'missing' 只能用做引數"

#: src/main/envir.c:2486
msgid "'pos' must be an integer"
msgstr "'pos' 必須是整數"

#: src/main/envir.c:2500
msgid "all elements of a list must be named"
msgstr "串列的所有元素都必須具名"

#: src/main/envir.c:2523
msgid "'attach' only works for lists, data frames and environments"
msgstr "'attach' 只作用於串列、資料框和環境"

#: src/main/envir.c:2606
msgid "detaching \"package:base\" is not allowed"
msgstr "\"package:base\" 不能被拆離"

#: src/main/envir.c:2951 src/main/envir.c:3033
msgid "argument must be an environment"
msgstr "引數必須是環境物件"

#: src/main/envir.c:3037
msgid "arguments must be symbolic"
msgstr "引數必須是符號"

#: src/main/envir.c:3182
msgid "no enclosing environment"
msgstr "沒有封閉的環境"

#: src/main/envir.c:3239
#, c-format
msgid "no item called \"%s\" on the search list"
msgstr "搜尋串列中沒有所謂的 \"%s\" 項目"

#: src/main/envir.c:3265
msgid "using 'as.environment(NULL)' is defunct"
msgstr "'as.environment(NULL)' 已廢止使用"

#: src/main/envir.c:3271
msgid "S4 object does not extend class \"environment\""
msgstr "S4 物件並不延伸類別 \"environment\""

#: src/main/envir.c:3286
msgid "invalid object for 'as.environment'"
msgstr "無效的物件用於 'as.environment'"

#: src/main/envir.c:3309 src/main/envir.c:3337 src/main/envir.c:3366
#: src/main/envir.c:3387 src/main/envir.c:3410 src/main/envir.c:3445
#: src/main/envir.c:3466 src/main/envir.c:3513
msgid "not an environment"
msgstr "不是環境物件"

#: src/main/envir.c:3374 src/main/envir.c:3395 src/main/envir.c:3453
#: src/main/envir.c:3474 src/main/envir.c:3517 src/main/envir.c:3526
#, c-format
msgid "no binding for \"%s\""
msgstr "沒有 \"%s\" 繫結"

#: src/main/envir.c:3405
msgid "not a function"
msgstr "不是函式"

#: src/main/envir.c:3413 src/main/envir.c:3429
msgid "symbol already has a regular binding"
msgstr "符號已經有了正式繫結"

#: src/main/envir.c:3415 src/main/envir.c:3431
msgid "cannot change active binding if binding is locked"
msgstr "如果繫結被鎖定就無法變更作用中繫結"

#: src/main/envir.c:3519 src/main/envir.c:3528
#, fuzzy, c-format
msgid "no active binding for \"%s\""
msgstr "沒有 \"%s\" 繫結"

#: src/main/envir.c:3548 src/main/envir.c:3810
msgid "unknown op"
msgstr "沒有這種運算子"

#: src/main/envir.c:3604
msgid "cannot unbind a locked binding"
msgstr "無法切斷已經鎖定的繫結"

#: src/main/envir.c:3606
msgid "cannot unbind an active binding"
msgstr "無法切斷正在使用中的繫結"

#: src/main/envir.c:3760
msgid "bad namespace name"
msgstr "不當的命名空間名稱"

#: src/main/envir.c:3772
msgid "namespace already registered"
msgstr "命名空間已註冊"

#: src/main/envir.c:3784
msgid "namespace not registered"
msgstr "命名空間尚未註冊"

#: src/main/envir.c:3845
#, fuzzy
msgid "bad variable name"
msgstr "不當的變數名稱"

#: src/main/envir.c:3887
#, fuzzy
msgid "bad namespace"
msgstr "不當的命名空間名稱"

#: src/main/envir.c:3923
#, c-format
msgid "'%s' is not an exported object from 'namespace:%s'"
msgstr ""

#: src/main/envir.c:3972
msgid "bad import environment argument"
msgstr "不當導入環境引數"

#: src/main/envir.c:3977
msgid "bad export environment argument"
msgstr "不當導出環境引數"

#: src/main/envir.c:3981
msgid "length of import and export names must match"
msgstr "導入和導出名稱的長度必須相等"

#: src/main/envir.c:4004
#, c-format
msgid "exported symbol '%s' has no value"
msgstr "導出的符號 '%s' 沒有值"

#: src/main/envir.c:4170
#, c-format
msgid "unknown encoding: %d"
msgstr "不明編碼：%d"

#: src/main/envir.c:4190
#, c-format
msgid "embedded nul in string: '%s'"
msgstr "空值嵌入於字串中：'%s'"

#: src/main/errors.c:212 src/main/errors.c:249
msgid "interrupts suspended; signal ignored"
msgstr "暫停被中斷; 信號忽略不用"

#: src/main/errors.c:367
msgid "[... truncated]"
msgstr "[... 已截斷]"

#: src/main/errors.c:454
msgid "invalid option \"warning.expression\""
msgstr "\"warning.expression\" 選項無效"

#: src/main/errors.c:484
#, c-format
msgid "(converted from warning) %s"
msgstr "(從警告轉換成) %s"

#: src/main/errors.c:495
msgid "Warning:"
msgstr "警告："

#: src/main/errors.c:497
#, c-format
msgid "Warning in %s :"
msgstr "%s 中的警告："

#: src/main/errors.c:506 src/main/errors.c:521 src/main/errors.c:868
msgid "Calls:"
msgstr "呼叫："

#: src/main/errors.c:568 src/main/errors.c:587 src/main/errors.c:764
msgid "Lost warning messages\n"
msgstr "警告訊息遺失\n"

#: src/main/errors.c:599
msgid "Warning message:"
msgid_plural "Warning messages:"
msgstr[0] "警告訊息："

#: src/main/errors.c:609 src/main/errors.c:637
#, c-format
msgid "In %s :"
msgstr "於 %s："

#: src/main/errors.c:662
#, c-format
msgid "There was %d warning (use warnings() to see it)"
msgid_plural "There were %d warnings (use warnings() to see them)"
msgstr[0] "共有 %d 個警告 (用 warnings() 來顯示)"

#: src/main/errors.c:667
#, c-format
msgid "There were %d or more warnings (use warnings() to see the first %d)"
msgstr "警告多於 %d 個 (用 warnings() 來顯示最先的 %d 個)"

#: src/main/errors.c:755
msgid "Error during wrapup: "
msgstr "收捲時發生錯誤: "

#: src/main/errors.c:766
msgid ""
"Error: no more error handlers available (recursive errors?); invoking "
"'abort' restart\n"
msgstr ""

#: src/main/errors.c:785
msgid "Error in "
msgstr "錯誤在"

#: src/main/errors.c:807 src/main/errors.c:814
#, c-format
msgid "Error in %s (from %s) : "
msgstr "錯誤發生於 %s (來自 %s)："

#: src/main/errors.c:816
#, c-format
msgid "Error in %s : "
msgstr "錯誤發生在 %s："

#: src/main/errors.c:839 src/main/errors.c:845
msgid "Error: "
msgstr "錯誤: "

#: src/main/errors.c:881 src/main/errors.c:1549
msgid "In addition: "
msgstr "此外: "

#: src/main/errors.c:1017
msgid "invalid option \"error\"\n"
msgstr "選項 \"error\" 無效\n"

#: src/main/errors.c:1286 src/main/errors.c:1288 src/main/options.c:406
#: src/main/unique.c:2155
#, c-format
msgid "'%s' must be a character string"
msgstr "'%s' 必須是字串"

#: src/main/errors.c:1362
msgid " [invalid string in stop(.)]"
msgstr " [stop(.) 中的字串無效]"

#: src/main/errors.c:1394
msgid " [invalid string in warning(.)]"
msgstr " [warning(.) 中的字串無效]"

#: src/main/errors.c:1410
#, c-format
msgid "incorrect number of arguments to \"%s\""
msgstr "\"%s\" 中的引數數目不正確"

#: src/main/errors.c:1416 src/main/errors.c:1431
#, c-format
msgid "unimplemented feature in %s"
msgstr "%s 中的功能尚未實作"

#: src/main/errors.c:1425
msgid "invalid number of arguments"
msgstr "引數數目無效"

#: src/main/errors.c:1426 src/main/logic.c:189
msgid "invalid argument type"
msgstr "引數類型無效"

#: src/main/errors.c:1428
msgid "time-series/vector length mismatch"
msgstr "時間序列/向量長度不等"

#: src/main/errors.c:1429
msgid "incompatible arguments"
msgstr "不相容的引數"

#: src/main/errors.c:1432
msgid "unknown error (report this!)"
msgstr "不明錯誤 (請通報!)"

#: src/main/errors.c:1441
msgid "inaccurate integer conversion in coercion"
msgstr "強制變更造成整數不精確"

#: src/main/errors.c:1444
msgid "unknown warning (report this!)"
msgstr "不明警告 (請通報!)"

#: src/main/errors.c:1519
msgid "No function to return from, jumping to top level"
msgstr "沒有可回返的函式, 跳到最高層"

#: src/main/errors.c:1535
msgid "top level inconsistency?"
msgstr "最高層不一致？"

#: src/main/errors.c:1791
msgid "bad handler data"
msgstr "不當的處理常式資料"

#: src/main/errors.c:1949
msgid "error message not a string"
msgstr "錯誤訊息不是字串"

#: src/main/errors.c:2031
msgid "handler or restart stack mismatch in old restart"
msgstr "舊重新啟動中的處理常式或重新啟動堆疊不符合"

#: src/main/errors.c:2054 src/main/errors.c:2067
msgid "bad error message"
msgstr "不當的錯誤訊息"

#: src/main/errors.c:2108
msgid "bad restart"
msgstr "不當的重新啟動"

#: src/main/errors.c:2140
msgid "restart not on stack"
msgstr "未在堆疊上重新啟動"

#: src/main/errors.c:2156
msgid "not in a try context"
msgstr "不在 try 的上下文中"

#: src/main/errors.c:2169
msgid "error message must be a character string"
msgstr "錯誤訊息必須是字串"

#: src/main/errors.c:2658
#, fuzzy
msgid "condition object must be a VECSXP of length at least one"
msgstr "'mode' 的長度必須是至少一個"

#: src/main/errors.c:2661
#, fuzzy
msgid "first element of condition object must be a scalar string"
msgstr "字串類別的替換物件無效"

#: src/main/errors.c:2776
msgid "protect(): protection stack overflow"
msgstr "protect()：防止堆疊向上溢位"

#: src/main/errors.c:2778
msgid ""
"evaluation nested too deeply: infinite recursion / options(expressions=)?"
msgstr "評估巢狀太深：無窮遞迴/選項(表示式=)?"

#: src/main/errors.c:2780
msgid "node stack overflow"
msgstr "節點堆疊向上溢位"

#: src/main/eval.c:393
#, c-format
msgid "source files skipped by Rprof; please increase '%s'"
msgstr "Rprof 跳過了原始碼檔案；請增加 '%s'"

#: src/main/eval.c:414
#, c-format
msgid "Rprof: cannot open profile file '%s'"
msgstr "Rprof: 打不開程式概要分析檔案 '%s'"

#: src/main/eval.c:528
msgid "R profiling is not available on this system"
msgstr "本系統沒有 R 程式概要分析這個功能"

#: src/main/eval.c:552
msgid ""
"promise already under evaluation: recursive default argument reference or "
"earlier problems?"
msgstr "約定已進行求值：遞迴預設引數參考或是之前的問題？"

#: src/main/eval.c:557
msgid "restarting interrupted promise evaluation"
msgstr "重新啟動插斷的約定求值"

#: src/main/eval.c:764 src/main/eval.c:5142
msgid "argument is missing, with no default"
msgstr "缺少引數, 也沒有預設值"

#: src/main/eval.c:878 src/main/eval.c:1993 src/main/eval.c:7005
msgid "attempt to apply non-function"
msgstr "不適用於非函式"

#: src/main/eval.c:902
#, c-format
msgid "%s at %s#%d: "
msgstr "%s 於 %s#%d："

#: src/main/eval.c:1981 src/main/eval.c:3070
#, c-format
msgid "argument %d is empty"
msgstr "引數 %d 是空的"

#: src/main/eval.c:2037
#, c-format
msgid "could not find symbol \"%s\" in environment of the generic function"
msgstr "一般函式環境中沒有 \"%s\" 符號"

#: src/main/eval.c:2055
#, c-format
msgid "symbol \"%s\" not in environment of method"
msgstr "方法環境中沒有 \"%s\" 符號"

#: src/main/eval.c:2196
msgid "the condition has length > 1"
msgstr "條件的長度 > 1"

#: src/main/eval.c:2197
msgid "the condition has length > 1 and only the first element will be used"
msgstr "條件的長度 > 1，因此只能用其第一元素"

#: src/main/eval.c:2217
msgid "missing value where TRUE/FALSE needed"
msgstr "需要 TRUE/FALSE 值的地方有缺值"

#: src/main/eval.c:2218
msgid "argument is not interpretable as logical"
msgstr "引數無法解譯為邏輯值"

#: src/main/eval.c:2219
msgid "argument is of length zero"
msgstr "引數長度為零"

#: src/main/eval.c:2317
msgid "non-symbol loop variable"
msgstr "非符號循環變數"

#: src/main/eval.c:2410 src/main/eval.c:6705
msgid "invalid for() loop sequence"
msgstr "不當的 for() 循環序列"

#: src/main/eval.c:2559
msgid "multi-argument returns are not permitted"
msgstr "不允許多引數回傳"

#: src/main/eval.c:2607
msgid "invalid (NULL) left side of assignment"
msgstr "賦值公式左側是無效 (NULL) 值"

#: src/main/eval.c:2648
msgid "target of assignment expands to non-language object"
msgstr "賦值目標擴充到非語言的物件"

#: src/main/eval.c:2733
#, c-format
msgid "overlong name in '%s'"
msgstr "'%s' 中的名稱太長"

#: src/main/eval.c:2859
msgid "cannot do complex assignments in base namespace"
msgstr "無法在基本命名空間中賦予複數值"

#: src/main/eval.c:2861
msgid "cannot do complex assignments in base environment"
msgstr "無法在基本環境中賦予複數值"

#: src/main/eval.c:2904 src/main/eval.c:2931
msgid "invalid function in complex assignment"
msgstr "複數賦值中的函式無效"

#: src/main/eval.c:3002
msgid "invalid (do_set) left-hand side to assignment"
msgstr "(do_set) 賦值公式左側無效"

#: src/main/eval.c:3084
#, c-format
msgid "'%s' is missing"
msgstr "缺少 '%s'"

#: src/main/eval.c:3259
msgid "invalid formal argument list for \"function\""
msgstr "\"function\" 形式引數串列無效"

#: src/main/eval.c:3317 src/main/eval.c:3348 src/main/eval.c:3353
#, c-format
msgid "invalid '%s' argument of type '%s'"
msgstr "'%2$s' 類型的 '%1$s' 引數無效"

#: src/main/eval.c:3345
msgid "numeric 'envir' arg not of length one"
msgstr "數值 'envir' 引數的長度不是 1"

#: src/main/eval.c:3370 src/main/eval.c:3394
msgid "restarts not supported in 'eval'"
msgstr "'eval' 不支援重新啟動"

#: src/main/eval.c:3453 src/main/eval.c:3466
msgid "'Recall' called from outside a closure"
msgstr "'Recall' 從閉包外部呼叫"

#: src/main/eval.c:3560
msgid "value in '...' is not a promise"
msgstr "'...' 中的值不是一個約定"

#: src/main/eval.c:3829
#, c-format
msgid "Incompatible methods (\"%s\", \"%s\") for \"%s\""
msgstr "不相容的方法 (\"%s\", \"%s\") 用於 \"%s\""

#: src/main/eval.c:3879
msgid "dispatch error in group dispatch"
msgstr "群組派送時發生錯誤"

#: src/main/eval.c:4376
#, c-format
msgid "\"%s\" is not a %s function"
msgstr "\"%s\" 並非 %s 函式"

#: src/main/eval.c:4995
msgid "bad opcode"
msgstr "不當的操作代碼"

#: src/main/eval.c:6097
#, c-format
msgid "invalid %s type in 'x %s y'"
msgstr "'x %2$s y' 中無效的 %1$s 類型"

#: src/main/eval.c:6533
msgid "bytecode version mismatch; using eval"
msgstr "位元組碼版本不符；使用 eval"

#: src/main/eval.c:6539
msgid "bytecode version is too old"
msgstr "位元組碼版本太舊"

#: src/main/eval.c:6540
msgid "bytecode version is too new"
msgstr "位元組碼版本太新"

#: src/main/eval.c:6585
msgid "byte code version mismatch"
msgstr "位元組碼版本不符"

#: src/main/eval.c:6838
msgid "invalid sequence argument in for loop"
msgstr "迴圈中的序列引數無效"

#: src/main/eval.c:6994 src/main/names.c:1360
#, c-format
msgid "there is no .Internal function '%s'"
msgstr "沒有 \"%s\" 這個 .Internal 函式"

#: src/main/eval.c:7112 src/main/eval.c:7537 src/main/eval.c:7581
msgid "bad function"
msgstr "不當的函式"

#: src/main/eval.c:7125
msgid "not a BUILTIN function"
msgstr "非 BUILTIN 函式"

#: src/main/eval.c:7639
msgid "bad numeric 'switch' offsets"
msgstr "不當的數值 'switch' 偏移值"

#: src/main/eval.c:7645
msgid "numeric EXPR required for 'switch' without named alternatives"
msgstr "'switch' 需要數值 EXPR 而無需具名的替代方案"

#: src/main/eval.c:7649
msgid "bad character 'switch' offsets"
msgstr "不當的字元 'switch' 偏移值"

#: src/main/eval.c:7802
msgid "cannot find index for threaded code address"
msgstr "找不到執行緒程式碼位址的索引"

#: src/main/eval.c:8076
msgid "invalid body"
msgstr "無效的主體"

#: src/main/eval.c:8096
msgid "invalid symbol"
msgstr "符號無效"

#: src/main/eval.c:8140
msgid "argument is not a byte code object"
msgstr "引數不是位元組碼物件"

#: src/main/eval.c:8211 src/main/eval.c:8230 src/main/eval.c:8264
msgid "constant buffer must be a generic vector"
msgstr "常數緩衝區必須是個一般向量"

#: src/main/eval.c:8266
msgid "bad constant count"
msgstr "不當的常數計數"

#: src/main/eval.c:8304
msgid "profile timer in use"
msgstr "程式概要分析計時器在使用中"

#: src/main/eval.c:8306
msgid "already byte code profiling"
msgstr "已經在進行位元組碼程式概要分析"

#: src/main/eval.c:8326
msgid "setting profile timer failed"
msgstr "程式概要分析計時器設置失敗"

#: src/main/eval.c:8344
msgid "not byte code profiling"
msgstr "非位元組碼程式概要分析"

#: src/main/eval.c:8360 src/main/eval.c:8364 src/main/eval.c:8368
msgid "byte code profiling is not supported in this build"
msgstr "這個組建不支援位元組碼程式概要分析"

#: src/main/gevents.c:45
#, c-format
msgid "'%s' events not supported in this device"
msgstr "'%s' 事件在這個裝置中不支援"

#: src/main/gevents.c:69
msgid "internal error"
msgstr "內部錯誤"

#: src/main/gevents.c:76
msgid "this graphics device does not support event handling"
msgstr "這個圖形裝置不支援事件處理"

#: src/main/gevents.c:142
msgid "invalid prompt"
msgstr "提示無效"

#: src/main/gevents.c:153
msgid "recursive use of 'getGraphicsEvent' not supported"
msgstr "不支援 getGraphicsEvent 的遞迴使用"

#: src/main/gevents.c:164
msgid "no graphics event handlers set"
msgstr "沒有任何圖形事件處理常式被設定"

#: src/main/gram.y:299 src/main/gram.y:316 src/main/gram.y:2604
#: src/main/gram.y:2619
#, c-format
msgid "EOF whilst reading MBCS char at line %d"
msgstr "讀取 MBCS 字元於第 %d 列時遇到 EOF"

#: src/main/gram.y:305 src/main/gram.y:313 src/main/gram.y:632
#: src/main/gram.y:639 src/main/gram.y:715 src/main/gram.y:2609
#: src/main/gram.y:2616
#, c-format
msgid "invalid multibyte character in parser at line %d"
msgstr "在剖析器的第 %d 列中有無效的多位元組字元"

#: src/main/gram.y:551
#, c-format
msgid "input buffer overflow at line %d"
msgstr "輸入緩衝區溢位於第 %d 列"

#: src/main/gram.y:1180
msgid "The pipe operator requires a function call as RHS"
msgstr ""

#: src/main/gram.y:1199
#, fuzzy
msgid "RHS variable must be a symbol"
msgstr "引數必須是符號"

#: src/main/gram.y:1305
#, c-format
msgid "incorrect tag type at line %d"
msgstr "第 %d 列有不正確的標記類型"

#: src/main/gram.y:1480
#, fuzzy
msgid "allocation of source reference state failed"
msgstr "配置承接座連接失敗"

#: src/main/gram.y:1638
msgid "pipe bind symbol may only appear in pipe expressions"
msgstr ""

#: src/main/gram.y:1989
msgid "contextstack overflow"
msgstr "contextstack 溢位"

#: src/main/gram.y:2244 src/main/gram.y:2250
#, c-format
msgid "unexpected input"
msgstr "未預期的輸入"

#: src/main/gram.y:2247 src/main/main.c:319
#, c-format
msgid "unexpected end of input"
msgstr "未預期的輸入結束"

#: src/main/gram.y:2253
#, c-format
msgid "unexpected string constant"
msgstr "未預期的字串常數"

#: src/main/gram.y:2256
#, c-format
msgid "unexpected numeric constant"
msgstr "未預期的數值常數"

#: src/main/gram.y:2259
#, c-format
msgid "unexpected symbol"
msgstr "未預期的符號"

#: src/main/gram.y:2262
#, c-format
msgid "unexpected assignment"
msgstr "未預期的賦值"

#: src/main/gram.y:2265
#, c-format
msgid "unexpected end of line"
msgstr "未預期的列尾"

#: src/main/gram.y:2268 src/main/gram.y:2276
#, c-format
msgid "unexpected %s"
msgstr "未預期的 %s"

#: src/main/gram.y:2288
#, c-format
msgid "repeated formal argument '%s' on line %d"
msgstr "重複的形式引數 '%s' 於第 %d 列"

#: src/main/gram.y:2515
#, c-format
msgid "integer literal %s contains decimal; using numeric value"
msgstr "整數實字 %s 含有小數；使用數值"

#: src/main/gram.y:2518
#, c-format
msgid "non-integer value %s qualified with L; using numeric value"
msgstr "非整數值 %s 以 L 修飾過性質；使用數值"

#: src/main/gram.y:2530
#, c-format
msgid "integer literal %s contains unnecessary decimal point"
msgstr "整數實字 %s 含有非必要的小數點"

#: src/main/gram.y:2741 src/main/gram.y:2764 src/main/gram.y:2801
#: src/main/gram.y:2838
#, c-format
msgid "nul character not allowed (line %d)"
msgstr "不允許的空字元 (第 %d 列)"

#: src/main/gram.y:2757
#, c-format
msgid "'\\x' used without hex digits in character string starting \"%s\""
msgstr "在起始 \"%s\" 的字串中使用了 '\\x' 卻無十六進位數字"

#: src/main/gram.y:2773
#, c-format
msgid "\\uxxxx sequences not supported inside backticks (line %d)"
msgstr "在反引號內部不支援 \\uxxxx 序列 (第 %d 列)"

#: src/main/gram.y:2788
#, c-format
msgid "'\\u' used without hex digits in character string starting \"%s\""
msgstr "在起始 \"%s\" 的字串中使用了 '\\u' 卻無十六進位數字"

#: src/main/gram.y:2796
#, c-format
msgid "invalid \\u{xxxx} sequence (line %d)"
msgstr "無效的 \\u{xxxx} 序列 (第 %d 列)"

#: src/main/gram.y:2810
#, c-format
msgid "\\Uxxxxxxxx sequences not supported inside backticks (line %d)"
msgstr "在反引號內部不支援 \\Uxxxxxxxx 序列 (第 %d 列)"

#: src/main/gram.y:2825
#, c-format
msgid "'\\U' used without hex digits in character string starting \"%s\""
msgstr "在起始 \"%s\" 的字串中使用了 '\\U' 卻無十六進位數字"

#: src/main/gram.y:2833
#, c-format
msgid "invalid \\U{xxxxxxxx} sequence (line %d)"
msgstr "無效的 \\U{xxxxxxxx} 序列 (第 %d 列)"

#: src/main/gram.y:2842
#, fuzzy, c-format
msgid "invalid \\U{xxxxxxxx} value %6x (line %d)"
msgstr "無效的 \\U{xxxxxxxx} 序列 (第 %d 列)"

#: src/main/gram.y:2845
#, fuzzy, c-format
msgid "invalid \\Uxxxxxxxx value %6x (line %d)"
msgstr "無效的 \\U{xxxxxxxx} 序列 (第 %d 列)"

#: src/main/gram.y:2893
#, c-format
msgid "'\\%c' is an unrecognized escape in character string starting \"%s\""
msgstr "在起始 \"%2$s\" 的字串中 '\\%1$c' 是無法辨識的跳脫字元"

#: src/main/gram.y:2962 src/main/gram.y:3091
msgid "mixing Unicode and octal/hex escapes in a string is not allowed"
msgstr "不允許在字串中混合萬國碼和八進位/十六進位跳脫字元"

#: src/main/gram.y:2966 src/main/gram.y:3095
#, c-format
msgid ""
"string at line %d containing Unicode escapes not in this locale\n"
"is too long (max 10000 chars)"
msgstr ""
"第 %d 列的字串包含不存在這個語區的萬國碼跳脫字元\n"
"長度太長 (最大 10000 字元)"

#: src/main/gram.y:3002
#, c-format
msgid "malformed raw string literal at line %d"
msgstr ""

#: src/main/gram.y:3720 src/main/gram.y:3727 src/main/gram.y:3733
#: src/main/gram.y:3740
#, c-format
msgid "contextstack overflow at line %d"
msgstr "contextstack 於第 %d 列溢位"

#: src/main/gram.y:3830
#, c-format
msgid "internal parser error at line %d"
msgstr "內部解析錯誤於第 %d 列"

#: src/main/graphics.c:95
#, c-format
msgid ""
"axis(%d, *): range of values (%5.2g) is small wrt |M| = %7.2g --> not "
"pretty()"
msgstr ""

#: src/main/grep.c:152
#, fuzzy, c-format
msgid "TRE pattern compilation error '%s'"
msgstr ""
"PCRE 胚騰編譯錯誤\n"
"\t'%s'\n"
"\t於 '%s'\n"

#: src/main/grep.c:153
#, c-format
msgid "invalid regular expression '%s', reason '%s'"
msgstr "無效的正規表示式 '%s' ，原因是 '%s'"

#: src/main/grep.c:155
#, c-format
msgid "invalid regular expression, reason '%s'"
msgstr "無效的正規表示式，原因是 '%s'"

#: src/main/grep.c:193
#, c-format
msgid ""
"PCRE error\n"
"\t'%s'\n"
"\tfor element %d"
msgstr ""

#: src/main/grep.c:374 src/main/grep.c:446
#, c-format
msgid ""
"PCRE pattern compilation error\n"
"\t'%s'\n"
"\tat '%s'\n"
msgstr ""
"PCRE 胚騰編譯錯誤\n"
"\t'%s'\n"
"\t於 '%s'\n"

#: src/main/grep.c:376 src/main/grep.c:449
#, c-format
msgid "invalid regular expression '%s'"
msgstr "正規表示式 '%s' 無效"

#: src/main/grep.c:388
#, fuzzy, c-format
msgid ""
"PCRE JIT compilation error\n"
"\t'%s'"
msgstr ""
"PCRE 胚騰編譯錯誤\n"
"\t'%s'\n"
"\t於 '%s'\n"

#: src/main/grep.c:457
#, c-format
msgid ""
"PCRE pattern study error\n"
"\t'%s'\n"
msgstr ""
"PCRE 胚騰檢查錯誤\n"
"\t'%s'\n"

#: src/main/grep.c:554 src/main/grep.c:651 src/main/grep.c:761
#: src/main/grep.c:1278 src/main/grep.c:2067 src/main/grep.c:2979
#, c-format
msgid "input string %d is invalid UTF-8"
msgstr "輸入字串 %d 是無效的 UTF-8"

#: src/main/grep.c:628 src/main/grep.c:725
#, c-format
msgid "'split' string %d is invalid UTF-8"
msgstr "'split' 字串 %d 是無效的 UTF-8"

#: src/main/grep.c:632 src/main/grep.c:729 src/main/grep.c:934
#, c-format
msgid "'split' string %d is invalid in this locale"
msgstr "'split' 字串 %d 在這個語區中無效"

#: src/main/grep.c:1237 src/main/grep.c:2873
msgid "regular expression is invalid UTF-8"
msgstr "正規表示式是無效的 UTF-8"

#: src/main/grep.c:1688
msgid "pattern matches an empty string infinitely, returning first match only"
msgstr "胚騰符合無限大的空字串，只回傳第一個符合者"

#: src/main/grep.c:2011
msgid "'pattern' is invalid UTF-8"
msgstr "'pattern' 是無效的 UTF-8"

#: src/main/grep.c:2013
msgid "'replacement' is invalid UTF-8"
msgstr "'replacement' 是無效的 UTF-8"

#: src/main/grep.c:2017
msgid "'pattern' is invalid in this locale"
msgstr "'pattern' 的值在本語區環境下無效"

#: src/main/grep.c:2020
msgid "'replacement' is invalid in this locale"
msgstr "'replacement' 的值在本語區環境下無效"

#: src/main/grep.c:2025
msgid "zero-length pattern"
msgstr "胚騰長度為零"

#: src/main/grep.c:2178 src/main/grep.c:2199 src/main/grep.c:2248
#: src/main/grep.c:2269 src/main/grep.c:2316 src/main/grep.c:2332
msgid "result string is too long"
msgstr "結果字串太長"

#: src/main/grep.c:2894
#, fuzzy, c-format
msgid "'pcre2_patterninfo' returned '%d' "
msgstr "pcre_fullinfo 已回傳 '%d' "

#: src/main/grep.c:2911
#, c-format
msgid "'pcre_fullinfo' returned '%d' "
msgstr "pcre_fullinfo 已回傳 '%d' "

#: src/main/identical.c:144
msgid "ignoring non-pairlist attributes"
msgstr "忽略非成對串列的屬性"

#: src/main/internet.c:67
msgid "internet routines cannot be accessed in module"
msgstr "無法讀寫模組中的網際網路常式"

#: src/main/internet.c:78 src/main/internet.c:91 src/main/internet.c:104
#: src/main/internet.c:115 src/main/internet.c:126 src/main/internet.c:136
#: src/main/internet.c:259 src/main/internet.c:271 src/main/internet.c:283
#: src/main/internet.c:295
msgid "internet routines cannot be loaded"
msgstr "無法載入網際網路常式"

#: src/main/internet.c:150 src/main/internet.c:169 src/main/internet.c:188
#: src/main/internet.c:200 src/main/internet.c:214 src/main/internet.c:234
#: src/main/internet.c:247
msgid "socket routines cannot be loaded"
msgstr "無法載入承接座常式"

#: src/main/internet.c:160
#, fuzzy
msgid "maxlen must be non-negative"
msgstr "'gap' 必須是正整數"

#: src/main/internet.c:183
msgid "attempt to close invalid socket"
msgstr "試圖關閉無效的承接座"

#: src/main/lapack.c:39
msgid "LAPACK routines cannot be accessed in module"
msgstr "模組中沒有此一 LAPACK 常式"

#: src/main/lapack.c:53
msgid "LAPACK routines cannot be loaded"
msgstr "無法載入 LAPACK 常式"

#: src/main/logic.c:79
msgid "operations are possible only for numeric, logical or complex types"
msgstr "運算只適用於數值、邏輯或複數類型"

#: src/main/logic.c:276
#, c-format
msgid "'%s' operator requires 2 arguments"
msgstr "'%s' 運算子需要兩個引數"

#: src/main/logic.c:283
#, c-format
msgid "invalid 'x' type in 'x %s y'"
msgstr "'x %s y' 中的 'x' 類型無效"

#: src/main/logic.c:292
#, c-format
msgid "invalid 'y' type in 'x %s y'"
msgstr "'x %s y' 中的 'y' 類型無效"

#: src/main/logic.c:370
msgid "Unary operator `!' called with two arguments"
msgstr "呼叫一元運算 '!' 時用了兩個引數"

#: src/main/logic.c:483
#, c-format
msgid "coercing argument of type '%s' to logical"
msgstr "強制變更 '%s' 類型的引數為邏輯類型"

#: src/main/main.c:49
msgid "dummy - do not translate"
msgstr "dummy - do not translate"

#: src/main/main.c:337
msgid "error during cleanup\n"
msgstr "清理時發生錯誤\n"

#: src/main/main.c:344
msgid "Execution halted\n"
msgstr "停止執行\n"

#: src/main/main.c:512
msgid "Error: segfault from C stack overflow\n"
msgstr "錯誤: C 堆疊向上溢位的區段錯誤\n"

#: src/main/main.c:958
msgid "unable to open the base package\n"
msgstr "無法開啟基本套件\n"

#: src/main/main.c:1042
#, c-format
msgid "unable to restore saved data in %s\n"
msgstr "無法還原儲存在 %s 中的資料\n"

#: src/main/main.c:1091
msgid "During startup - "
msgstr "於啟動期間 - "

#: src/main/main.c:1107
msgid "unable to initialize the JIT\n"
msgstr "無法初始化 JIT\n"

#: src/main/main.c:1380
msgid "cannot quit from browser"
msgstr "無法離開瀏覽器"

#: src/main/main.c:1384
msgid "one of \"yes\", \"no\", \"ask\" or \"default\" expected."
msgstr "只能用 \"yes\"、\"no\"、\"ask\" 或 \"default\" 中的一個。"

#: src/main/main.c:1389
msgid "save=\"ask\" in non-interactive use: command-line default will be used"
msgstr "save=\"ask\" 不能在非交互狀態時使用：改用命令列預設值"

#: src/main/main.c:1397
msgid "unrecognized value of 'save'"
msgstr "沒有這種 'save' 值"

#: src/main/main.c:1400
msgid "invalid 'status', 0 assumed"
msgstr "'status' 無效, 假定為 0"

#: src/main/main.c:1405
msgid "invalid 'runLast', FALSE assumed"
msgstr "'runLast' 無效, 假定為 FALSE"

#: src/main/main.c:1436
msgid "cannot allocate space for toplevel callback element"
msgstr "無法為最高層回呼元素配置空間"

#: src/main/main.c:1514
msgid "negative index passed to R_removeTaskCallbackByIndex"
msgstr "負的索引值被傳遞給 R_removeTaskCallbackByIndex"

#: src/main/main.c:1627
#, c-format
msgid "warning messages from top-level task callback '%s'\n"
msgstr "最高層任務回呼 '%s' 產生了警告訊息\n"

#: src/main/main.c:1718
msgid "top-level task callback did not return a logical value"
msgstr "最高層任務回呼沒回傳邏輯值"

#: src/main/mapply.c:84
#, fuzzy
msgid "argument 'MoreArgs' of 'mapply' is not a list or pairlist"
msgstr "'mapply' 的引數 'MoreArgs' 不是一個串列"

#: src/main/mapply.c:121
msgid "longer argument not a multiple of length of shorter"
msgstr "長引數長度不是短引數長度的整數倍"

#: src/main/match.c:88
msgid "invalid partial string match"
msgstr "部分字串比對無效"

#: src/main/match.c:231 src/main/match.c:274 src/main/objects.c:49
#: src/main/objects.c:59
#, c-format
msgid "formal argument \"%s\" matched by multiple actual arguments"
msgstr "形式引數 \"%s\" 有多個與之相對應的實際引數"

#: src/main/match.c:235 src/main/match.c:271
#, c-format
msgid "argument %d matches multiple formal arguments"
msgstr "引數 %d 有多個與之相對應的形式引數"

#: src/main/match.c:278
#, c-format
msgid "partial argument match of '%s' to '%s'"
msgstr "'%s' 的部分引數符合 '%s'"

#: src/main/match.c:375
#, c-format
msgid "unused argument %s"
msgid_plural "unused arguments %s"
msgstr[0] "未使用的引數 %s"

#: src/main/memory.c:1373
msgid "can only weakly reference/finalize reference objects"
msgstr "參考物件只能被弱型參考或被終了"

#: src/main/memory.c:1407
msgid "finalizer must be a function or NULL"
msgstr "終了程式必須是函式或 NULL"

#: src/main/memory.c:1463 src/main/memory.c:1471 src/main/memory.c:1482
msgid "not a weak reference"
msgstr "非弱型參考"

#: src/main/memory.c:1632
msgid "first argument must be environment or external pointer"
msgstr "第一引數必須是環境或外部指標"

#: src/main/memory.c:1634
msgid "second argument must be a function"
msgstr "第二引數必須是函式"

#: src/main/memory.c:1638
msgid "third argument must be 'TRUE' or 'FALSE'"
msgstr "第三引數的值必須是 'TRUE' 或 'FALSE'"

#: src/main/memory.c:2138
msgid "vector memory exhausted (limit reached?)"
msgstr "向量記憶體已用完 (達到了極值?)"

#: src/main/memory.c:2144
msgid "cons memory exhausted (limit reached?)"
msgstr "cons 記憶體已用完 (達到了極值?)"

#: src/main/memory.c:2149
msgid "memory exhausted (limit reached?)"
msgstr "記憶體已耗盡 (達到了極值？)"

#: src/main/memory.c:2283
#, c-format
msgid "cannot allocate memory block of size %0.f Tb"
msgstr "無法配置大小為 %0.f Tb 的記憶體區塊"

#: src/main/memory.c:2288
#, c-format
msgid "cannot allocate memory block of size %0.1f Gb"
msgstr "無法配置大小為 %0.1f Gb 的記憶體區塊"

#: src/main/memory.c:2686
msgid "vector is too large"
msgstr "指定的向量太大"

#: src/main/memory.c:2688
msgid "negative length vectors are not allowed"
msgstr "不允許負長度的向量"

#: src/main/memory.c:2714 src/main/memory.c:2726 src/main/memory.c:2738
#: src/main/memory.c:2752
#, c-format
msgid "cannot allocate vector of length %d"
msgstr "無法分派長度為 %d 的向量"

#: src/main/memory.c:2773
#, c-format
msgid "invalid type/length (%s/%d) in vector allocation"
msgstr "向量配置的類型/長度 (%s/%d) 無效"

#: src/main/memory.c:2860
#, c-format
msgid "cannot allocate vector of size %0.1f Gb"
msgstr "無法配置大小為 %0.1f Gb 的向量"

#: src/main/memory.c:2864
#, c-format
msgid "cannot allocate vector of size %0.1f Mb"
msgstr "無法配置大小為 %0.1f Mb 的向量"

#: src/main/memory.c:2868
#, c-format
msgid "cannot allocate vector of size %0.f Kb"
msgstr "無法配置大小為 %0.f Kb 的向量"

#: src/main/memory.c:3340
#, c-format
msgid "unprotect(): only %d protected item"
msgid_plural "unprotect(): only %d protected items"
msgstr[0] "unprotect()：只有 %d 個受保護項目"

#: src/main/memory.c:3378
msgid "unprotect_ptr: pointer not found"
msgstr "unprotect_ptr: 找不到指標"

#: src/main/memory.c:3417
#, c-format
msgid "R_Reprotect: only %d protected item, can't reprotect index %d"
msgid_plural "R_Reprotect: only %d protected items, can't reprotect index %d"
msgstr[0] "R_Reprotect：只有 %d 個受保護項目，無法重新保護索引 %d"

#: src/main/memory.c:3471
#, c-format
msgid "'R_Calloc' could not allocate memory (%.0f of %u bytes)"
msgstr "R_Calloc 無法配置記憶體 (%.0f 於 %u 位元組)"

#: src/main/memory.c:3482
#, c-format
msgid "'R_Realloc' could not re-allocate memory (%.0f bytes)"
msgstr "R_Realloc 無法重新配置記憶體 (%.0f 位元組)"

#: src/main/memory.c:3892
#, c-format
msgid "SETLENGTH() can only be applied to a standard vector, not a '%s'"
msgstr "SETLENGTH() 只能套用於標準向量而非 '%s'"

#: src/main/memory.c:4063
msgid "not safe to return vector pointer"
msgstr "回傳向量指標不是安全的做法"

#: src/main/memory.c:4074
#, fuzzy, c-format
msgid "attempt to set index %lld/%lld in SET_STRING_ELT"
msgstr "試圖於 SET_STRING_ELT 設定索引 %lu/%lu"

#: src/main/memory.c:4095
#, fuzzy, c-format
msgid "attempt to set index %lld/%lld in SET_VECTOR_ELT"
msgstr "試圖於 SET_VECTOR_ELT 設定索引 %lu/%lu"

#: src/main/memory.c:4256 src/main/memory.c:4265 src/main/memory.c:4278
#: src/main/memory.c:4295 src/main/memory.c:4310 src/main/memory.c:4326
#: src/main/memory.c:4345
msgid "bad value"
msgstr "不當的值"

#: src/main/memory.c:4523
msgid "memory profiling is not available on this system"
msgstr "這個系統上無法取得記憶體側寫檔"

#: src/main/memory.c:4586
#, c-format
msgid "Rprofmem: cannot open output file '%s'"
msgstr "Rprofmem：無法開啟輸出檔案 '%s'"

#: src/main/memory.c:4700
#, c-format
msgid "long vectors not supported yet: %s:%d"
msgstr "尚不支援長整數向量：%s:%d"

#: src/main/names.c:1058
msgid "string argument required"
msgstr "需要字串引數"

#: src/main/names.c:1061
msgid "no such primitive function"
msgstr "沒有此一原始函式"

#: src/main/names.c:1256 src/main/names.c:1290
msgid "attempt to use zero-length variable name"
msgstr "不能用零長度的變數名"

#: src/main/names.c:1258 src/main/names.c:1292
#, c-format
msgid "variable names are limited to %d bytes"
msgstr "變數名稱受限為 %d 位元組"

#: src/main/names.c:1355 src/main/names.c:1358
msgid "invalid .Internal() argument"
msgstr ".Internal() 引數無效"

#: src/main/objects.c:39
msgid "generic 'function' is not a function"
msgstr "一般 'function' 不是函式"

#: src/main/objects.c:245
msgid "bad generic call environment"
msgstr "一般呼叫環境不正確"

#: src/main/objects.c:253
msgid "bad generic definition environment"
msgstr "一般定義環境不正確"

#: src/main/objects.c:347
msgid ""
"no '.S3MethodsClass' table, cannot use S4 objects with S3 methods ('methods' "
"package not attached?)"
msgstr ""
"沒有 .S3MethodsClass 表格，無法使用 S4 物件與 S3 方法 (沒有附加 'methods' 套"
"件？)"

#: src/main/objects.c:519
msgid "there must be a 'generic' argument"
msgstr "必須要有一個 'generic' 引數"

#: src/main/objects.c:523
msgid "'generic' argument must be a character string"
msgstr "'generic' 引數必須是字串"

#: src/main/objects.c:536
msgid "'UseMethod' used in an inappropriate fashion"
msgstr "'UseMethod' 不能這樣使用"

#: src/main/objects.c:586
#, c-format
msgid "no applicable method for '%s' applied to an object of class \"%s\""
msgstr "沒有適用的方法可將 '%s' 套用到 \"%s\" 類別的物件"

#: src/main/objects.c:695
msgid "'NextMethod' called from outside a function"
msgstr "'NextMethod' 不能在函式外呼叫"

#: src/main/objects.c:701
msgid "'NextMethod' called from an anonymous function"
msgstr "'NextMethod' 不能在匿名函式內呼叫"

#: src/main/objects.c:722
msgid "no calling generic was found: was a method called directly?"
msgstr "找不到呼叫此方法的一般函式: 是不是已經直接呼叫這個方法?"

#: src/main/objects.c:725
#, c-format
msgid "'function' is not a function, but of type %d"
msgstr "'function' 不是函式, 而是類型 %d"

#: src/main/objects.c:752
msgid "wrong argument ..."
msgstr "引數不正確 …"

#: src/main/objects.c:764
msgid "object not specified"
msgstr "物件沒有指定"

#: src/main/objects.c:772 src/main/objects.c:779
msgid "generic function not specified"
msgstr "一般功能沒有指定"

#: src/main/objects.c:776
msgid "invalid generic argument to 'NextMethod'"
msgstr "NextMethod 不能用一般引數"

#: src/main/objects.c:788
msgid "invalid 'group' argument found in 'NextMethod'"
msgstr "NextMethod 不能用 'group' 引數"

#: src/main/objects.c:805
msgid "wrong value for .Method"
msgstr ".Method 的值不正確"

#: src/main/objects.c:815
msgid "Incompatible methods ignored"
msgstr "不相容方法，忽略不用"

#: src/main/objects.c:872 src/main/objects.c:879
msgid "no method to invoke"
msgstr "沒有可以呼叫的方法"

#: src/main/objects.c:930
msgid "cannot unclass an environment"
msgstr "無法取消環境的類別"

#: src/main/objects.c:933
msgid "cannot unclass an external pointer"
msgstr "無法取消外部指標的類別"

#: src/main/objects.c:994
msgid "'what' must be a character vector"
msgstr "'what' 必須是字元向量"

#: src/main/objects.c:998
msgid "'which' must be a length 1 logical vector"
msgstr "'which' 必須是長度為 1 的邏輯向量"

#: src/main/objects.c:1129
msgid "could not find correct environment; please report!"
msgstr "找不到正確的環境；請通報！"

#: src/main/objects.c:1173
msgid "'onOff' must be TRUE or FALSE"
msgstr "'onOff' 必須是 TRUE 或 FALSE"

#: src/main/objects.c:1238
#, c-format
msgid "unable to find a non-generic version of function \"%s\""
msgstr "無法找到非一般版本的函式 \"%s\""

#: src/main/objects.c:1270
msgid ""
"'standardGeneric' called without 'methods' dispatch enabled (will be ignored)"
msgstr "standardGeneric 被呼叫，但 'methods' 分派沒有啟用 (忽略不用)"

#: src/main/objects.c:1278
msgid "argument to 'standardGeneric' must be a non-empty character string"
msgstr "standardGeneric 的引數必須是非空字串"

#: src/main/objects.c:1283
#, c-format
msgid ""
"call to standardGeneric(\"%s\") apparently not from the body of that generic "
"function"
msgstr "不能從非同屬函式中呼叫 standardGeneric(\"%s\") "

#: src/main/objects.c:1382
#, c-format
msgid ""
"invalid primitive methods code (\"%s\"): should be \"clear\", \"reset\", "
"\"set\", or \"suppress\""
msgstr ""
"原始方法程式碼 (\"%s\") 無效：應該是 \"clear\"、\"reset\"、\"set\" 或 "
"\"suppress\""

#: src/main/objects.c:1390
msgid "invalid object: must be a primitive function"
msgstr "物件無效: 必須是原始函式"

#: src/main/objects.c:1437
#, c-format
msgid ""
"the formal definition of a primitive generic must be a function object (got "
"type '%s')"
msgstr "原始一般函式的形式定義必須是函式物件 (不能是 '%s' 類別)"

#: src/main/objects.c:1467
#, c-format
msgid "object returned as generic function \"%s\" does not appear to be one"
msgstr "以通用函式 \"%s\" 型式回傳的物件看來不是一個"

#: src/main/objects.c:1556
msgid "invalid primitive operation given for dispatch"
msgstr "不能分派原始運算"

#: src/main/objects.c:1587 src/main/objects.c:1617
msgid "dispatch error"
msgstr "分派錯誤"

#: src/main/objects.c:1611
#, c-format
msgid ""
"primitive function \"%s\" has been set for methods but no generic function "
"supplied"
msgstr "原始函式 \"%s\" 設定了方法，但沒有一般函式 "

#: src/main/objects.c:1642
msgid "C level MAKE_CLASS macro called with NULL string pointer"
msgstr "C 級的 MAKE_TYPE 巨集不能用 NULL 字串指標來呼叫"

#: src/main/objects.c:1658
msgid "'methods' package not yet loaded"
msgstr "尚未載入 'methods' 套件"

#: src/main/objects.c:1668
msgid "R_getClassDef(.) called with NULL string pointer"
msgstr "R_getClassDef(.)  以空字串指標來呼叫"

#: src/main/objects.c:1715
msgid "C level NEW macro called with null class definition pointer"
msgstr "C 級的 NEW 巨集不能用 null 類別定義指標來呼叫"

#: src/main/objects.c:1719
#, c-format
msgid "trying to generate an object from a virtual class (\"%s\")"
msgstr "試著從虛擬類別 (\"%s\") 產生物件"

#: src/main/objects.c:1804
#, c-format
msgid "object of class \"%s\" does not correspond to a valid S3 object"
msgstr "\"%s\" 類別的物件並不相應於有效的 S3 物件"

#: src/main/options.c:135 src/main/options.c:210
msgid "corrupted options list"
msgstr "已損壞的選項串列"

#: src/main/options.c:145
#, fuzzy, c-format
msgid "invalid printing width %d, used 80"
msgstr "無效的印出寬度，使用 80"

#: src/main/options.c:148
#, fuzzy
msgid "invalid printing width"
msgstr "無效的印出寬度，使用 80"

#: src/main/options.c:163
#, fuzzy, c-format
msgid "invalid printing digits %d, used 7"
msgstr "無效的印出位數，使用 7"

#: src/main/options.c:166
#, fuzzy, c-format
msgid "invalid printing digits %d"
msgstr "無效的印出位數，使用 7"

#: src/main/options.c:182
msgid "invalid 'deparse.cutoff', used 60"
msgstr "無效的'deparse.cutoff'，使用 60"

#: src/main/options.c:194
msgid "invalid value for \"device.ask.default\", using FALSE"
msgstr "用於 \"device.ask.default\" 的值無效，使用 FALSE"

#: src/main/options.c:485
msgid "list argument has no valid names"
msgstr "串列引數沒有任何有效名稱"

#: src/main/options.c:531
#, fuzzy, c-format
msgid "option '%s' cannot be deleted"
msgstr "zip 檔案 '%s' 無法開啟"

#: src/main/options.c:536 src/main/options.c:547 src/main/options.c:554
#, fuzzy, c-format
msgid "invalid '%s' parameter, allowed %d...%d"
msgstr "無效的 'digits' 參數，允許 %d...%d"

#: src/main/options.c:561 src/main/options.c:569 src/main/options.c:575
#: src/main/options.c:583 src/main/options.c:590 src/main/options.c:595
#: src/main/options.c:602 src/main/options.c:612 src/main/options.c:627
#: src/main/options.c:633 src/main/options.c:638 src/main/options.c:643
#: src/main/options.c:652 src/main/options.c:658 src/main/options.c:664
#: src/main/options.c:674 src/main/options.c:688 src/main/options.c:694
#: src/main/options.c:702 src/main/options.c:709 src/main/options.c:716
#: src/main/options.c:723 src/main/options.c:730 src/main/options.c:738
#: src/main/options.c:747 src/main/options.c:750 src/main/options.c:756
#: src/main/options.c:764 src/main/options.c:777 src/main/options.c:818
#, c-format
msgid "invalid value for '%s'"
msgstr "無效的值用於 '%s'"

#: src/main/options.c:617
#, c-format
msgid "value for '%s' outside of -1:2 is set to %d\n"
msgstr ""

#: src/main/options.c:679
msgid "'OutDec' must be a string of one character"
msgstr "'OutDec' 必須是單一字元字串"

#: src/main/options.c:743 src/main/options.c:837
msgid "\"par.ask.default\" has been replaced by \"device.ask.default\""
msgstr "\"par.ask.default\" 已被 \"device.ask.default\" 所置換"

#: src/main/options.c:774
msgid "OpenMP SIMD is not supported in this build of R"
msgstr "R 的這次組建不支援 OpenMP SIMD"

#: src/main/options.c:798
msgid "'PCRE_study' has no effect with PCRE2"
msgstr ""

#: src/main/options.c:821
#, c-format
msgid "'%s' is deprecated and will be disabled"
msgstr ""

#: src/main/options.c:834
msgid "invalid argument"
msgstr "引數無效"

#: src/main/paste.c:78 src/main/util.c:483
#, c-format
msgid "%d argument passed to .Internal(%s) which requires %d"
msgid_plural "%d arguments passed to .Internal(%s) which requires %d"
msgstr[0] "傳遞 %d 個引數給 .Internal(%s) 但它需要 %d 個"

#: src/main/paste.c:103 src/main/paste.c:345
msgid "invalid separator"
msgstr "分隔符號無效"

#: src/main/paste.c:150 src/main/paste.c:365
#, fuzzy, c-format
msgid "non-string argument to .Internal(%s)"
msgstr "內部貼上的引數不是字串"

#: src/main/paste.c:215 src/main/paste.c:286
msgid "result would exceed 2^31-1 bytes"
msgstr "結果會超過 2^31-1 位元組"

#: src/main/paste.c:378
#, fuzzy
msgid "strings with \"bytes\" encoding are not allowed"
msgstr "不允許以 \"bytes\" 編碼的翻譯字串"

#: src/main/paste.c:462
#, fuzzy
msgid "first argument must be atomic or environment"
msgstr "引數必須是環境物件"

#: src/main/paste.c:474
#, fuzzy, c-format
msgid "invalid value %d for '%s' argument"
msgstr "無效的值用於 '%s'"

#: src/main/paste.c:523
msgid "'decimal.mark' must be a string of one character"
msgstr "'decimal.mark' 必須是單一字元字串"

#: src/main/paste.c:654
msgid "Impossible mode ( x )"
msgstr "這種狀態 (x) 是不可能的"

#: src/main/paste.c:738
msgid "atomic vector arguments only"
msgstr "只能用基元向量引數"

#: src/main/platform.c:476 src/main/platform.c:490
msgid "invalid filename specification"
msgstr "檔案名稱設定無效"

#: src/main/platform.c:549 src/main/platform.c:605
msgid "write error during file append"
msgstr "檔案附加時寫入發生錯誤"

#: src/main/platform.c:569
msgid "nothing to append to"
msgstr "沒有可以附加的檔案"

#: src/main/platform.c:634 src/main/platform.c:968 src/main/platform.c:1187
msgid "invalid filename argument"
msgstr "filename 引數無效"

#: src/main/platform.c:647
#, c-format
msgid "cannot create file '%s', reason '%s'"
msgstr "無法建立檔案 '%s' ，原因是 '%s'"

#: src/main/platform.c:662 src/main/platform.c:703 src/main/platform.c:791
msgid "invalid first filename"
msgstr "第一個檔案名稱無效"

#: src/main/platform.c:674
#, c-format
msgid "cannot remove file '%s', reason '%s'"
msgstr "無法移除檔案 '%s' ，原因是 '%s'"

#: src/main/platform.c:705 src/main/platform.c:793
msgid "invalid second filename"
msgstr "第二個檔案名稱無效"

#: src/main/platform.c:708 src/main/platform.c:796
msgid "nothing to link"
msgstr "沒有可以連接的檔案"

#: src/main/platform.c:718
msgid "symbolic links are not supported on this version of Windows"
msgstr "這個版本的 Windows 不支援符號鏈結"

#: src/main/platform.c:734 src/main/platform.c:811 src/main/platform.c:2668
#: src/main/platform.c:2679
#, c-format
msgid "'%s' path too long"
msgstr "路徑 '%s' 太長"

#: src/main/platform.c:743
#, c-format
msgid "cannot symlink '%ls' to '%ls', reason '%s'"
msgstr "無法將 '%ls' 符號鏈結到 '%ls'，原因是 '%s'"

#: src/main/platform.c:765
#, c-format
msgid "cannot symlink '%s' to '%s', reason '%s'"
msgstr "無法將 '%s' 符號鏈結到 '%s'，原因是 '%s'"

#: src/main/platform.c:773
msgid "symbolic links are not supported on this platform"
msgstr "這個平臺不支援符號鏈結"

#: src/main/platform.c:816
#, c-format
msgid "cannot link '%ls' to '%ls', reason '%s'"
msgstr "無法將 '%ls' 鏈結到 '%ls' ，原因是 '%s'"

#: src/main/platform.c:838
#, c-format
msgid "cannot link '%s' to '%s', reason '%s'"
msgstr "無法將 '%s' 鏈結到 '%s' ，原因是 '%s'"

#: src/main/platform.c:847
msgid "(hard) links are not supported on this platform"
msgstr "這個平臺不支援 (硬式) 鏈結"

#: src/main/platform.c:879
msgid "'from' and 'to' are of different lengths"
msgstr "'from' 和 'to' 具有不同的長度"

#: src/main/platform.c:890 src/main/platform.c:905
msgid "expanded 'from' name too long"
msgstr "展開後的 'from' 名稱太長"

#: src/main/platform.c:894 src/main/platform.c:909
msgid "expanded 'to' name too long"
msgstr "展開後的 'to' 名稱太長"

#: src/main/platform.c:898
#, fuzzy, c-format
msgid "cannot rename file '%ls' to '%ls', reason '%s'"
msgstr "無法將檔案 '%s' 重新命名為 ' %s' ，原因是 '%s'"

#: src/main/platform.c:913
#, c-format
msgid "cannot rename file '%s' to '%s', reason '%s'"
msgstr "無法將檔案 '%s' 重新命名為 ' %s' ，原因是 '%s'"

#: src/main/platform.c:1290 src/main/platform.c:1321 src/main/platform.c:1435
#: src/main/platform.c:1448 src/main/platform.c:2530 src/main/platform.c:2542
#: src/main/platform.c:2571 src/main/platform.c:2592 src/main/platform.c:2789
#: src/main/platform.c:2802 src/main/platform.c:2833 src/main/platform.c:2854
msgid "over-long path"
msgstr "過長的路徑"

#: src/main/platform.c:1379
msgid "invalid 'pattern' regular expression"
msgstr "'pattern' 正規表示式無效"

#: src/main/platform.c:1503
msgid "unable to determine R home location"
msgstr "無法確定 R 家目錄位置"

#: src/main/platform.c:1558
msgid "file name too long"
msgstr "檔案名稱太長"

#: src/main/platform.c:1768 src/main/util.c:833 src/main/util.c:867
#: src/main/util.c:909 src/main/util.c:951
msgid "path too long"
msgstr "路徑太長"

#: src/main/platform.c:1829 src/main/platform.c:1893 src/main/sysutils.c:2110
#: src/main/sysutils.c:2124
msgid "internal out-of-memory condition"
msgstr "內部記憶體不足的狀況"

#: src/main/platform.c:1889 src/main/sysutils.c:2120
#, c-format
msgid "read error on '%s'"
msgstr "於 '%s' 讀取錯誤"

#: src/main/platform.c:1996
msgid "setting 'LC_NUMERIC' may cause R to function strangely"
msgstr "正在設定 'LC_NUMERIC' 可能會使得 R 的運作異常"

#: src/main/platform.c:2010
msgid "LC_MESSAGES exists on Windows but is not operational"
msgstr "LC_MESSAGES 存在於 Windows 但是運作不正常"

#: src/main/platform.c:2037
#, c-format
msgid "OS reports request to set locale to \"%s\" cannot be honored"
msgstr "作業系統通報無法實現設定語區為 \"%s\" 的要求"

#: src/main/platform.c:2423
#, c-format
msgid "'%s' already exists"
msgstr "'%s' 已存在"

#: src/main/platform.c:2426
#, c-format
msgid "cannot create dir '%s', reason '%s'"
msgstr "無法建立目錄 '%s' ，原因是 '%s'"

#: src/main/platform.c:2449
#, c-format
msgid "'%s' too long"
msgstr "'%s' 太長"

#: src/main/platform.c:2480
#, c-format
msgid "'%ls' already exists"
msgstr "'%ls' 已經存在"

#: src/main/platform.c:2482 src/main/platform.c:2488
#, c-format
msgid "cannot create dir '%ls', reason '%s'"
msgstr "無法建立目錄 '%ls' ，原因是 '%s'"

#: src/main/platform.c:2522 src/main/platform.c:2773
msgid "too deep nesting"
msgstr "巢狀結構太深"

#: src/main/platform.c:2554
#, c-format
msgid "cannot overwrite non-directory %ls with directory %ls"
msgstr ""

#: src/main/platform.c:2559
#, c-format
msgid "problem creating directory %ls: %s"
msgstr "建立目錄 %ls 時出了問題：%s"

#: src/main/platform.c:2581
#, fuzzy, c-format
msgid "problem reading directory %ls: %s"
msgstr "讀取目錄 %s 時出了問題：%s"

#: src/main/platform.c:2600
#, c-format
msgid "problem copying %ls to %ls: %s"
msgstr "複製 %ls 到 %ls 時出了問題：%s"

#: src/main/platform.c:2816
#, c-format
msgid "cannot overwrite non-directory %s with directory %s"
msgstr ""

#: src/main/platform.c:2821
#, c-format
msgid "problem creating directory %s: %s"
msgstr "建立目錄 %s 時出了問題：%s"

#: src/main/platform.c:2843
#, c-format
msgid "problem reading directory %s: %s"
msgstr "讀取目錄 %s 時出了問題：%s"

#: src/main/platform.c:2863
#, c-format
msgid "problem copying %s to %s: %s"
msgstr "複製 %s 到 %s 時出了問題：%s"

#: src/main/platform.c:3022
msgid "'mode' must be of length at least one"
msgstr "'mode' 的長度必須是至少一個"

#: src/main/platform.c:3090
msgid "insufficient OS support on this platform"
msgstr "這個平臺的作業系統支援不足"

#: src/main/platform.c:3200
#, fuzzy, c-format
msgid "'%s' must be of length at least one"
msgstr "'mode' 的長度必須是至少一個"

#: src/main/plot3d.c:120
#, c-format
msgid "contour(): circular/long seglist -- set %s > %d?"
msgstr "contour()：環/長 seglist -- 設定 %s > %d？"

#: src/main/plot3d.c:198
msgid "all z values are equal"
msgstr "所有的 z 值都一樣"

#: src/main/plot3d.c:200
msgid "all z values are NA"
msgstr "所有的 z 值都是 NA"

#: src/main/plotmath.c:333
msgid "invalid math style encountered"
msgstr "遇到無效的數學樣式"

#: src/main/plotmath.c:1265 src/main/plotmath.c:1371 src/main/plotmath.c:2664
msgid "invalid mathematical annotation"
msgstr "無效的數學記法"

#: src/main/plotmath.c:1675
msgid "invalid accent"
msgstr "無效的音調符號"

#: src/main/plotmath.c:1973
msgid "invalid group delimiter"
msgstr "無效的群組分隔符號"

#: src/main/plotmath.c:2000 src/main/plotmath.c:2137
msgid "invalid group specification"
msgstr "無效的群組規格"

#: src/main/plotmath.c:2062
msgid "group is incomplete"
msgstr "群組不完整"

#: src/main/plotmath.c:3190
msgid "Metric information not available for this family/device"
msgstr "度量資訊無法用於這個家族/裝置"

#: src/main/print.c:150 src/main/print.c:257
msgid "invalid 'na.print' specification"
msgstr "'na.print' 設定無效"

#: src/main/print.c:159
msgid "invalid row labels"
msgstr "列標記無效"

#: src/main/print.c:161
msgid "invalid column labels"
msgstr "行標記無效"

#: src/main/print.c:269
msgid "'gap' must be non-negative integer"
msgstr "'gap' 必須是正整數"

#: src/main/print.c:272
#, fuzzy, c-format
msgid "'print.gap' must be less than %d"
msgstr "'fromLast' 的長度必須是 1"

#: src/main/print.c:1002
msgid "print buffer overflow"
msgstr "印出緩衝區溢位"

#: src/main/print.c:1130
msgid "invalid character length in 'dblepr'"
msgstr "dblepr 字元長度無效"

#: src/main/print.c:1151
msgid "invalid character length in 'intpr'"
msgstr "intpr 字元長度無效"

#: src/main/print.c:1173
msgid "invalid character length in 'realpr'"
msgstr "realpr 字元長度無效"

#: src/main/print.c:1183
msgid "memory allocation error in 'realpr'"
msgstr "realpr 記憶體配置錯誤"

#: src/main/print.c:1216
#, c-format
msgid "BLAS/LAPACK routine '%6s' gave error code %d"
msgstr "BLAS/LAPACK 常式 '%6s' 產生了錯誤碼 %d"

#: src/main/printarray.c:340
msgid "too few row labels"
msgstr "列標記不夠"

#: src/main/printarray.c:342
msgid "too few column labels"
msgstr "行標記不夠"

#: src/main/printarray.c:376
#, c-format
msgid " [ reached getOption(\"max.print\") -- omitted %d row ]\n"
msgid_plural " [ reached getOption(\"max.print\") -- omitted %d rows ]\n"
msgstr[0] " [ 達到了 getOption(\"max.print\") -- 省略最後 %d 列 ]]\n"

#: src/main/printutils.c:650
#, c-format
msgid "too large string (nchar=%d) => 5*nchar + 8 > SIZE_MAX"
msgstr "太長的字串 (nchar=%d) => 5*nchar + 8 > SIZE_MAX"

#: src/main/printutils.c:764
msgid "it is not known that wchar_t is Unicode on this platform"
msgstr "不確定本平臺的 wchar_t 是否為萬國碼"

#: src/main/qsort.c:55
msgid "argument is not a numeric vector"
msgstr "引數不是數值向量"

#: src/main/random.c:39
msgid "invalid arguments"
msgstr "引數無效"

#: src/main/random.c:95 src/main/random.c:112 src/main/random.c:178
#: src/main/random.c:204 src/main/random.c:277 src/main/random.c:291
msgid "NAs produced"
msgstr "產生了 NA"

#: src/main/random.c:445
msgid "NA in probability vector"
msgstr "機率向量中有 NA"

#: src/main/random.c:447
msgid "negative probability"
msgstr "出現負值機率"

#: src/main/random.c:454
msgid "too few positive probabilities"
msgstr "正值機率太少"

#: src/main/random.c:483 src/main/random.c:511
msgid "cannot take a sample larger than the population when 'replace = FALSE'"
msgstr "當 'replace = FALSE' 時不能取用比總體還要大的樣本"

#: src/main/random.c:490
msgid "incorrect number of probabilities"
msgstr "機率數目不正確"

#: src/main/random.c:529
msgid "n >= 2^31, replace = FALSE is only supported on 64-bit platforms"
msgstr "只有 64 位元平臺才支援 n >= 2^31, replace = FALSE"

#: src/main/raw.c:37 src/main/raw.c:330
msgid "argument must be a character vector of length 1"
msgstr "引數必須是長度為 1 的字元向量"

#: src/main/raw.c:39 src/main/raw.c:332
msgid ""
"argument should be a character vector of length 1\n"
"all but the first element will be ignored"
msgstr ""
"引數應該是長度為 1 的字元向量\n"
"只有第一個元素將被使用"

#: src/main/raw.c:53 src/main/raw.c:90 src/main/raw.c:113
msgid "argument 'x' must be a raw vector"
msgstr "引數 'x' 必須是純量向量"

#: src/main/raw.c:56 src/main/raw.c:388
msgid "argument 'multiple' must be TRUE or FALSE"
msgstr "引數 'multiple' 必須為 TRUE 或 FALSE"

#: src/main/raw.c:92
#, fuzzy
msgid "argument 'n' must be a small integer"
msgstr "引數 'shift' 必須是小整數"

#: src/main/raw.c:129 src/main/raw.c:385
msgid "argument 'x' must be an integer vector"
msgstr "引數 'x' 必須是整數向量"

#: src/main/raw.c:155 src/main/raw.c:178
#, fuzzy
msgid "argument 'x' must be a numeric vector"
msgstr "引數 'x' 必須是純量向量"

#: src/main/raw.c:205
msgid "argument 'x' must be raw, integer or logical"
msgstr "引數 'x' 必須是原始值、整數或邏輯值"

#: src/main/raw.c:215
#, c-format
msgid "argument 'x' must be a multiple of %d long"
msgstr "引數 'x' 必須是 %d 長度的位數"

#: src/main/raw.c:228 src/main/raw.c:242 src/main/raw.c:264
msgid "argument 'x' must not contain NAs"
msgstr "引數 'x' 必須不包含 NA"

#: src/main/raw.c:344 src/main/util.c:1912
msgid "invalid UTF-8 string"
msgstr "無效的 UTF-8 字串"

#: src/main/raw.c:391
msgid "argument 'allow_surrogate_pairs' must be TRUE or FALSE"
msgstr "引數 'allow_surrogate_pairs' 必須為 TRUE 或 FALSE"

#: src/main/relop.c:163
#, c-format
msgid "comparison (%d) is possible only for atomic and list types"
msgstr "只有基元或串列類型才能做比較 (%d)"

#: src/main/relop.c:167
msgid "comparison is not allowed for expressions"
msgstr "運算式不能作比較"

#: src/main/relop.c:258
msgid "comparison of these types is not implemented"
msgstr "這些類型的比較還沒有實作"

#: src/main/relop.c:361
msgid "invalid comparison with complex values"
msgstr "不能與複數值進行比較"

#: src/main/relop.c:636 src/main/relop.c:681 src/main/relop.c:715
msgid "'a' and 'b' must have the same type"
msgstr "'a' 和 'b' 必須是相同類型"

#: src/main/saveload.c:205 src/main/saveload.c:210 src/main/saveload.c:219
#: src/main/saveload.c:228 src/main/saveload.c:237 src/main/saveload.c:246
#: src/main/saveload.c:250 src/main/saveload.c:259 src/main/saveload.c:1394
#: src/main/saveload.c:1399 src/main/saveload.c:1443 src/main/saveload.c:1511
#: src/main/saveload.c:1520 src/main/serialize.c:394 src/main/serialize.c:401
#: src/main/serialize.c:414 src/main/serialize.c:418 src/main/serialize.c:445
#: src/main/serialize.c:461 src/main/serialize.c:1992 src/main/serialize.c:2768
#: src/main/serialize.c:2776
msgid "read error"
msgstr "讀取錯誤"

#: src/main/saveload.c:337
msgid "a I read error occurred"
msgstr "發生了 I 類別讀取錯誤"

#: src/main/saveload.c:347
msgid "a R read error occurred"
msgstr "發生了 R 類別讀取錯誤"

#: src/main/saveload.c:357
msgid "a C read error occurred"
msgstr "發生了 C 類別讀取錯誤"

#: src/main/saveload.c:367
msgid "a S read error occurred"
msgstr "發生了 S 類別讀取錯誤"

#: src/main/saveload.c:392 src/main/saveload.c:400 src/main/saveload.c:408
#: src/main/saveload.c:1607 src/main/saveload.c:1615
msgid "a read error occurred"
msgstr "發生了讀取錯誤"

#: src/main/saveload.c:472
msgid "unresolved node during restore"
msgstr "復原時遇到了無法解析的節點"

#: src/main/saveload.c:493
#, c-format
msgid "restore compatibility error - no version %d compatibility"
msgstr "復原相容錯誤：沒有同版本 %d 相容的功能"

#: src/main/saveload.c:577 src/main/saveload.c:650
msgid "bad SEXP type in data file"
msgstr "資料檔案中 SEXP 類型發生錯誤"

#: src/main/saveload.c:591
msgid "mismatch on types"
msgstr "類型不符合"

#: src/main/saveload.c:612 src/main/saveload.c:1283 src/main/serialize.c:1920
#, c-format
msgid "unrecognized internal function name \"%s\""
msgstr "無法識別的內部函式名稱 \"%s\""

#: src/main/saveload.c:714
msgid "cannot save file position while restoring data"
msgstr "復原資料的時候無法儲存檔案位置"

#: src/main/saveload.c:727
msgid "cannot restore file position while restoring data"
msgstr "復原資料的時候無法復原檔案位置"

#: src/main/saveload.c:920
msgid "base namespace is not preserved in version 1 workspaces"
msgstr "1 號版本工作空間不能保留基本命名空間"

#: src/main/saveload.c:922
msgid "cannot save namespace in version 1 workspaces"
msgstr "1 號版本工作空間無法儲存命名空間"

#: src/main/saveload.c:924
msgid ""
"cannot save environment with locked/active bindings in version 1 workspaces"
msgstr "1 號版本工作空間不能儲存鎖住的或是仍在用的繫結環境"

#: src/main/saveload.c:952
msgid "cannot save weak references in version 1 workspaces"
msgstr "1 號版本工作空間無法儲存弱型參考"

#: src/main/saveload.c:1030
msgid "NewWriteVec called with non-vector type"
msgstr "NewWriteVec 不適用於非向量類型"

#: src/main/saveload.c:1097
msgid "cannot save byte code objects in version 1 workspaces"
msgstr "1 號版本工作空間無法儲存位元組碼物件"

#: src/main/saveload.c:1099
#, c-format
msgid "NewWriteItem: unknown type %i"
msgstr "NewWriteItem: 不明類型 %i"

#: src/main/saveload.c:1229
msgid "NewReadVec called with non-vector type"
msgstr "NewReadVec 不適用於非向量類型"

#: src/main/saveload.c:1299
msgid "cannot read byte code objects from version 1 workspaces"
msgstr "無法從 1 號版本工作空間中讀取位元組碼物件"

#: src/main/saveload.c:1301
#, c-format
msgid "NewReadItem: unknown type %i"
msgstr "NewReadItem: 不明類型 %i"

#: src/main/saveload.c:1453
msgid "out of memory reading ascii string"
msgstr "讀取 ascii 字串時記憶體不足"

#: src/main/saveload.c:1578
msgid "a binary read error occurred"
msgstr "二進位讀取時發生了錯誤"

#: src/main/saveload.c:1593 src/main/saveload.c:1694
msgid "out of memory reading binary string"
msgstr "讀取二進位字串時記憶體不足"

#: src/main/saveload.c:1598
msgid "a binary string read error occurred"
msgstr "讀取二進位字串時發生了錯誤"

#: src/main/saveload.c:1658
msgid "an xdr integer data write error occurred"
msgstr "發生了 xdr 整數資料寫入錯誤"

#: src/main/saveload.c:1665
msgid "an xdr integer data read error occurred"
msgstr "發生了 xdr 整數資料讀取錯誤"

#: src/main/saveload.c:1680 src/main/saveload.c:1699
msgid "an xdr string data write error occurred"
msgstr "發生了 xdr 字串資料寫入錯誤"

#: src/main/saveload.c:1707
msgid "an xdr real data write error occurred"
msgstr "發生了 xdr 實數資料寫入錯誤"

#: src/main/saveload.c:1714
msgid "an xdr real data read error occurred"
msgstr "發生了 xdr 實數資料讀取錯誤"

#: src/main/saveload.c:1721
msgid "an xdr complex data write error occurred"
msgstr "發生了 xdr 複數資料寫入錯誤"

#: src/main/saveload.c:1728
msgid "an xdr complex data read error occurred"
msgstr "發生了 xdr 複數資料讀取錯誤"

#: src/main/saveload.c:1805 src/main/serialize.c:2333 src/main/serialize.c:2960
#: src/modules/internet/internet.c:390 src/modules/internet/internet.c:463
msgid "write failed"
msgstr "寫入失敗"

#: src/main/saveload.c:1964
msgid "restore file may be empty -- no data loaded"
msgstr "復原檔案可能是空的 -- 沒有載入任何資料"

#: src/main/saveload.c:1966
msgid "restore file may be from a newer version of R -- no data loaded"
msgstr "復原檔案可能是由比本 R 版本要新的 R 所儲存的 -- 沒有載入任何資料"

#: src/main/saveload.c:1968
msgid "bad restore file magic number (file may be corrupted) -- no data loaded"
msgstr "復原檔案魔術數字發生錯誤 (檔案可能有損壞)-- 沒有載入任何資料"

#: src/main/saveload.c:1984
msgid "bad file name"
msgstr "不當的檔案名稱"

#: src/main/saveload.c:1988 src/main/saveload.c:2016
msgid "unable to open 'file'"
msgstr "無法開啟 'file'"

#: src/main/saveload.c:2004 src/main/saveload.c:2046
msgid "'file' must be non-empty string"
msgstr "'file' 必須是非空字串"

#: src/main/saveload.c:2006 src/main/saveload.c:2048 src/main/saveload.c:2348
#: src/main/serialize.c:2525
msgid "'ascii' must be logical"
msgstr "'ascii' 必須是邏輯值"

#: src/main/saveload.c:2044 src/main/saveload.c:2342
msgid "first argument must be a character vector"
msgstr "第一引數必須是字元向量"

#: src/main/saveload.c:2116
msgid "not a valid named list"
msgstr "不是有效的具名串列"

#: src/main/saveload.c:2123 src/main/saveload.c:2144
#, c-format
msgid "'%s' looks like a pre-2.4.0 S4 object: please recreate it"
msgstr "'%s' 看來像是 pre-2.4.0 S4 物件：請重新建立它"

#: src/main/saveload.c:2131
msgid "loaded data is not in pair list form"
msgstr "載入資料不是成雙的串列形式"

#: src/main/saveload.c:2167
msgid "first argument must be a file name"
msgstr "第一引數必須是檔案名稱"

#: src/main/saveload.c:2212 src/main/saveload.c:2238 src/main/serialize.c:908
#: src/main/serialize.c:945 src/main/serialize.c:983
msgid "XDR write failed"
msgstr "XDR 寫入失敗"

#: src/main/saveload.c:2225 src/main/saveload.c:2250 src/main/serialize.c:1501
#: src/main/serialize.c:1537 src/main/serialize.c:1575
msgid "XDR read failed"
msgstr "XDR 讀取失敗"

#: src/main/saveload.c:2261
#, c-format
msgid "cannot save data -- unable to open '%s': %s"
msgstr "無法儲存資料 -- 無法開啟 '%s' ：%s"

#: src/main/saveload.c:2358 src/main/serialize.c:2538
#, c-format
msgid "cannot save to connections in version %d format"
msgstr "不可使用版本 %d 的格式來儲存連接"

#: src/main/saveload.c:2381 src/main/serialize.c:2563
msgid "connection not open for writing"
msgstr "無法開啟連接來進行寫入"

#: src/main/saveload.c:2391
msgid "cannot save XDR format to a text-mode connection"
msgstr "不能將XDR格式儲存到文字狀態連接"

#: src/main/saveload.c:2403 src/main/serialize.c:2441 src/main/serialize.c:2455
#: src/main/serialize.c:2642 src/main/serialize.c:2664
msgid "error writing to connection"
msgstr "連接寫入發生了錯誤"

#: src/main/saveload.c:2465 src/main/serialize.c:2609
msgid "connection not open for reading"
msgstr "連接未開啟而無法讀取"

#: src/main/saveload.c:2466
msgid "can only load() from a binary connection"
msgstr "只能從二進位連接 load()"

#: src/main/saveload.c:2479
msgid "no input is available"
msgstr "沒有可用的輸入"

#: src/main/saveload.c:2504
msgid ""
"the input does not start with a magic number compatible with loading from a "
"connection"
msgstr "輸入並非以從某個連接所載入的神奇數字開始"

#: src/main/scan.c:368 src/main/scan.c:418
msgid "EOF within quoted string"
msgstr "EOF 出現於引號字串中"

#: src/main/scan.c:488
#, c-format
msgid "scan() expected '%s', got '%s'"
msgstr "scan() 需要 '%s'，而不是 '%s'"

#: src/main/scan.c:593 src/main/scan.c:748
msgid "too many items"
msgstr "太多項目"

#: src/main/scan.c:681
msgid "empty 'what' specified"
msgstr "'what' 設定是空的"

#: src/main/scan.c:736
#, fuzzy, c-format
msgid "line %lld did not have %lld elements"
msgstr "第 %d 列沒有 %d 個元素"

#: src/main/scan.c:788
msgid "number of items read is not a multiple of the number of columns"
msgstr "讀取的項目數必須是行數的倍數"

#: src/main/scan.c:883
msgid "invalid 'strip.white' length"
msgstr "'strip.white' 的長度無效"

#: src/main/scan.c:894
msgid "invalid 'sep' value: must be one byte"
msgstr "'sep' 值無效: 大小只能為一個位元組"

#: src/main/scan.c:906
msgid "invalid decimal separator: must be one byte"
msgstr "十進位分隔符號無效: 大小只能為一個位元組"

#: src/main/scan.c:911
msgid "invalid decimal separator"
msgstr "十進位分隔符號無效"

#: src/main/scan.c:920
msgid "invalid quote symbol set"
msgstr "引號符號集無效"

#: src/main/scan.c:1002
msgid "embedded nul(s) found in input"
msgstr "空值嵌入於輸入中"

#: src/main/seq.c:49
msgid "unequal factor lengths"
msgstr "因子長度不相等"

#: src/main/seq.c:101 src/main/seq.c:1101
msgid "result would be too long a vector"
msgstr "答案向量會太長"

#: src/main/seq.c:155
msgid "argument of length 0"
msgstr "長度為 0 的引數"

#: src/main/seq.c:158 src/main/seq.c:163
#, c-format
msgid "numerical expression has %d element: only the first used"
msgid_plural "numerical expression has %d elements: only the first used"
msgstr[0] "數值運算式一共有 %d 個元素: 只用了第一個"

#: src/main/seq.c:169
msgid "NA/NaN argument"
msgstr "NA/NaN 引數"

#: src/main/seq.c:357
#, c-format
msgid "invalid type (%s) for '%s' (must be a vector)"
msgstr "設 '%2$s' 時的類型 (%1$s) 無效 (必須是向量)"

#: src/main/seq.c:361
#, c-format
msgid "attempt to replicate an object of type '%s'"
msgstr "試圖複製 '%s' 類型的物件"

#: src/main/seq.c:433
msgid "attempt to replicate non-vector"
msgstr "非向量物件不能被複製"

#: src/main/seq.c:448
msgid "cannot replicate NULL to a non-zero length"
msgstr "無法將空值複製為非零長度"

#: src/main/seq.c:681 src/main/seq.c:697 src/main/seq.c:855 src/main/seq.c:1093
#, c-format
msgid "first element used of '%s' argument"
msgstr "'%s' 引數的第一個元素已用"

#: src/main/seq.c:835 src/main/seq.c:867 src/main/seq.c:874 src/main/seq.c:957
#: src/main/seq.c:958 src/main/seq.c:1003 src/main/seq.c:1004
#: src/main/seq.c:1025 src/main/seq.c:1026
#, c-format
msgid "'%s' must be a finite number"
msgstr "'%s' 必須是有限的數字"

#: src/main/seq.c:853
msgid "'length.out' must be a non-negative number"
msgstr "'length.out' 必須是非負的數字"

#: src/main/seq.c:864 src/main/seq.c:871 src/main/seq.c:879
#, c-format
msgid "'%s' must be of length 1"
msgstr "'%s' 的長度必須是 1"

#: src/main/seq.c:897
msgid "invalid '(to - from)/by'"
msgstr "無效的 '(to - from)/by'"

#: src/main/seq.c:909
msgid "'by' argument is much too small"
msgstr "'by' 的引數小太多了"

#: src/main/seq.c:911
msgid "wrong sign in 'by' argument"
msgstr "在 'by' 的引數中有錯誤符號"

#: src/main/seq.c:1099 src/main/seq.c:1106
msgid "argument must be coercible to non-negative integer"
msgstr "引數必須可強制變更為非負值整數"

#: src/main/seq.c:1126
#, fuzzy
msgid "'lengths' is not of mode integer"
msgstr "引數不是字元狀態"

#: src/main/seq.c:1129
#, fuzzy
msgid "'from' is not of mode integer"
msgstr "引數不是字元狀態"

#: src/main/seq.c:1132
#, fuzzy
msgid "'by' is not of mode integer"
msgstr "引數不是字元狀態"

#: src/main/seq.c:1139
#, fuzzy
msgid "'from' has length 0, but not 'lengths'"
msgstr "群組長度為零但資料長度 > 0"

#: src/main/seq.c:1141
#, fuzzy
msgid "'by' has length 0, but not 'lengths'"
msgstr "群組長度為零但資料長度 > 0"

#: src/main/seq.c:1148
#, fuzzy
msgid "'lengths' must be a vector of non-negative integers"
msgstr "'gap' 必須是正整數"

#: src/main/seq.c:1163
msgid "'from' contains NAs"
msgstr ""

#: src/main/seq.c:1168
msgid "'by' contains NAs"
msgstr ""

#: src/main/serialize.c:268 src/main/serialize.c:315 src/main/serialize.c:339
msgid "unknown or inappropriate output format"
msgstr "不明或不適當的輸出格式"

#: src/main/serialize.c:584
msgid "must specify ascii, binary, or xdr format"
msgstr "必須設定 ascii、binary 或 xdr 格式之一"

#: src/main/serialize.c:585
msgid "unknown output format"
msgstr "不明的輸出格式"

#: src/main/serialize.c:616 src/main/serialize.c:2255
msgid "unknown input format"
msgstr "不明的輸入格式"

#: src/main/serialize.c:621
msgid "input format does not match specified format"
msgstr "輸入格式與設定的格式不符合"

#: src/main/serialize.c:834
msgid "no restore method available"
msgstr "沒有復原的方法"

#: src/main/serialize.c:876
msgid "names in persistent strings are currently ignored"
msgstr "固有字串中的名稱現在不用"

#: src/main/serialize.c:1076
#, c-format
msgid "'%s' may not be available when loading"
msgstr "載入時 '%s' 也許不能用"

#: src/main/serialize.c:1084
msgid "namespaces may not be available when loading"
msgstr "載入時命名空間也許不能用"

#: src/main/serialize.c:1224
#, c-format
msgid "WriteItem: unknown type %i"
msgstr "WriteItem：不明的類型 %i"

#: src/main/serialize.c:1411
#, c-format
msgid "version %d not supported"
msgstr "版本 %d 不支援"

#: src/main/serialize.c:1444
msgid "reference index out of range"
msgstr "參照索引超出範圍"

#: src/main/serialize.c:1474
msgid "names in persistent strings are not supported yet"
msgstr "目前不支援固有字串中的名稱"

#: src/main/serialize.c:1679
#, c-format
msgid "deserializing invalid UTF-8 string '%s'"
msgstr "正在解除序列化無效的 UTF-8 字串 '%s'"

#: src/main/serialize.c:1699
#, c-format
msgid "input string '%s' cannot be translated to UTF-8, is it valid in '%s'?"
msgstr "輸入字串 '%s' 無法翻譯為 UTF-8，它在 '%s' 之中有效嗎？"

#: src/main/serialize.c:1711
msgid "strings not representable in native encoding will not be translated"
msgstr "無法以原生編碼展現的字串將不會被翻譯"

#: src/main/serialize.c:1713
msgid ""
"strings not representable in native encoding will be translated to UTF-8"
msgstr "無法以原生編碼展現的字串將不會被翻譯為 UTF-8"

#: src/main/serialize.c:1720
#, c-format
msgid "input string '%s' cannot be translated to UTF-8, is it valid in '%s' ?"
msgstr "輸入字串 '%s' 無法翻譯為 UTF-8，它在 '%s' 之中有效嗎？"

#: src/main/serialize.c:1732
msgid "negative serialized length for vector"
msgstr "向量序列化的長度不可為負值"

#: src/main/serialize.c:1740
msgid "invalid upper part of serialized vector length"
msgstr "序列化向量長度上半部無效"

#: src/main/serialize.c:1745
msgid ""
"negative serialized vector length:\n"
"perhaps long vector from 64-bit version of R?"
msgstr ""
"負的序列化向量長度：\n"
"也許是來自 R 64 位元版本的長整數向量"

#: src/main/serialize.c:1980
msgid "this version of R cannot read class references"
msgstr "本 R 版本無法讀取類別參照"

#: src/main/serialize.c:1982
msgid "this version of R cannot read generic function references"
msgstr "本 R 版本無法讀取一般功能參照"

#: src/main/serialize.c:2011
#, c-format
msgid "ReadItem: unknown type %i, perhaps written by later version of R"
msgstr "ReadItem：不明類型 %i，也許是由後期版本的 R 所寫入"

#: src/main/serialize.c:2170 src/main/serialize.c:2261
#, fuzzy
msgid "invalid length of encoding name"
msgstr "名稱插槽的類型或長度無效"

#: src/main/serialize.c:2180
#, c-format
msgid ""
"cannot read unreleased workspace version %d written by experimental R %d.%d."
"%d"
msgstr ""
"無法從由 R 實驗版本 %2$d.%3$d.%4$d 所寫入之尚未被釋放的工作空間版本 %1$d 中讀"
"取資料"

#: src/main/serialize.c:2184
#, c-format
msgid ""
"cannot read workspace version %d written by R %d.%d.%d; need R %d.%d.%d or "
"newer"
msgstr ""
"無法從由 R 版本 %2$d.%3$d.%4$d 所寫入之工作空間版本 %1$d 中讀取資料；需要 R "
"版本 %5$d.%6$d.%7$d 或更新"

#: src/main/serialize.c:2340
msgid "read failed"
msgstr "讀取失敗"

#: src/main/serialize.c:2403
msgid "error reading from ascii connection"
msgstr "從 ascii 連接讀取時發生錯誤"

#: src/main/serialize.c:2405
msgid "unexpected format in ascii connection"
msgstr "在 ascii 連接中未預期的格式"

#: src/main/serialize.c:2410 src/main/serialize.c:2424
msgid "error reading from connection"
msgstr "從連接讀取時發生了錯誤"

#: src/main/serialize.c:2466
msgid "only ascii format can be written to text mode connections"
msgstr "只有 ascii 格式才能對文字狀態的連接進行寫入"

#: src/main/serialize.c:2480
msgid "only ascii format can be read from text mode connections"
msgstr "只有 ascii 格式才能從文字狀態的連接讀取"

#: src/main/serialize.c:2536 src/main/serialize.c:2692
#: src/main/serialize.c:2841
msgid "bad version value"
msgstr "不當的版本值"

#: src/main/serialize.c:2561
msgid "binary-mode connection required for ascii=FALSE"
msgstr "當 ascii=FASLE 時需要二進位模式連接"

#: src/main/serialize.c:2720 src/main/serialize.c:2757
#: src/main/serialize.c:2820
msgid "serialization is too large to store in a raw vector"
msgstr "序列化太大而無法儲存在純量向量中"

#: src/main/serialize.c:2737
msgid "cannot allocate buffer"
msgstr "無法配置緩衝區"

#: src/main/serialize.c:2933 src/main/serialize.c:3014
msgid "not a proper file name"
msgstr "檔案名稱不恰當"

#: src/main/serialize.c:2937
msgid "not a proper raw vector"
msgstr "非適當純量向量"

#: src/main/serialize.c:2951 src/main/serialize.c:3043
#: src/main/serialize.c:3056 src/main/serialize.c:3065
#: src/main/serialize.c:3076 src/main/serialize.c:3090
#, c-format
msgid "seek failed on %s"
msgstr "搜索 %s 失敗"

#: src/main/serialize.c:2961
msgid "could not determine file position"
msgstr "無法確定檔案位置"

#: src/main/serialize.c:3018
msgid "bad offset/length argument"
msgstr "不當的位移/長度引數"

#: src/main/serialize.c:3060 src/main/serialize.c:3069
#: src/main/serialize.c:3080 src/main/serialize.c:3094
#, c-format
msgid "read failed on %s"
msgstr "讀取 %s 失敗"

#: src/main/serialize.c:3114
msgid "bad environment"
msgstr "不當的環境"

#: src/main/serialize.c:3116
msgid "bad variable names"
msgstr "不當的變數名稱"

#: src/main/sort.c:95
msgid "only atomic vectors can be tested to be sorted"
msgstr "只有基元向量才能被試著排序"

#: src/main/sort.c:420 src/main/sort.c:1432
msgid "'decreasing' must be TRUE or FALSE"
msgstr "'increasing' 必須是 TRUE 或是 FALSE"

#: src/main/sort.c:423 src/main/sort.c:783
msgid "only atomic vectors can be sorted"
msgstr "只有基元向量才能被排序"

#: src/main/sort.c:425 src/main/sort.c:785 src/main/sort.c:1501
msgid "raw vectors cannot be sorted"
msgstr "無法排序純量向量"

#: src/main/sort.c:796
msgid "NA or infinite index"
msgstr "NA 或無限索引"

#: src/main/sort.c:799
#, c-format
msgid "index %ld outside bounds"
msgstr "索引 %ld 在界限外"

#: src/main/sort.c:804 src/main/sort.c:817
msgid "NA index"
msgstr "NA 索引"

#: src/main/sort.c:806 src/main/sort.c:819
#, c-format
msgid "index %d outside bounds"
msgstr "索引 %d 在界限外"

#: src/main/sort.c:1441
#, c-format
msgid "argument %d is not a vector"
msgstr "引數 %d 不是向量"

#: src/main/sort.c:1443
msgid "argument lengths differ"
msgstr "引數長度不同"

#: src/main/sort.c:1529
msgid "invalid ties.method for rank() [should never happen]"
msgstr "rank() 的 ties.method 無效 [這是不應該發生的]"

#: src/main/source.c:163
#, c-format
msgid "%s in \"%s\""
msgstr ""

#: src/main/source.c:167
#, c-format
msgid ""
"%s in:\n"
"\"%s\n"
"%s\""
msgstr ""

#: src/main/source.c:216
msgid "coercion of 'text' to character was unsuccessful"
msgstr "將 'text' 強制變更為字元未能成功"

#: src/main/source.c:244
msgid "argument encoding=\"latin1\" is ignored in MBCS locales"
msgstr ""

#: src/main/source.c:252
msgid "argument encoding=\"UTF-8\" is ignored in MBCS locales"
msgstr ""

#: src/main/source.c:254
#, c-format
msgid "argument '%s = \"%s\"' will be ignored"
msgstr "引數 '%s = \"%s\"' 將被忽略"

#: src/main/split.c:39
msgid "first argument must be a vector"
msgstr "第一引數必須是向量"

#: src/main/split.c:41
msgid "second argument must be a factor"
msgstr "第二引數必須是因子"

#: src/main/split.c:46
msgid "group length is 0 but data length > 0"
msgstr "群組長度為零但資料長度 > 0"

#: src/main/split.c:48
msgid "data length is not a multiple of split variable"
msgstr "資料長度不是 split 變數的倍數"

#: src/main/sprintf.c:98
#, c-format
msgid "required resulting string length %d is greater than maximal %d"
msgstr "需要的結果字串長度 %d 大於最大值 %d"

#: src/main/sprintf.c:106
msgid "'fmt' is not a character vector"
msgstr "'fmt' 並非字元向量"

#: src/main/sprintf.c:111
#, c-format
msgid "only %d arguments are allowed"
msgstr "只允許 %d 個引數"

#: src/main/sprintf.c:119
#, c-format
msgid "invalid type of argument[%d]: '%s'"
msgstr "無效的引數 [%d] 類型：'%s'"

#: src/main/sprintf.c:130 src/main/sprintf.c:133
msgid "arguments cannot be recycled to the same length"
msgstr "不是所有的引數都一樣長"

#: src/main/sprintf.c:155 src/main/sprintf.c:264
#, c-format
msgid "'fmt' length exceeds maximal format length %d"
msgstr "'fmt' 長度超出格式長度的最大值 %d"

#: src/main/sprintf.c:174
#, c-format
msgid "unrecognised format specification '%s'"
msgstr "無法辨識的格式規格 '%s'"

#: src/main/sprintf.c:185 src/main/sprintf.c:191 src/main/sprintf.c:204
#: src/main/sprintf.c:211
#, c-format
msgid "reference to non-existent argument %d"
msgstr "參照不存在的引數 %d"

#: src/main/sprintf.c:218 src/main/sprintf.c:251
msgid "too few arguments"
msgstr "引數數目太少"

#: src/main/sprintf.c:223
msgid "at most one asterisk '*' is supported in each conversion specification"
msgstr "在每個轉換規格中只支援最多一個星號 '*'"

#: src/main/sprintf.c:234
msgid "argument for '*' conversion specification must be a number"
msgstr "用於 '*' 轉換規格的引數必須是一個數字"

#: src/main/sprintf.c:274
msgid "coercion has changed vector length to 0"
msgstr "強制變更時將向量長度改為 0"

#: src/main/sprintf.c:359 src/main/sprintf.c:373 src/main/sprintf.c:387
#: src/main/sprintf.c:422
#, c-format
msgid "invalid format '%s'; %s"
msgstr "無效的格式 '%s'；%s"

#: src/main/sprintf.c:360
#, c-format
msgid "use format %d or %i for logical objects"
msgstr "邏輯物件套用格式 %d 或 %i"

#: src/main/sprintf.c:374
#, c-format
msgid "use format %d, %i, %o, %x or %X for integer objects"
msgstr "使用格式 %d, %i, %o, %x 或 %X 於整數物件"

#: src/main/sprintf.c:388
#, c-format
msgid "use format %f, %e, %g or %a for numeric objects"
msgstr "使用格式 %f, %e, %g 或 %a 於數值物件"

#: src/main/sprintf.c:423
#, c-format
msgid "use format %s for character objects"
msgstr "字元物件套用格式 %s"

#: src/main/sprintf.c:428
#, c-format
msgid "likely truncation of character string to %d characters"
msgstr "字串似乎被截斷成 %d 個字元"

#: src/main/sprintf.c:437
msgid "unsupported type"
msgstr "不支援此一類型"

#: src/main/sprintf.c:479
#, fuzzy, c-format
msgid "one argument not used by format '%s'"
msgstr "在 '%s' 中引數超出領域\n"

#: src/main/sprintf.c:481
#, fuzzy, c-format
msgid "%d arguments not used by format '%s'"
msgstr "在 '%s' 中引數超出領域\n"

#: src/main/sprintf.c:484
#, fuzzy
msgid "one argument not used by format"
msgstr "第二引數必須是因子"

#: src/main/sprintf.c:486
#, fuzzy, c-format
msgid "%d arguments not used by format"
msgstr "引數不是矩陣"

#: src/main/startup.c:69
msgid "R_LibraryFileName: buffer too small"
msgstr "R_LibraryFileName: 緩衝區太小"

#: src/main/subassign.c:142
msgid "attempt to enlarge non-vector"
msgstr "不能加大非向量"

#: src/main/subassign.c:147
#, c-format
msgid "assignment outside vector/list limits (extending from %d to %d)"
msgstr "不能在向量/串列極值外賦值(%d 加大到 %d)"

#: src/main/subassign.c:267
msgid "bad names attribute"
msgstr "不當的名稱屬性"

#: src/main/subassign.c:477
#, c-format
msgid "incompatible types (from %s to %s) in subassignment type fix"
msgstr "下標賦值 fix 類型中有不相容的類型 (從 %s 到 %s)"

#: src/main/subassign.c:653 src/main/subassign.c:960 src/main/subassign.c:1203
msgid "NAs are not allowed in subscripted assignments"
msgstr "下標賦值中不允許 NA"

#: src/main/subassign.c:673 src/main/subassign.c:970 src/main/subassign.c:1195
#: src/main/subassign.c:1834
msgid "replacement has length zero"
msgstr "置換的長度為零"

#: src/main/subassign.c:675 src/main/subassign.c:972 src/main/subassign.c:1197
msgid "number of items to replace is not a multiple of replacement length"
msgstr "被替換的項目不是替換值長度的倍數"

#: src/main/subassign.c:932
msgid "incorrect number of subscripts on matrix"
msgstr "矩陣中的下標數目不正確"

#: src/main/subassign.c:1124
#, c-format
msgid "incompatible types (from %s to %s) in matrix subset assignment"
msgstr "矩陣子集賦值中有不相容的類型 (從 %s 到 %s)"

#: src/main/subassign.c:1165 src/main/subset.c:984
msgid "incorrect number of subscripts"
msgstr "下標數目不正確"

#: src/main/subassign.c:1358
#, c-format
msgid "incompatible types (from %s to %s) in array subset assignment"
msgstr "陣列子集賦值有不相容的類型 (從 %s 到 %s)"

#: src/main/subassign.c:1384 src/main/subassign.c:1406
msgid "invalid subscript in list assign"
msgstr "串列賦值中的下標數目無效"

#: src/main/subassign.c:1399
msgid "invalid number of subscripts to list assign"
msgstr "串列賦值中的下標數目無效"

#: src/main/subassign.c:1501
msgid "SubAssignArgs: invalid number of arguments"
msgstr "SubAssignArgs: 引數數目無效"

#: src/main/subassign.c:1671
msgid "result is zero-length and so cannot be a language object"
msgstr "結果長度為零因而無法做為一個語言物件"

#: src/main/subassign.c:1786
msgid ""
"[[<- defined for objects of type \"S4\" only for subclasses of environment"
msgstr "[[<- 只有在子類別用於定義 \"S4\" 類型的物件"

#: src/main/subassign.c:1800
msgid "improper dimensions"
msgstr "維度數目不恰當"

#: src/main/subassign.c:1806
msgid "wrong args for environment subassignment"
msgstr "環境下賦值的引數不正確"

#: src/main/subassign.c:1836
msgid "more elements supplied than there are to replace"
msgstr "用來替換的元素比所要替換的值多"

#: src/main/subassign.c:1838
msgid "[[ ]] with missing subscript"
msgstr "[[ ]] 缺少下標"

#: src/main/subassign.c:1863 src/main/subassign.c:2047
msgid "[[ ]] improper number of subscripts"
msgstr "[[ ]] 下標數目不恰當"

#: src/main/subassign.c:2013
#, c-format
msgid "incompatible types (from %s to %s) in [[ assignment"
msgstr "[[ 賦值中有不相容的類型 (從 %s 到 %s)"

#: src/main/subassign.c:2142
msgid "no method for assigning subsets of this S4 class"
msgstr "沒有方法可用於指派這個 S4 類別的子集"

#: src/main/subassign.c:2211
msgid "Coercing LHS to a list"
msgstr "把公式左側強迫變成串列"

#: src/main/subscript.c:87 src/main/subscript.c:109 src/main/subscript.c:128
#: src/main/subscript.c:222 src/main/subscript.c:248
#, c-format
msgid "attempt to select less than one element in %s"
msgstr "試圖於 %s 選擇少於一個元素"

#: src/main/subscript.c:91 src/main/subscript.c:106 src/main/subscript.c:132
#: src/main/subscript.c:220 src/main/subscript.c:255 src/main/subscript.c:349
#, c-format
msgid "attempt to select more than one element in %s"
msgstr "試圖於 %s 選擇一個以上元素"

#: src/main/subscript.c:191 src/main/subscript.c:322 src/main/subscript.c:1011
#: src/main/subscript.c:1095 src/main/subset.c:1216
#, c-format
msgid "invalid subscript type '%s'"
msgstr "無效的下標類型 '%s'"

#: src/main/subscript.c:225
msgid "internal error in use of recursive indexing"
msgstr "用遞迴索引時發生了內部錯誤"

#: src/main/subscript.c:247 src/main/subscript.c:254
#, fuzzy, c-format
msgid "invalid negative subscript in %s"
msgstr "無效的下標類型 '%s'"

#: src/main/subscript.c:300
#, c-format
msgid "further partial match of '%s' to '%s'"
msgstr "進一步部分匹配 '%s' 到 '%s'"

#: src/main/subscript.c:347
#, c-format
msgid "recursive indexing failed at level %d\n"
msgstr "遞迴索引在 %d 層失敗\n"

#: src/main/subscript.c:357
#, c-format
msgid "no such index at level %d\n"
msgstr "在 %d 層沒有此一索引\n"

#: src/main/subscript.c:413
msgid "incorrect number of columns in matrix subscript"
msgstr "矩陣下標中行數不正確"

#: src/main/subscript.c:434 src/main/subscript.c:453 src/main/subscript.c:478
msgid "negative values are not allowed in a matrix subscript"
msgstr "矩陣下標中不允許負值"

#: src/main/subscript.c:515 src/main/subscript.c:1003
msgid "no 'dimnames' attribute for array"
msgstr "陣列中沒有 'dimnames' 此一屬性"

#: src/main/subscript.c:518
#, c-format
msgid "%d x %d character matrix subscript illegal for NULL dimnames"
msgstr ""

#: src/main/subscript.c:525
#, c-format
msgid ""
"subscripting by character matrix of %d columns does not match "
"length(dimnames(x)) == %d"
msgstr ""

#: src/main/subscript.c:585
msgid "(subscript) logical subscript too long"
msgstr "(下標) 邏輯下標太長"

#: src/main/subscript.c:768 src/main/subscript.c:819
msgid "only 0's may be mixed with negative subscripts"
msgstr "只有負數下標中才能有 0"

#: src/main/subscript.c:794
msgid "subscript too large for 32-bit R"
msgstr "對於 32 位元 R 版本而言下標太大"

#: src/main/subscript.c:1039
msgid "subscripting on non-vector"
msgstr "非向量不能有下標"

#: src/main/subset.c:316
msgid "dimensions would exceed maximum size of array"
msgstr "維度會超過陣列的最大尺寸"

#: src/main/subset.c:358
msgid "matrix subscripting not handled for this type"
msgstr "此一類型無法處理矩陣下標"

#: src/main/subset.c:529
msgid "array subscripting not handled for this type"
msgstr "此一類型無法處理陣列下標"

#: src/main/subset.c:881
msgid "incorrect number of dimensions"
msgstr "維度數目不正確"

#: src/main/subset.c:980
msgid "no index specified"
msgstr "沒有指定的索引"

#: src/main/subset.c:990
msgid "this S4 class is not subsettable"
msgstr "這個 S4 類別不是子集合表格"

#: src/main/subset.c:997
msgid "wrong arguments for subsetting an environment"
msgstr "取子集環境時的引數不正確"

#: src/main/summary.c:33
#, c-format
msgid "invalid 'type' (%s) of argument"
msgstr "'type' (%s) 的引數無效"

#: src/main/summary.c:116
msgid "integer overflow - use sum(as.numeric(.))"
msgstr "整數溢位 - 請使用 sum(as.numeric(.))"

#: src/main/summary.c:687
#, c-format
msgid "internal error ('op = %d' in do_summary).\t Call a Guru"
msgstr "內部錯誤 (do_summary 中的 'op = %d')。\t 請向專家請教"

#: src/main/summary.c:843
msgid "Integer overflow - use sum(as.numeric(.))"
msgstr "整數溢位 - 請使用 sum(as.numeric(.))"

#: src/main/summary.c:958
msgid "no non-missing arguments, returning NA"
msgstr "沒有非漏失的引數，回傳 NA"

#: src/main/summary.c:961
msgid "no non-missing arguments to min; returning Inf"
msgstr "min 中沒有無漏失的引數; 回傳 Inf"

#: src/main/summary.c:963
msgid "no non-missing arguments to max; returning -Inf"
msgstr "max 中沒有無漏失的引數；回傳 -Inf"

#: src/main/summary.c:1127
msgid "argument to 'which' is not logical"
msgstr "'which' 的引數不是邏輯值"

#: src/main/summary.c:1202
msgid "no arguments"
msgstr "沒有引數"

#: src/main/summary.c:1214 src/main/summary.c:1232
msgid "invalid input type"
msgstr "無效的輸入類型"

#: src/main/summary.c:1249
msgid "an argument will be fractionally recycled"
msgstr "某個引數將被部分重新利用"

#: src/main/sysutils.c:71 src/main/sysutils.c:85
#, c-format
msgid "cannot determine file modification time of '%s'"
msgstr "無法確定檔案 '%s' 的修改時間"

#: src/main/sysutils.c:175
msgid "encoding of a filename cannot be 'bytes'"
msgstr "檔名的編碼不可以是 'bytes'"

#: src/main/sysutils.c:178 src/main/sysutils.c:886 src/main/sysutils.c:901
#: src/main/sysutils.c:1108 src/main/sysutils.c:1174
#, c-format
msgid "unsupported conversion from '%s' in codepage %d"
msgstr "不支援在編碼頁 %2$d 中來自 '%1$s' 的轉換"

#: src/main/sysutils.c:187
msgid "file name conversion problem -- name too long?"
msgstr "檔案名稱轉換問題 -- 名稱太長？"

#: src/main/sysutils.c:188
msgid "file name conversion problem"
msgstr "檔案名稱轉換問題"

#: src/main/sysutils.c:262
msgid "invalid filename pattern"
msgstr "檔案名稱胚騰無效"

#: src/main/sysutils.c:266
msgid "invalid file extension"
msgstr "無效的副檔名"

#: src/main/sysutils.c:268
msgid "no 'pattern'"
msgstr "沒有 'pattern'"

#: src/main/sysutils.c:270
msgid "no 'tempdir'"
msgstr "沒有 'tempdir'"

#: src/main/sysutils.c:272
msgid "no 'fileext'"
msgstr "沒有 'fileext'"

#: src/main/sysutils.c:342 src/unix/sys-unix.c:647
#, c-format
msgid "system call failed: %s"
msgstr "系統呼叫失敗：%s"

#: src/main/sysutils.c:369 src/main/sysutils.c:372 src/main/sysutils.c:463
#: src/main/sysutils.c:465 src/main/sysutils.c:501
msgid "wrong type for argument"
msgstr "引數類型不正確"

#: src/main/sysutils.c:467
msgid "wrong length for argument"
msgstr "引數的長度錯誤"

#: src/main/sysutils.c:488
msgid "'Sys.setenv' is not available on this system"
msgstr "這個系統無法使用 'Sys.setenv'"

#: src/main/sysutils.c:532
msgid "this system cannot unset environment variables: setting to \"\""
msgstr "這個系統無法解除設定環境變數：設定為 \"\""

#: src/main/sysutils.c:543
msgid "'Sys.unsetenv' is not available on this system"
msgstr "這個系統無法使用 'Sys.unsetenv'"

#: src/main/sysutils.c:642
#, c-format
msgid "unsupported conversion from '%s' to '%s' in codepage %d"
msgstr "在編碼頁 %3$d 中不支援從 '%1$s' 轉換到 '%2$s'"

#: src/main/sysutils.c:658
msgid "'x' must be a character vector"
msgstr "'x' 必須是字元向量"

#: src/main/sysutils.c:675
msgid "'x' must be a character vector or a list of NULL or raw vectors"
msgstr "'x' 必須是字元向量、空值串列或純量向量串列"

#: src/main/sysutils.c:781 src/main/sysutils.c:1075 src/main/sysutils.c:1244
#, c-format
msgid "'%s' must be called on a CHARSXP"
msgstr "'%s' 必須於 CHARSXP 之上被呼叫"

#: src/main/sysutils.c:853 src/main/sysutils.c:1097 src/main/sysutils.c:1163
#: src/main/sysutils.c:1247
msgid "translating strings with \"bytes\" encoding is not allowed"
msgstr "不允許以 \"bytes\" 編碼的翻譯字串"

#: src/main/sysutils.c:867
msgid "internal error: no translation needed"
msgstr "內部錯誤：不需要翻譯"

#: src/main/sysutils.c:966 src/main/sysutils.c:970
#, fuzzy, c-format
msgid "unable to translate '%s' to native encoding"
msgstr "無法寫入剪貼簿"

#: src/main/sysutils.c:982 src/main/sysutils.c:1002 src/main/sysutils.c:1023
#: src/main/sysutils.c:1042 src/main/sysutils.c:1091 src/main/sysutils.c:1157
#, c-format
msgid "'%s' must be called on a CHARSXP, but got '%s'"
msgstr "'%s' 必須於 CHARSXP 之上被呼叫，但卻是於 '%s'"

#: src/main/sysutils.c:1206
#, fuzzy, c-format
msgid "unable to translate '%s' to UTF-8"
msgstr "無法解析 '%s'"

#: src/main/sysutils.c:1278
#, c-format
msgid "unsupported conversion to '%s' from codepage %d"
msgstr "不支援從編碼頁 %2$d 轉換到 '%1$s'"

#: src/main/sysutils.c:1712
#, c-format
msgid "invalid Unicode point %u"
msgstr "無效的萬國碼位 %u"

#: src/main/sysutils.c:1821
msgid "'R_TempDir' contains space"
msgstr ""

#: src/main/sysutils.c:1830
msgid "cannot create 'R_TempDir'"
msgstr "無法建立 R_TempDir"

#: src/main/sysutils.c:1835 src/main/sysutils.c:1843 src/main/sysutils.c:1846
msgid "unable to set R_SESSION_TMPDIR"
msgstr "無法設定 R_SESSION_TMPDIR"

#: src/main/sysutils.c:1855
msgid "cannot allocate 'R_TempDir'"
msgstr "無法配置 R_TempDir"

#: src/main/sysutils.c:1896
msgid "temporary name too long"
msgstr "暫時名稱太長"

#: src/main/sysutils.c:1911
msgid "cannot find unused tempfile name"
msgstr "暫時檔名已用盡"

#: src/main/sysutils.c:1914
msgid "allocation failed in R_tmpnam2"
msgstr "在 R_tmpnam2 中配置失敗"

#: src/main/sysutils.c:2098
msgid "'dirmark = TRUE' is not supported on this platform"
msgstr "這個平臺不支援 'dirmark = TRUE'"

#: src/main/unique.c:447 src/main/unique.c:450
#, c-format
msgid "length %d is too large for hashing"
msgstr "用雜亂定址法時長度 %d 太長"

#: src/main/unique.c:647 src/main/unique.c:833 src/main/unique.c:980
#: src/main/unique.c:1010 src/main/unique.c:1049
msgid "'duplicated' applies only to vectors"
msgstr "'duplicated' 只適用於向量"

#: src/main/unique.c:1054
msgid "any_duplicated3(., <0-length incomp>)"
msgstr "any_duplicated3(., <長度零不相容>)"

#: src/main/unique.c:1103
msgid "'fromLast' must be length 1"
msgstr "'fromLast' 的長度必須是 1"

#: src/main/unique.c:1106
msgid "'fromLast' must be TRUE or FALSE"
msgstr "'fromLast' 必須是 TRUE 或 FALSE"

#: src/main/unique.c:1116
#, c-format
msgid "%s() applies only to vectors"
msgstr "%s() 只適用於向量"

#: src/main/unique.c:1124
msgid "'nmax' must be positive"
msgstr "'nmax' 必須是正值"

#: src/main/unique.c:1496
msgid "'match' requires vector arguments"
msgstr "'match' 需要向量引數"

#: src/main/unique.c:1545 src/main/unique.c:1683
msgid "argument is not of mode character"
msgstr "引數不是字元狀態"

#: src/main/unique.c:1806
msgid "... used in a situation where it does not exist"
msgstr "... 用在了它不存在的地方"

#: src/main/unique.c:1812
msgid "... is not a pairlist"
msgstr "... 不是一個成對串列"

#: src/main/unique.c:2045
msgid "non-numeric data frame in rowsum"
msgstr "rowsum 中不能有非數值資料框"

#: src/main/unique.c:2080
msgid "this cannot happen"
msgstr "這不可能發生"

#: src/main/unique.c:2151
msgid "'names' must be a character vector"
msgstr "'names' 必須是字元向量"

#: src/main/util.c:81 src/main/util.c:99
msgid "object is not a matrix"
msgstr "物件不是矩陣"

#: src/main/util.c:297 src/main/util.c:309 src/main/util.c:320
#: src/main/util.c:333
#, c-format
msgid "type %d is unimplemented in '%s'"
msgstr "'%2$s' 中尚未實作類型 %1$d"

#: src/main/util.c:344
#, c-format
msgid "unimplemented type '%s' in '%s'\n"
msgstr "類型 '%s' 尚未在 '%s' 中實作\n"

#: src/main/util.c:346
#, c-format
msgid "unimplemented type (%d) in '%s'\n"
msgstr "(%d) 類型尚未在 '%s' 中實作\n"

#: src/main/util.c:472
msgid "invalid tag in name extraction"
msgstr "抽取名稱的標記無效"

#: src/main/util.c:489
#, c-format
msgid "%d argument passed to '%s' which requires %d"
msgid_plural "%d arguments passed to '%s' which requires %d"
msgstr[0] "傳遞了 %d 個引數給 '%s' 但它需要 %d 個"

#: src/main/util.c:503
#, c-format
msgid "supplied argument name '%s' does not match '%s'"
msgstr "給定引數名稱 '%s' 不匹配 '%s'"

#: src/main/util.c:513
#, c-format
msgid "'nthcdr' list shorter than %d"
msgstr "'nthcdr' 串列比 %d 要短"

#: src/main/util.c:518
msgid "'nthcdr' needs a list to CDR down"
msgstr "'nthcdr' 需要 CDR 向下串列"

#: src/main/util.c:667
msgid "'all.x' must be TRUE or FALSE"
msgstr "'all.x' 必須是 TRUE 或 FALSE"

#: src/main/util.c:669
msgid "'all.y' must be TRUE or FALSE"
msgstr "'all.y' 必須是 TRUE 或 FALSE"

#: src/main/util.c:698
msgid "number of rows in the result exceeds maximum vector length"
msgstr "結果的列數超過了向量長度的最大值"

#: src/main/util.c:790
msgid "missing value is invalid"
msgstr "缺少值為無效"

#: src/main/util.c:799 src/main/util.c:806
msgid "cannot change working directory"
msgstr "無法變更工作目錄"

#: src/main/util.c:826 src/main/util.c:859 src/main/util.c:900
#: src/main/util.c:943 src/main/util.c:1110 src/main/util.c:1189
#: src/main/util.c:1215
msgid "a character vector argument expected"
msgstr "需要字元向量引數"

#: src/main/util.c:1124
msgid "only the first character of 'quote' will be used"
msgstr "只用了 'quote' 的第一個字元"

#: src/main/util.c:1217
msgid "a character vector 'value' expected"
msgstr "預期有一個字元向量 'value'"

#: src/main/util.c:1220
msgid "'value' must be of positive length"
msgstr "'value' 必須是正值的長度"

#: src/main/util.c:1382 src/main/util.c:1395
#, c-format
msgid "invalid input '%s' in 'utf8towcs'"
msgstr "在 'utf8towcs' 中無效的輸入'%s'"

#: src/main/util.c:1415 src/main/util.c:1425
#, fuzzy, c-format
msgid "invalid input '%s' in 'utf8towcs32'"
msgstr "在 'utf8towcs' 中無效的輸入'%s'"

#: src/main/util.c:1545
#, c-format
msgid "invalid multibyte string at '%s'"
msgstr "無效的多位元組字串於 '%s'"

#: src/main/util.c:1734
msgid "error message truncated to 255 chars"
msgstr "錯誤訊息截短到 255 個位元組"

#: src/main/util.c:1752
msgid "warning message truncated to 255 chars"
msgstr "警告訊息截短到 255 個位元組"

#: src/main/util.c:1924
#, fuzzy
msgid "Conversion failed"
msgstr "不當的版本值"

#: src/main/util.c:2042
#, c-format
msgid "accuracy loss in conversion from \"%s\" to numeric"
msgstr "從 \"%s\" 轉換到數值時失去了準確度"

#: src/main/util.c:2364
msgid "all arguments must be named"
msgstr "所有屬性必須被命名"

#: src/main/util.c:2503
msgid "ICU is not supported on this build"
msgstr "這個組建不支援 ICU"

#: src/main/util.c:2570
msgid "'breaks' is not sorted"
msgstr "'breaks' 未被排序"

#: src/main/util.c:2604 src/main/util.c:2667
#, c-format
msgid "long vector '%s' is not supported"
msgstr "長整數向量 '%s' 未被支援"

#: src/main/util.c:2725
msgid "'eps.correct' must be 0, 1, or 2"
msgstr "'eps.correct' 必須是 0, 1 或 2"

#: src/main/util.c:2728
#, fuzzy
msgid "'bounds' must be TRUE or FALSE"
msgstr "'onOff' 必須是 TRUE 或 FALSE"

#: src/main/util.c:2768
msgid "'x' must be a vector"
msgstr "'x' 必須是向量"

#: src/main/version.c:37
msgid ""
"R is free software and comes with ABSOLUTELY NO WARRANTY.\n"
"You are welcome to redistribute it under certain conditions.\n"
"Type 'license()' or 'licence()' for distribution details.\n"
"\n"
msgstr ""
"R 是自由軟體，不提供任何擔保。\n"
"在某些條件下歡迎您將其散佈。\n"
"用 'license()' 或 'licence()' 來獲得散佈的詳細條件。\n"
"\n"

#: src/main/version.c:40
msgid ""
"R is a collaborative project with many contributors.\n"
"Type 'contributors()' for more information and\n"
"'citation()' on how to cite R or R packages in publications.\n"
"\n"
msgstr ""
"R 是個協作計劃，有許多人為之做出了貢獻。\n"
"用 'contributors()' 來看詳細的情況以及\n"
"用 'citation()' 會告訴您如何在出版品中正確地參照 R 或 R 套件。\n"
"\n"

#: src/main/version.c:43
msgid ""
"Type 'demo()' for some demos, 'help()' for on-line help, or\n"
"'help.start()' for an HTML browser interface to help.\n"
"Type 'q()' to quit R.\n"
"\n"
msgstr ""
"用 'demo()' 來看一些示範程式，用 'help()' 來檢視線上輔助檔案，或\n"
"用 'help.start()' 透過 HTML 瀏覽器來看輔助檔案。\n"
"用 'q()' 離開 R。\n"
"\n"

#: src/main/xspline.c:60
#, c-format
msgid "add_point - reached MAXNUMPTS (%d)"
msgstr "add_point - 已達到 MAXNUMPTS (%d)"

#: src/main/xspline.c:74
msgid "insufficient memory to allocate point array"
msgstr "配置點陣列時記憶體不足"

#: src/main/xspline.c:472
msgid "there must be at least two control points"
msgstr "至少必須有兩個控制點"

#: src/main/xspline.c:474
msgid "there must be at least four control points"
msgstr "至少必須有四個控制點"

#: src/main/xspline.c:534
msgid "There must be at least three control points"
msgstr "至少必須有三個控制點"

#: src/modules/X11/dataentry.c:1876 src/modules/X11/devX11.c:1255
#, c-format
msgid "X11 protocol error: %s"
msgstr "X11 協定錯誤：%s"

#: src/modules/X11/devX11.c:467
msgid "cannot set grayscale: reverting to monochrome"
msgstr "無法設定灰階: 轉用黑白顏色"

#: src/modules/X11/devX11.c:553
msgid ""
"X11 driver unable to obtain color cube\n"
"  reverting to monochrome"
msgstr "X11 驅動程式無法開啟顏色方塊，轉用黑白顏色"

#: src/modules/X11/devX11.c:601
msgid ""
"Error: X11 cannot allocate additional graphics colors.\n"
"Consider using X11 with colortype=\"pseudo.cube\" or \"gray\"."
msgstr ""
"錯誤：X11 無法配置額外的圖案顏色。\n"
"請考慮用 colortype=\"pseudo.cube\" 或 \"gray\" 選項來呼叫 X11。"

#: src/modules/X11/devX11.c:1036
msgid ""
"could not find any X11 fonts\n"
"Check that the Font Path is correct."
msgstr ""
"找不到任何 X11 字型\n"
"請檢查字型路徑設得是不是對。"

#: src/modules/X11/devX11.c:1096
#, c-format
msgid "X11 used font size %d when %d was requested"
msgstr "X11 用了字型大小 %d 但需要的是 %d"

#: src/modules/X11/devX11.c:1130
#, c-format
msgid "X11 font %s, face %d at size %d could not be loaded"
msgstr "X11 字型 %s，字體 %d 於大小 %d 時無法載入"

#: src/modules/X11/devX11.c:1139
msgid ""
"semi-transparency is not supported on this device: reported only once per "
"page"
msgstr "這個裝置不支援半透明：每頁只會通報一次"

#: src/modules/X11/devX11.c:1263
#, c-format
msgid "X11 I/O error while opening X11 connection to '%s'"
msgstr "當開啟 X11 連線到 '%s' 時 X11 I/O 錯誤"

#: src/modules/X11/devX11.c:1280
msgid "X11 fatal IO error: please save work and shut down R"
msgstr "X11 致命的 IO 錯誤: 請儲存工作資料，然後重新啟動 R"

#: src/modules/X11/devX11.c:1335
msgid "locale not supported by Xlib: some X ops will operate in C locale"
msgstr "Xlib 不支援語區環境: 某些 X 作業指令將在 C 語區環境中啟動"

#: src/modules/X11/devX11.c:1336
msgid "X cannot set locale modifiers"
msgstr "X 無法設定語區環境修飾器"

#: src/modules/X11/devX11.c:1340
msgid "no png support in this version of R"
msgstr "這個版本的 R 不支援 png"

#: src/modules/X11/devX11.c:1346
msgid "filename too long in png() call"
msgstr "png() 呼叫時檔案名稱太長"

#: src/modules/X11/devX11.c:1350
#, c-format
msgid "could not open PNG file '%s'"
msgstr "無法開啟 PNG 檔案 '%s'"

#: src/modules/X11/devX11.c:1362
msgid "no jpeg support in this version of R"
msgstr "這個版本的 R 不支援 jpeg"

#: src/modules/X11/devX11.c:1372
msgid "filename too long in jpeg() call"
msgstr "jpeg() 呼叫時檔案名稱太長"

#: src/modules/X11/devX11.c:1376
#, c-format
msgid "could not open JPEG file '%s'"
msgstr "無法開啟 JPEG 檔案 '%s'"

#: src/modules/X11/devX11.c:1388
msgid "no tiff support in this version of R"
msgstr "這個版本的 R 不支援 tiff"

#: src/modules/X11/devX11.c:1396
msgid "filename too long in tiff() call"
msgstr "tiff() 呼叫時檔案名稱太長"

#: src/modules/X11/devX11.c:1408
msgid "filename too long in bmp() call"
msgstr "bmp() 呼叫時檔案名稱太長"

#: src/modules/X11/devX11.c:1412
#, c-format
msgid "could not open BMP file '%s'"
msgstr "無法開啟 BMP 檔案 '%s'"

#: src/modules/X11/devX11.c:1442
#, c-format
msgid "unable to open connection to X11 display '%s'"
msgstr "無法開啟連接到 X11 顯示 '%s'"

#: src/modules/X11/devX11.c:1452
msgid "ignoring 'display' argument as an X11 device is already open"
msgstr "某個 X11 裝置已經開啟因而忽略 'display' 引數"

#: src/modules/X11/devX11.c:1458
msgid "cairo-based types may only work correctly on TrueColor visuals"
msgstr "基於 cairo 的類型只會在 TrueColor 視訊中正常作用"

#: src/modules/X11/devX11.c:1468
msgid "jpeg() does not support transparency: using white bg"
msgstr "jpeg() 不支援透明繪圖：使用白色背景"

#: src/modules/X11/devX11.c:1573
#, c-format
msgid "unable to obtain information on display '%s'"
msgstr "無法在顯示 '%s' 上得到資訊"

#: src/modules/X11/devX11.c:1591
msgid "unable to create X11 window"
msgstr "無法建立 X11 視窗"

#: src/modules/X11/devX11.c:1742
#, c-format
msgid "'width=%d, height=%d' are unlikely values in pixels"
msgstr "'寬度=%d, 高度=%d' 是不太可能的像素值"

#: src/modules/X11/devX11.c:1747
msgid "unable to create pixmap"
msgstr "無法建立像素圖"

#: src/modules/X11/devX11.c:1778
msgid "invalid font specification"
msgstr "字型設定無效"

#: src/modules/X11/devX11.c:1818
msgid "font family not found in X11 font database"
msgstr "X11 字型資料庫中沒有此一字型家族"

#: src/modules/X11/devX11.c:1857
#, c-format
msgid "invalid use of %d < 0 in '%s'"
msgstr "在 '%2$s' 中使用 %1$d < 0 是無效的"

#: src/modules/X11/devX11.c:1978
#, c-format
msgid "could not open file '%s'"
msgstr "無法開啟檔案 '%s'"

#: src/modules/X11/devX11.c:2213
#, c-format
msgid "%s not available for this device"
msgstr "這個裝置無法使用 %s "

#: src/modules/X11/devX11.c:2358
msgid "Unable to create XImage"
msgstr "無法建立 XImage"

#: src/modules/X11/devX11.c:2557
msgid "attempt to use the locator after dev.hold()"
msgstr "於 dev.hold() 之後試圖使用定位器"

#: src/modules/X11/devX11.c:3205
#, c-format
msgid "unable to start device %s"
msgstr "無法開啟裝置 %s"

#: src/modules/X11/devX11.c:3237
msgid "invalid 'width' or 'height'"
msgstr "'width' 或 'height' 無效"

#: src/modules/X11/devX11.c:3244
msgid "invalid colortype passed to X11 driver"
msgstr "傳給 X11 驅動器的顏色類型無效"

#: src/modules/X11/devX11.c:3258
msgid "unknown X11 color/colour model -- using monochrome"
msgstr "沒有這種 X11 顏色/顏色模型 -- 使用黑白顏色"

#: src/modules/X11/devX11.c:3356
msgid "no plot on device to save"
msgstr "裝置上沒有插槽可以儲存"

#: src/modules/X11/devX11.c:3358
msgid "not an open X11cairo device"
msgstr "不是一個開啟的 X11cairo 裝置"

#: src/modules/X11/devX11.c:3367
#, c-format
msgid "cannot open file '%s'"
msgstr "無法開啟檔案 '%s'"

#: src/modules/X11/devX11.c:3384
msgid "savePlot() is not supported on this build"
msgstr "這次組建並未支援 savePlot()"

#: src/modules/X11/devX11.c:3424
msgid "unable to contact X11 display"
msgstr "無法連接到 X11 顯示"

#: src/modules/X11/devX11.c:3473
#, c-format
msgid "clipboard cannot be read (error code %d)"
msgstr "無法讀取剪貼簿 (錯誤碼 %d)"

#: src/modules/X11/devX11.c:3509
msgid "cannot allocate memory for X11Routines structure"
msgstr "無法為 X11Routines 結構配置記憶體"

#: src/modules/internet/internet.c:94
msgid ""
"the 'wininet' method of url() is deprecated for http:// and https:// URLs"
msgstr ""

#: src/modules/internet/internet.c:116
msgid "the 'wininet' method of url() is deprecated for ftp:// URLs"
msgstr ""

#: src/modules/internet/internet.c:127 src/modules/internet/internet.c:519
#, c-format
msgid "scheme not supported in URL '%s'"
msgstr "網址 '%s' 不支援方案格式"

#: src/modules/internet/internet.c:202 src/modules/internet/internet.c:206
#: src/modules/internet/internet.c:212 src/modules/internet/internet.c:232
#: src/modules/internet/internet.c:240 src/modules/internet/libcurl.c:957
#: src/modules/internet/libcurl.c:961 src/modules/internet/libcurl.c:968
#: src/modules/internet/libcurl.c:982 src/modules/internet/libcurl.c:991
#: src/modules/internet/libcurl.c:1001
msgid "allocation of url connection failed"
msgstr "網址連接配置失敗"

#: src/modules/internet/internet.c:326
msgid "only first element of 'url' argument used"
msgstr "只用 'url' 引數的第一個元素"

#: src/modules/internet/internet.c:332
msgid "only first element of 'destfile' argument used"
msgstr "只用 'destfile' 引數的第一個元素"

#: src/modules/internet/internet.c:353 src/modules/internet/libcurl.c:624
msgid "Download progress"
msgstr "正在下載"

#: src/modules/internet/internet.c:378
#, c-format
msgid "cannot open URL '%s', reason '%s'"
msgstr "無法開啟網址 '%s' ，原因是 '%s'"

#: src/modules/internet/internet.c:385 src/modules/internet/internet.c:415
#, c-format
msgid "cannot open destfile '%s', reason '%s'"
msgstr "無法開啟目標檔案 '%s' ，原因是 '%s'"

#: src/modules/internet/internet.c:396
msgid "the 'internal' method for http:// URLs is defunct"
msgstr ""

#: src/modules/internet/internet.c:404
msgid "the 'wininet' method is deprecated for http:// and https:// URLs"
msgstr ""

#: src/modules/internet/internet.c:420 src/modules/internet/libcurl.c:655
#, c-format
msgid "trying URL '%s'\n"
msgstr "嘗試 URL '%s'\n"

#: src/modules/internet/internet.c:504 src/modules/internet/libcurl.c:713
#, c-format
msgid "downloaded length %0.f != reported length %0.f"
msgstr "下載的長度 %0.f != 所通報的長度 %0.f"

#: src/modules/internet/internet.c:510 src/modules/internet/libcurl.c:740
#, c-format
msgid "cannot open URL '%s'"
msgstr "無法開啟網址 '%s'"

#: src/modules/internet/internet.c:515
msgid "the 'wininet' method for ftp:// URLs is defunct"
msgstr ""

#: src/modules/internet/internet.c:517
msgid "the 'internal' method for ftp:// URLs is defunct"
msgstr ""

#: src/modules/internet/internet.c:570 src/modules/internet/internet.c:584
#: src/modules/internet/internet.c:676 src/modules/internet/internet.c:685
#, c-format
msgid "InternetOpenUrl failed: '%s'"
msgstr "InternetOpenUrl 失敗: '%s'"

#: src/modules/internet/internet.c:599 src/modules/internet/libcurl.c:217
#, c-format
msgid "cannot open URL '%s': %s status was '%d %s'"
msgstr "無法開啟網址 '%s': %s 狀態是 '%d %s'"

#: src/modules/internet/libcurl.c:222
#, c-format
msgid "URL '%s': Timeout of %d seconds was reached"
msgstr ""

#: src/modules/internet/libcurl.c:225
#, c-format
msgid "URL '%s': status was '%s'"
msgstr "網址 '%s': 狀態是 '%s'"

#: src/modules/internet/libcurl.c:321
msgid "curlGetHeaders is not supported on this platform"
msgstr "本平臺不支援 curlGetHeaders"

#: src/modules/internet/libcurl.c:382 src/modules/internet/libcurl.c:384
#, c-format
msgid ""
"libcurl error code %d:\n"
"\t%s\n"
msgstr ""
"libcurl 錯誤碼 %d:\n"
"\t%s\n"

#: src/modules/internet/libcurl.c:524
msgid "download.file(method = \"libcurl\") is not supported on this platform"
msgstr "本平臺不支援 download.file(method = \"libcurl\")"

#: src/modules/internet/libcurl.c:540
msgid "lengths of 'url' and 'destfile' must match"
msgstr "'url' 和 'destfile' 的長度必須相符"

#: src/modules/internet/libcurl.c:560 src/modules/internet/libcurl.c:578
msgid "out of memory"
msgstr ""

#: src/modules/internet/libcurl.c:606
#, c-format
msgid "URL %s: cannot open destfile '%s', reason '%s'"
msgstr "網址 %s：無法開啟目標檔案 '%s' ，原因是 '%s'"

#: src/modules/internet/libcurl.c:736
msgid "cannot download any files"
msgstr "無法下載任何檔案"

#: src/modules/internet/libcurl.c:737
msgid "some files were not downloaded"
msgstr "一些檔案並未被下載"

#: src/modules/internet/libcurl.c:742
#, c-format
msgid "download from '%s' failed"
msgstr "從 '%s' 下載時失敗"

#: src/modules/internet/libcurl.c:885
msgid "cannot read from connection"
msgstr "無法從此連接讀取"

#: src/modules/internet/libcurl.c:927
#, c-format
msgid "cannot open the connection to '%s'"
msgstr "無法開啟到 '%s' 的連接"

#: src/modules/internet/libcurl.c:1008
msgid "url(method = \"libcurl\") is not supported on this platform"
msgstr "本平臺不支援 url(method = \"libcurl\")"

#: src/modules/internet/sockconn.c:201 src/modules/internet/sockconn.c:205
#: src/modules/internet/sockconn.c:212 src/modules/internet/sockconn.c:226
msgid "allocation of socket connection failed"
msgstr "配置承接座連接失敗"

#: src/modules/internet/sockconn.c:242 src/modules/internet/sockconn.c:246
#: src/modules/internet/sockconn.c:253 src/modules/internet/sockconn.c:261
#, fuzzy
msgid "allocation of server socket connection failed"
msgstr "配置承接座連接失敗"

#: src/modules/internet/sockconn.c:270
#, c-format
msgid "creation of server socket failed: port %d cannot be opened"
msgstr ""

#: src/modules/lapack/Lapack.c:66 src/modules/lapack/Lapack.c:85
#, c-format
msgid "argument type[1]='%s' must be a character string of string length 1"
msgstr "引數 type[1]='%s' 必須是長度為 1 的字串"

#: src/modules/lapack/Lapack.c:74
#, c-format
msgid "argument type[1]='%s' must be one of 'M','1','O','I','F' or 'E'"
msgstr "引數 type[1]='%s' 必須是 'M','1','O','I','F' 或 'E' 之一"

#: src/modules/lapack/Lapack.c:91
#, c-format
msgid "argument type[1]='%s' must be one of '1','O', or 'I'"
msgstr "引數 type[1]='%s' 必須是 '1', 'O' 或 'I' 之一"

#: src/modules/lapack/Lapack.c:131 src/modules/lapack/Lapack.c:138
#: src/modules/lapack/Lapack.c:197 src/modules/lapack/Lapack.c:208
#: src/modules/lapack/Lapack.c:289 src/modules/lapack/Lapack.c:295
#: src/modules/lapack/Lapack.c:631 src/modules/lapack/Lapack.c:637
#: src/modules/lapack/Lapack.c:691 src/modules/lapack/Lapack.c:698
#: src/modules/lapack/Lapack.c:703 src/modules/lapack/Lapack.c:738
#: src/modules/lapack/Lapack.c:745 src/modules/lapack/Lapack.c:794
#: src/modules/lapack/Lapack.c:801 src/modules/lapack/Lapack.c:849
#: src/modules/lapack/Lapack.c:855 src/modules/lapack/Lapack.c:910
#: src/modules/lapack/Lapack.c:917 src/modules/lapack/Lapack.c:1155
#: src/modules/lapack/Lapack.c:1161 src/modules/lapack/Lapack.c:1207
#: src/modules/lapack/Lapack.c:1214 src/modules/lapack/Lapack.c:1219
#: src/modules/lapack/Lapack.c:1247 src/modules/lapack/Lapack.c:1254
#: src/modules/lapack/Lapack.c:1274
#, c-format
msgid "error code %d from Lapack routine '%s'"
msgstr "錯誤程式碼 %d，Lapack 常式 '%s'"

#: src/modules/lapack/Lapack.c:168 src/modules/lapack/Lapack.c:262
#: src/modules/lapack/Lapack.c:889
msgid "'x' must be a square numeric matrix"
msgstr "'x' 必須是正方形的數值矩陣"

#: src/modules/lapack/Lapack.c:339 src/modules/lapack/Lapack.c:369
#: src/modules/lapack/Lapack.c:418
msgid "'A' must be a numeric matrix"
msgstr "'A' 必須是數值矩陣"

#: src/modules/lapack/Lapack.c:341
msgid "'type' must be a character string"
msgstr "'type' 必須是字串"

#: src/modules/lapack/Lapack.c:371 src/modules/lapack/Lapack.c:419
#: src/modules/lapack/Lapack.c:455 src/modules/lapack/Lapack.c:512
msgid "'norm' must be a character string"
msgstr "'norm' 必須是字串"

#: src/modules/lapack/Lapack.c:391
#, c-format
msgid "error [%d] from Lapack 'dgetrf()'"
msgstr "錯誤 [%d] 來自 Lapack 'dgetrf()'"

#: src/modules/lapack/Lapack.c:396
#, c-format
msgid "exact singularity: U[%d,%d] = 0 in LU-decomposition {Lapack 'dgetrf()'}"
msgstr ""
"精確的奇異性：U[%d,%d] = 0 於 LU-decomposition {Lapack 'dgetrf()'} 之中"

#: src/modules/lapack/Lapack.c:408
#, c-format
msgid "error [%d] from Lapack 'dgecon()'"
msgstr "錯誤 [%d] 來自 Lapack 'dgecon()'"

#: src/modules/lapack/Lapack.c:428 src/modules/lapack/Lapack.c:460
#: src/modules/lapack/Lapack.c:518
msgid "'A' must be a *square* matrix"
msgstr "'A' 必須是 *正方形* 矩陣"

#: src/modules/lapack/Lapack.c:442
#, c-format
msgid "error [%d] from Lapack 'dtrcon()'"
msgstr "錯誤 [%d] 來自 Lapack 'dtrcon()'"

#: src/modules/lapack/Lapack.c:457 src/modules/lapack/Lapack.c:514
msgid "'A' must be a complex matrix"
msgstr "'A' 必須是複數矩陣"

#: src/modules/lapack/Lapack.c:479 src/modules/lapack/Lapack.c:486
#, c-format
msgid "error [%d] from Lapack 'zgetrf()'"
msgstr "錯誤 [%d] 來自 Lapack 'zgetrf()'"

#: src/modules/lapack/Lapack.c:494
#, c-format
msgid "error [%d] from Lapack 'zgecon()'"
msgstr "錯誤 [%d] 來自 Lapack 'zgecon()'"

#: src/modules/lapack/Lapack.c:498 src/modules/lapack/Lapack.c:533
#: src/modules/lapack/Lapack.c:602 src/modules/lapack/Lapack.c:662
#: src/modules/lapack/Lapack.c:707 src/modules/lapack/Lapack.c:749
#: src/modules/lapack/Lapack.c:815 src/modules/lapack/Lapack.c:872
#: src/modules/lapack/Lapack.c:934
msgid "Fortran complex functions are not available on this platform"
msgstr "本平臺不能使用 Fortran 複數功能"

#: src/modules/lapack/Lapack.c:530
#, c-format
msgid "error [%d] from Lapack 'ztrcon()'"
msgstr "錯誤 [%d] 來自 Lapack 'ztrcon()'"

#: src/modules/lapack/Lapack.c:546 src/modules/lapack/Lapack.c:616
msgid "'a' must be a complex matrix"
msgstr "'a' 必須是複數矩陣"

#: src/modules/lapack/Lapack.c:549 src/modules/lapack/Lapack.c:1061
msgid "'a' is 0-diml"
msgstr "'a' 是 0-diml"

#: src/modules/lapack/Lapack.c:551 src/modules/lapack/Lapack.c:1063
#, c-format
msgid "'a' (%d x %d) must be square"
msgstr "'a' (%d x %d) 必須是正方形的"

#: src/modules/lapack/Lapack.c:557 src/modules/lapack/Lapack.c:1069
msgid "no right-hand side in 'b'"
msgstr "'b' 在等號右側沒有公式"

#: src/modules/lapack/Lapack.c:560 src/modules/lapack/Lapack.c:574
#: src/modules/lapack/Lapack.c:1072 src/modules/lapack/Lapack.c:1088
#, c-format
msgid "'b' (%d x %d) must be compatible with 'a' (%d x %d)"
msgstr "'b' (%d x %d) 必須與 'a' (%d x %d) 相容"

#: src/modules/lapack/Lapack.c:595 src/modules/lapack/Lapack.c:965
#: src/modules/lapack/Lapack.c:980 src/modules/lapack/Lapack.c:1036
#: src/modules/lapack/Lapack.c:1110
#, c-format
msgid "argument %d of Lapack routine %s had invalid value"
msgstr "Lapack 常式 %2$s 的引數 %1$d 具有無效的值"

#: src/modules/lapack/Lapack.c:598
#, fuzzy
msgid "Lapack routine zgesv: system is exactly singular"
msgstr "Lapack 常式 %s: 系統正好是奇異的：U[%d,%d] = 0"

#: src/modules/lapack/Lapack.c:676 src/modules/lapack/Lapack.c:722
msgid "'b' must be a complex matrix"
msgstr "'b' 必須是複數矩陣"

#: src/modules/lapack/Lapack.c:684 src/modules/lapack/Lapack.c:731
#: src/modules/lapack/Lapack.c:1199 src/modules/lapack/Lapack.c:1240
#, c-format
msgid "right-hand side should have %d not %d rows"
msgstr "公式右側應該有 %d 而不是 %d 列"

#: src/modules/lapack/Lapack.c:758
msgid "'jobu' must be a character string"
msgstr "'jobu' 必須是字串"

#: src/modules/lapack/Lapack.c:766
msgid "matrices of 2^31 or more elements are not supported"
msgstr "不支援具有 2^31 以上元素的矩陣"

#: src/modules/lapack/Lapack.c:831
msgid "'x' must be a square complex matrix"
msgstr "'x' 必須是正方形複數矩陣"

#: src/modules/lapack/Lapack.c:943 src/modules/lapack/Lapack.c:1019
#: src/modules/lapack/Lapack.c:1058 src/modules/lapack/Lapack.c:1135
#: src/modules/lapack/Lapack.c:1265
msgid "'a' must be a numeric matrix"
msgstr "'a' 必須是數值矩陣"

#: src/modules/lapack/Lapack.c:950 src/modules/lapack/Lapack.c:1270
msgid "'a' must be a square matrix"
msgstr "'a' 必須是正方形矩陣"

#: src/modules/lapack/Lapack.c:951
msgid "'a' must have dims > 0"
msgstr "'a' 必須有 dims > 0"

#: src/modules/lapack/Lapack.c:963
#, c-format
msgid "the leading minor of order %d is not positive definite"
msgstr "序列 %d 前置的次要符號並非肯定明確"

#: src/modules/lapack/Lapack.c:978
msgid "the matrix is either rank-deficient or indefinite"
msgstr "矩陣若非等級匱乏就是不明確的"

#: src/modules/lapack/Lapack.c:1006
msgid "'size' argument must be a positive integer"
msgstr "'size' 引數必須是正整數"

#: src/modules/lapack/Lapack.c:1021
#, c-format
msgid "'size' cannot exceed ncol(x) = %d"
msgstr "'size' 不能超過 ncol(x)=%d"

#: src/modules/lapack/Lapack.c:1022
#, c-format
msgid "'size' cannot exceed nrow(x) = %d"
msgstr "'size' 不能超過 nrow(x)=%d"

#: src/modules/lapack/Lapack.c:1034
#, c-format
msgid "element (%d, %d) is zero, so the inverse cannot be computed"
msgstr "元素 (%d,%d) 為零，因此無法逆向求值"

#: src/modules/lapack/Lapack.c:1113
#, c-format
msgid "Lapack routine %s: system is exactly singular: U[%d,%d] = 0"
msgstr "Lapack 常式 %s: 系統正好是奇異的：U[%d,%d] = 0"

#: src/modules/lapack/Lapack.c:1123
#, c-format
msgid "system is computationally singular: reciprocal condition number = %g"
msgstr "系統計算上是奇異的: 互反條件數 = %g"

#: src/modules/lapack/Lapack.c:1190 src/modules/lapack/Lapack.c:1232
msgid "'b' must be a numeric matrix"
msgstr "'b' 必須是數值矩陣"

#: src/modules/lapack/Lapack.c:1266
msgid "argument 'logarithm' must be logical"
msgstr "引數 'logarithm' 必須是邏輯值"

#: src/nmath/bessel_i.c:69
msgid "bessel_i allocation error"
msgstr "bessel_i 配置錯誤"

#: src/nmath/bessel_i.c:77 src/nmath/bessel_i.c:122
#, c-format
msgid "bessel_i(%g): ncalc (=%d) != nb (=%d); alpha=%g. Arg. out of range?\n"
msgstr "bessel_i(%g): ncalc (=%d) != nb (=%d); alpha=%g. 引數在範圍外？\n"

#: src/nmath/bessel_i.c:80 src/nmath/bessel_i.c:125
#, c-format
msgid "bessel_i(%g,nu=%g): precision lost in result\n"
msgstr "bessel_i(%g,nu=%g): 結果的精確度有損害\n"

#: src/nmath/bessel_j.c:64 src/nmath/bessel_j.c:118
#, c-format
msgid "besselJ(x, nu): nu=%g too large for bessel_j() algorithm"
msgstr "besselJ(x, nu): nu=%g 對於 bessel_j() 演算法而言太大"

#: src/nmath/bessel_j.c:72
msgid "bessel_j allocation error"
msgstr "bessel_j 配置錯誤"

#: src/nmath/bessel_j.c:80 src/nmath/bessel_j.c:127
#, c-format
msgid "bessel_j(%g): ncalc (=%d) != nb (=%d); alpha=%g. Arg. out of range?\n"
msgstr "bessel_j(%g): ncalc (=%d) != nb (=%d); alpha=%g. 引數在範圍外？\n"

#: src/nmath/bessel_j.c:83 src/nmath/bessel_j.c:130
#, c-format
msgid "bessel_j(%g,nu=%g): precision lost in result\n"
msgstr "bessel_j(%g,nu=%g): 結果的精確度有損害\n"

#: src/nmath/bessel_k.c:63
msgid "bessel_k allocation error"
msgstr "bessel_k 配置錯誤"

#: src/nmath/bessel_k.c:71 src/nmath/bessel_k.c:108
#, c-format
msgid "bessel_k(%g): ncalc (=%d) != nb (=%d); alpha=%g. Arg. out of range?\n"
msgstr "bessel_k(%g): ncalc (=%d) != nb (=%d); alpha=%g. 引數在範圍外？\n"

#: src/nmath/bessel_k.c:74 src/nmath/bessel_k.c:111
#, c-format
msgid "bessel_k(%g,nu=%g): precision lost in result\n"
msgstr "bessel_k(%g,nu=%g): 結果的精確度有損害\n"

#: src/nmath/bessel_y.c:63 src/nmath/bessel_y.c:125
#, c-format
msgid "besselY(x, nu): nu=%g too large for bessel_y() algorithm"
msgstr "besselY(x, nu): nu=%g 對於 bessel_y() 演算法而言太大"

#: src/nmath/bessel_y.c:71
msgid "bessel_y allocation error"
msgstr "bessel_y 配置錯誤"

#: src/nmath/bessel_y.c:87 src/nmath/bessel_y.c:136
#, c-format
msgid "bessel_y(%g): ncalc (=%d) != nb (=%d); alpha=%g. Arg. out of range?\n"
msgstr "bessel_y(%g): ncalc (=%d) != nb (=%d); alpha=%g. 引數在範圍外？\n"

#: src/nmath/bessel_y.c:90 src/nmath/bessel_y.c:139
#, c-format
msgid "bessel_y(%g,nu=%g): precision lost in result\n"
msgstr "bessel_y(%g,nu=%g): 結果的精確度有損害\n"

#: src/nmath/choose.c:79 src/nmath/choose.c:122
#, c-format
msgid "'k' (%.2f) must be integer, rounded to %.0f"
msgstr "'k' (%.2f) 必須是整數，四捨五入至 %.0f"

#: src/nmath/nmath.h:157
#, c-format
msgid "argument out of domain in '%s'\n"
msgstr "在 '%s' 中引數超出領域\n"

#: src/nmath/nmath.h:160
#, c-format
msgid "value out of range in '%s'\n"
msgstr "在 '%s' 中的值超出範圍\n"

#: src/nmath/nmath.h:163
#, c-format
msgid "convergence failed in '%s'\n"
msgstr "在 '%s' 中收斂失敗\n"

#: src/nmath/nmath.h:166
#, c-format
msgid "full precision may not have been achieved in '%s'\n"
msgstr "在 '%s' 中可能尚未達到完全精確\n"

#: src/nmath/nmath.h:169
#, c-format
msgid "underflow occurred in '%s'\n"
msgstr "下限溢位發生於 '%s'\n"

#: src/nmath/pbeta.c:64
#, c-format
msgid "pbeta_raw(%g, a=%g, b=%g, ..) -> bratio() gave error code %d"
msgstr "pbeta_raw(%g, a=%g, b=%g, ..) -> bratio() 産生錯誤碼 %d"

#: src/nmath/pnbinom.c:82
#, c-format
msgid "pnbinom_mu() -> bratio() gave error code %d"
msgstr "pnbinom_mu() -> bratio() 産生錯誤碼 %d"

#: src/nmath/pnchisq.c:304
#, fuzzy, c-format
msgid "pnchisq(x=%g, f=%g, theta=%g, ..): not converged in %d iter."
msgstr "pnchisq(x=%g, ..): %d 次循環後還沒有聚合。"

#: src/nmath/polygamma.c:499
#, c-format
msgid "deriv = %d > %d (= n_max)\n"
msgstr "deriv = %d > %d (= n_max)\n"

#: src/nmath/rmultinom.c:78
#, c-format
msgid "rbinom: probability sum should be 1, but is %g"
msgstr "rbinom: 機率和應該為 1，而不是 %g"

#: src/nmath/signrank.c:77
msgid "signrank allocation error"
msgstr "signrank 配置錯誤"

#: src/nmath/snorm.c:326
#, c-format
msgid "norm_rand(): invalid N01_kind: %d\n"
msgstr "norm_rand(): N01_kind: %d 無效\n"

#: src/nmath/wilcox.c:85 src/nmath/wilcox.c:95 src/nmath/wilcox.c:148
#: src/nmath/wilcox.c:313
#, c-format
msgid "wilcox allocation error %d"
msgstr "wilcox 配置錯誤 %d"

#: src/unix/X11.c:54
msgid "X11 module is not available under this GUI"
msgstr "本 GUI 中沒有 X11 模組"

#: src/unix/X11.c:60
msgid "X11 routines cannot be accessed in module"
msgstr "模組中沒有此一 X11 常式"

#: src/unix/X11.c:78 src/unix/X11.c:90 src/unix/X11.c:102 src/unix/X11.c:113
msgid "X11 module cannot be loaded"
msgstr "無法載入 X11 模組"

#: src/unix/X11.c:144 src/unix/X11.c:150 src/unix/X11.c:156 src/unix/X11.c:162
msgid "X11 is not available"
msgstr "無法使用 X11"

#: src/unix/dynload.c:108
msgid ""
"Explicit local dynamic loading not supported on this platform. Using default."
msgstr "本系統不支援明確的本地動態載入。使用預設值。"

#: src/unix/dynload.c:109
msgid ""
"Explicit global dynamic loading not supported on this platform. Using "
"default."
msgstr "本系統不支援明確的全局動態載入。使用預設值。"

#: src/unix/dynload.c:110
msgid ""
"Explicit non-lazy dynamic loading not supported on this platform. Using "
"default."
msgstr "本系統不支援明確的非緩慢動態載入。使用預設值。"

#: src/unix/dynload.c:111
msgid ""
"Explicit lazy dynamic loading not supported on this platform. Using default."
msgstr "本系統不支援明確的緩慢動態載入。使用預設值。"

#: src/unix/dynload.c:202
msgid "cannot get working directory!"
msgstr "找不到工作目錄"

#: src/unix/sys-std.c:586
msgid ""
"An unusual circumstance has arisen in the nesting of readline input. Please "
"report using bug.report()"
msgstr "巢狀 readline 輸入出了不尋常的錯，請用 bug.report()"

#: src/unix/sys-std.c:1229 src/unix/sys-std.c:1398
#, c-format
msgid "problem in saving the history file '%s'"
msgstr "儲存歷史檔案 '%s' 時出了問題"

#: src/unix/sys-std.c:1305
#, c-format
msgid ""
"Cannot open file '%s': %s\n"
"\n"
msgstr ""
"無法開啟檔案 '%s' ：%s\n"
"\n"

#: src/unix/sys-std.c:1313 src/unix/sys-unix.c:795 src/unix/sys-unix.c:832
#: src/unix/system.c:582
msgid "error in running command"
msgstr "執行命令時發生錯誤"

#: src/unix/sys-std.c:1369 src/unix/sys-std.c:1392
msgid "'file' argument is too long"
msgstr "'file' 引數太長"

#: src/unix/sys-std.c:1375 src/unix/sys-std.c:1377
msgid "no history mechanism available"
msgstr "沒有歷史功能"

#: src/unix/sys-std.c:1404
msgid "problem in truncating the history file"
msgstr "截斷歷史檔案時發生問題"

#: src/unix/sys-std.c:1406 src/unix/sys-std.c:1408
msgid "no history available to save"
msgstr "沒有可以儲存的歷史紀錄"

#: src/unix/sys-std.c:1420
msgid "invalid timestamp"
msgstr "時間戳記無效"

#: src/unix/sys-unix.c:670
#, c-format
msgid "running command '%s' had status %d and error message '%s'"
msgstr "執行命令 '%s' 時出現狀態 %d 和錯誤訊息 '%s'"

#: src/unix/sys-unix.c:685
msgid "non-empty character argument expected"
msgstr "需要非空字元引數"

#: src/unix/sys-unix.c:688
msgid "'intern' must be logical and not NA"
msgstr "'intern' 必須是邏輯值且非無定義"

#: src/unix/sys-unix.c:733
#, c-format
msgid "cannot popen '%s', probable reason '%s'"
msgstr "無法 popen '%s' ，可能的原因是 '%s'"

#: src/unix/sys-unix.c:747
#, c-format
msgid "line %d may be truncated in call to system(, intern = TRUE)"
msgstr "第 %d 列也許在呼叫 system(, intern = TRUE) 時被截斷"

#: src/unix/sys-unix.c:793
#, c-format
msgid "error in running command: '%s'"
msgstr "執行命令時發生錯誤：'%s'"

#: src/unix/sys-unix.c:911
msgid "Sys.info() is not implemented on this system"
msgstr "本系統沒有實作 Sys.info() 此一功能"

#: src/unix/system.c:357
#, c-format
msgid "WARNING: --gui or -g without value ignored"
msgstr "警告: --gui 或 -g 選項沒有值，因此忽略不用"

#: src/unix/system.c:375
#, c-format
msgid "WARNING: unknown gui '%s', using X11\n"
msgstr "警告: 沒有這種 gui '%s', 使用 X11\n"

#: src/unix/system.c:378
#, c-format
msgid "WARNING: unknown gui '%s', using none\n"
msgstr "警告: 沒有這種 gui '%s', 因此什麼都不用\n"

#: src/unix/system.c:414
#, c-format
msgid "path given in -f/--file is too long"
msgstr ""

#: src/unix/system.c:486
msgid "creating temporary file for '-e' failed"
msgstr "為 '-e' 建立暫存檔時失敗"

#: src/unix/system.c:572
msgid "WARNING: Only editing the first in the list of files"
msgstr "警告: 只修改檔案串列中的第一個元素"

#~ msgid "incorrect argument"
#~ msgstr "引數不正確"

#~ msgid "don't be silly!: your machine has a 4Gb address limit"
#~ msgstr "別傻了！：您的機器有 4Gb 的位址上限"

#~ msgid "cannot decrease memory limit: ignored"
#~ msgstr "無法減少記憶體限制：已忽略"

#~ msgid "invalid input in 'Rmbstowcs'"
#~ msgstr "Rmbstowcs 中的輸入無效"

#, c-format
#~ msgid "WARNING: R_MAX_MEM_SIZE value is invalid: ignored\n"
#~ msgstr "警告：R_MAX_MEM_SIZE 值無效：已忽略\n"

#~ msgid "WARNING: no max-mem-size given\n"
#~ msgstr "警告: max-mem-size 沒有定義\n"

#, c-format
#~ msgid "WARNING: --max-mem-size value is invalid: ignored\n"
#~ msgstr "警告: --max-mem-size 值無效: 忽略不用\n"

#, c-format
#~ msgid "WARNING: --max-mem-size=%lu%c: too large and ignored\n"
#~ msgstr "警告：--max-mem-size=%lu%c：太大因而忽略\n"

#, c-format
#~ msgid "WARNING: --max-mem-size=%4.1fM: too small and ignored\n"
#~ msgstr "警告：--max-mem-size=%4.1fM：太小因而忽略\n"

#, c-format
#~ msgid "WARNING: --max-mem-size=%4.0fM: too large and taken as %uM\n"
#~ msgstr "警告：--max-mem-size=%4.0fM：太大因而視為 %uM\n"

#, fuzzy, c-format
#~ msgid "relative range of values (%4.0f * EPS) is small (axis %d)"
#~ msgstr "相對範圍值 =%4.0f * EPS太小 (座標 %d)"

#~ msgid "zero-length inputs cannot be mixed with those of non-zero length"
#~ msgstr "長度為零的輸入無法與長度非零者混合"

#~ msgid "[[ ]] subscript out of bounds"
#~ msgstr "[[ ]] 下標在界限外"

#, c-format
#~ msgid "[[ ]] subscript (%d) out of bounds"
#~ msgstr "[[ ]] 下標 (%d) 在界限外"

#~ msgid "nc = 0 for non-null data"
#~ msgstr "nc = 0 出現於非空值資料"

#~ msgid "nr = 0 for non-null data"
#~ msgstr "nr = 0 出現於非空值資料"

#~ msgid "for https:// URLs use method = \"wininet\""
#~ msgstr "對於 https:// URLs 使用 method = \"wininet\""

#, fuzzy
#~ msgid "could not allocate memory for http headers"
#~ msgstr "無法為 'read.dcf' 配置記憶體"

#~ msgid "removing FTP proxy info"
#~ msgstr "刪除 FTP 代理主機資訊"

#, c-format
#~ msgid "using FTP proxy '%s'"
#~ msgstr "用 FTP 代理主機 '%s'"

#~ msgid "cannot resolve host"
#~ msgstr "無法分辨主機"

#~ msgid "Malformed address resolved"
#~ msgstr "解析出異常的位址"

#~ msgid "failed to connect to server"
#~ msgstr "連線不上伺服器"

#~ msgid "failed to get response from server"
#~ msgstr "伺服器沒有反應"

#~ msgid "RxmlNanoFTPGetConnection: failed to create socket"
#~ msgstr "RxmlNanoFTPGetConnection: 建立承接座失敗"

#~ msgid "failed to create a data connection"
#~ msgstr "建立資料連接失敗"

#~ msgid "failed to bind a port"
#~ msgstr "連線通訊埠失敗"

#, c-format
#~ msgid "could not listen on port %d"
#~ msgstr "無法從通訊埠 %d 聽取資料"

#~ msgid "removing HTTP proxy info"
#~ msgstr "刪除 HTTP 代理主機資訊"

#, c-format
#~ msgid "using HTTP proxy '%s'"
#~ msgstr "使用 HTTP 代理主機 '%s'"

#, c-format
#~ msgid "unable to resolve '%s'"
#~ msgstr "無法解析 '%s'"

#, c-format
#~ msgid "connected to '%s' on port %d."
#~ msgstr "透過通訊埠 %2$d 接通到 '%1$s'。"

#, c-format
#~ msgid "unable to connect to '%s' on port %d."
#~ msgstr "無法透過通訊埠 %2$d 連線到 '%1$s'。"

#, c-format
#~ msgid "\"internal\" method cannot handle https redirection to: '%s'"
#~ msgstr "\"internal\" 方法無法處理 https 重新導向至：'%s'"

#, c-format
#~ msgid "redirect to: '%s'"
#~ msgstr "重新導向到: '%s'"

#~ msgid "too many redirects, aborting ..."
#~ msgstr "太多重新導向，中斷工作 …"

#~ msgid "(list) object cannot be coerced to type '%s'"
#~ msgstr "(串列) 物件無法強制變更成 '%s'"

#~ msgid "(symbol) object cannot be coerced to type '%s'"
#~ msgstr "(符號) 物件無法強制變更成 '%s'"

#~ msgid "as.call(<character string>)  not yet implemented"
#~ msgstr "as.call(<character string>) 尚未實作"

#~ msgid "'con' is not a rawConnection"
#~ msgstr "'con' 並非 rawConnection"

#~ msgid "'con' is not a textConnection"
#~ msgstr "'con' 並非 textConnection"

#~ msgid "only first string in char vector used in .Fortran"
#~ msgstr ".Fortran 只用了位元組向量中的第一個字串"

#~ msgid "invalid cached value in R_GetGlobalCache"
#~ msgstr "R_GetGlobalCache 中的快取值無效"

#~ msgid "integer stack overflow"
#~ msgstr "整數堆疊向上溢位"

#~ msgid "unable to allocate buffer for long string at line %d"
#~ msgstr "無法配置緩衝區給第 %d 列的長字串"

#~ msgid "invalid split pattern '%s'"
#~ msgstr "split 的胚騰 '%s' 無效"

#~ msgid "invalid 'width' parameter, allowed %d...%d"
#~ msgstr "無效的 'width' 參數，允許 %d...%d"

#~ msgid "'expressions' parameter invalid, allowed %d...%d"
#~ msgstr "'expressions' 參數無效，允許 %d...%d"

#~ msgid "non-string argument to internal 'paste'"
#~ msgstr "內部 'paste' 的引數不是字串"

#~ msgid "first argument must be atomic"
#~ msgstr "第一個引數必須是基元"

#~ msgid "problem reading dir %ls: %s"
#~ msgstr "讀取目錄 %ls 時出了問題：%s"

#~ msgid "over-long path length"
#~ msgstr "過長的路徑長度"

#~ msgid "non-function argument to .Internal(print.function(.))"
#~ msgstr ".Internal (print.function(.)) 的非函式引數"

#~ msgid "invalid 'tryS4' internal argument"
#~ msgstr "'tryS4' 內部引數無效"

#~ msgid "interrupt handler must not return"
#~ msgstr "插斷處理常式不能有回傳值"
