# # File R_HOME/src/library/methods/po/R-ko.po
# # Managed by Chel Hee Lee (Korean, R Development Translation Team)
# # Email <gnustats@gmail.com> or <chl948@mail.usask.ca>
# # Copyright 1995-2012 R Core Team & R Develoment Translation Team
# # Distributed under GPL 2 or later
# #
msgid ""
msgstr ""
"Project-Id-Version: R 2.3.0\n"
"Report-Msgid-Bugs-To: bugs@r-project.org\n"
"POT-Creation-Date: 2012-04-25 14:04\n"
"PO-Revision-Date: 2005-05-30 21:04+0900\n"
"Last-Translator: Chel Hee Lee <chl948@mail.usask.ca>\n"
"Language-Team: The Korean R Translation Council <gnustats@gmail.com>\n"
"Language: ko\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"

msgid "replacement value is not a matrix"
msgstr "치환값은 행렬이 아닙니다"

msgid "OOPS: something wrong with line"
msgstr ""

msgid "in .OldClassesPrototypes"
msgstr ""

msgid ""
"unnamed argument to initialize() for S3 class must have a class definition; "
"%s does not"
msgstr ""

msgid ""
"unnamed argument must extend either the S3 class or the class of the data "
"part; not true of class %s"
msgstr ""

#, fuzzy
msgid ""
"Class %s does not have an S3 data part, and so is of type \"S4\"; no S3 "
"equivalent"
msgstr "클래스 \"%s\"는 데이터 일부(.Data slot)를 정해지지 않습니다"

msgid ""
"Class %s is VIRTUAL; not meaningful to create an S4 object from this class"
msgstr ""

msgid "Object must be a valid data part for class %s; not true of type %s"
msgstr ""

msgid "Cannot specify matrix() arguments when specifying .Data"
msgstr ""

msgid "Cannot specify array() arguments when specifying .Data"
msgstr ""

msgid "Can't have more than one unnamed argument as environment"
msgstr ""

msgid "Unnamed argument to new() must be an environment for the new object"
msgstr ""

#, fuzzy
msgid ""
"methods may not be defined for primitive function %s in this version of R"
msgstr ""
"메소드는 R의 버전으로 최초의 함수 '%s' 때문애 정해지지 않을지도 모릅니다"

msgid ""
"S3Part() is only defined for classes set up by setOldCLass(), basic classes "
"or subclasses of these:  not true of class %s"
msgstr ""

#, fuzzy
msgid "The S3Class argument must be a superclass of %s:  not true of class %s"
msgstr ""
"첫번째 인수는 generic 함수(클래스 \"%s\"의 오브젝트를 얻을수 있습니다)의 이름"
"이어야만\n"
"합니다"

#, fuzzy
msgid "Replacement value must extend class %s, got %s"
msgstr "치환값은 행렬이 아닙니다"

#, fuzzy
msgid "Replacement value must be of class \""
msgstr "치환값은 행렬이 아닙니다"

msgid "\", got one of class \""
msgstr ""

msgid "\""
msgstr ""

#, fuzzy
msgid "no 'replace' method was defined for as(x, \"%s\") <- value for class %s"
msgstr ""
"클래스 \"%s\"에 적당한 값(x,\"%s\")때문에 'replace'가 없는 메소드가 정의 되었"
"습니다"

#, fuzzy
msgid ""
"the 'coerce' argument to 'setIs' should be a function of one argument, got "
"an object of class %s"
msgstr ""
"'setIs'에서 'coerce' 인수는 하나의 인수함수이어야만 합니다,\n"
"클래스 \"%s\" 오브젝트를 얻었습니다"

msgid ""
"the computation: as(object,\"%s\") <- value is valid when object has class "
"%s only if is(value, \"%s\") is TRUE (class(value) was %s)"
msgstr ""

#, fuzzy
msgid ""
"there is no automatic definition for as(object, \"%s\") <- value when object "
"has class %s and no 'replace' argument was supplied; replacement will be an "
"error"
msgstr ""
"(오브젝트, \"%s\")때문에 자동 정의는 없습니다 <- 오브젝트가 클래스 \n"
"\"%s\"를 가지고 있다면, 값 그리고 'replace' 인수를 주어집니다; 치환은 에러가 "
"되어질것입니다"

#, fuzzy
msgid ""
"the 'replace' argument to setIs() should be a function of 2 or 3 arguments, "
"got an object of class %s"
msgstr ""
"setIs()에서의 'replace' 인수는 2개 또는 3개 인수 함수이어야만 합니다, \n"
"클래스 \"%s\"의 오브젝트를 얻었습니다"

msgid "the member classes must be defined: not true of %s"
msgstr "member 클래스는 정해지지 않으면 안됩니다: %s에 정확하지 않습니다"

msgid "unable to create union class:  could not set members %s"
msgstr "union 클래스를 작성할 수 없습니다: members %s를 세트 할수가 없습니다"

msgid "invalid argument \"name\": %s"
msgstr ""

#, fuzzy
msgid ""
"%s is a primitive function;  methods can be defined, but the generic "
"function is implicit, and cannot be changed."
msgstr ""
"'%s'는 최초의 함수입니다; 메소드는 정해질 수가 있습니다, 그러나 일반적인 함수"
"는 내재하거나, \n"
"변경할수가 없습니다"

#, fuzzy
msgid ""
"if the 'def' argument is supplied, it must be a function that calls "
"standardGeneric(\"%s\") or is the default"
msgstr ""
"'def' 인수이 주어진다면, 그것은 메소드를 dispatch를 위해서 standGeneric(\"%s"
"\")를\n"
"호출 함수가 아니면 되지 않습니다"

#, fuzzy
msgid ""
"must supply a function skeleton for %s, explicitly or via an existing "
"function"
msgstr ""
"분명히 또는 기존의 함수에 의해 기능 골격을 주어지지 않으면 되지 않습니다"

msgid ""
"Creating a generic function for %s from %s in %s\n"
"    (from the saved implicit definition)"
msgstr ""

#, fuzzy
msgid "Creating a new generic function for %s in %s"
msgstr "'%s'으로 '%s'를 위해서 새로운 generic 함수를 작성합니다"

msgid ""
"No generic version of %s on package %s is allowed;\n"
"   a new generic will be assigned for %s"
msgstr ""

#, fuzzy
msgid "function %s appears to be a generic function, but with generic name %s"
msgstr "함수'%s'는 일반명 '%s'로 이외에, 일반적인 함수인 것처럼 보입니다"

#, fuzzy
msgid "generic function %s not found for removal"
msgstr "제거를 위해서 검색되지 않은 generic 함수 '%s' 입니다"

#, fuzzy
msgid ""
"internal error: did not get a valid generic function object for function %s"
msgstr ""
"내부의 에러: 함수'%s'의 유효한 일반적인 함수 대상을 얻지 않게 해주십시오"

msgid "A function for argument \"f\" must be a generic function"
msgstr ""

#, fuzzy
msgid "the environment %s is locked; cannot assign methods for function %s"
msgstr ""
"환경'%s'는 lock(락)이 되었습니다; '%s'함수를 위한 메소드 지정할수가 없습니다"

msgid ""
"the 'where' environment (%s) is a locked namespace; cannot assign methods "
"there"
msgstr ""
"'where'환경(%s)은 락(lock)된 namespace 입니다; 그 메소드를 \n"
"할당 할수가 없습니다"

#, fuzzy
msgid ""
"copying the generic function %s to environment %s, because the previous "
"version was in a sealed namespace (%s)"
msgstr ""
"전 버전이 밀폐한 namespace(%s)에 있었으므로, 환경'%s'에\n"
"일반적인 함수'%s'에 복사합니다"

#, fuzzy
msgid "no existing definition for function %s"
msgstr "함수'%s'를 위한 기존의 정의가 아닙니다"

#, fuzzy
msgid "Creating a generic function from function %s in %s"
msgstr "'%s'으로 '%s'를 위해서 새로운 generic 함수를 작성합니다"

#, fuzzy
msgid "Creating a generic function for %s from package %s in %s"
msgstr "'%s'으로 '%s'를 위해서 새로운 generic 함수를 작성합니다"

#, fuzzy
msgid ""
"apparent internal error: a generic function was found for \"%s\", but no "
"corresponding object was found searching from \"%s\""
msgstr ""
"명백한 내부 에러: generic 함수는 '%s'를 위해서 검색되었습니다, 그러나\n"
"대응하는 오브젝트는 '%s'로부터 검색한다는것을 알수가 없었습니다"

#, fuzzy
msgid ""
"the method for function %s and signature %s is sealed and cannot be re-"
"defined"
msgstr "함수'%s' 또는 기호 %s의 메소드는 밀폐되어 다시 정의할수가 없습니다"

#, fuzzy
msgid ""
"For function %s, signature \"%s\": argument in method definition changed "
"from (%s) to (%s)"
msgstr "(%s)에서(%s)부터 변경되어진 정의 인수입니다"

msgid ""
"primitive functions cannot be methods; they must be enclosed in a regular "
"function"
msgstr ""
"primitive 함수는 메소드일 수가 없습니다; 그것들은 reqular 함수로 포함되어야"
"만\n"
"합니다"

#, fuzzy
msgid ""
"invalid method definition: expected a function, got an object of class %s"
msgstr "무효인 메소드 정의: 함수를 예측해서 클래스 '%s'의 대상을 얻었습니다"

msgid "Function supplied as argument \"f\" must be a generic"
msgstr ""

#, fuzzy
msgid "no generic function %s found"
msgstr "'%s'가 검색되어 일반적인 함수가 아닙니다"

#, fuzzy
msgid "no method found for function %s and signature %s"
msgstr "함수'%s' 그리고 기호 %s 때문에 검색되는 메소드가 아닙니다"

msgid "no environment or package corresponding to argument where=%s"
msgstr ""

#, fuzzy
msgid "No generic function found for \"%s\""
msgstr "'%s'를 위해서 검색되어진 generic 함수가 아닙니다"

#, fuzzy
msgid "No method found for function \"%s\" and signature %s"
msgstr "함수'%s' 그리고 기호 %s 때문에 검색되는 메소드가 아닙니다"

msgid "Warning:  using defunct methods list search"
msgstr ""

#, fuzzy
msgid ""
"apparent inconsistency in the methods for function %s; argument %s in the "
"signature corresponds to %s in the methods list object"
msgstr ""
"함수'%s'의 메소드는 명백한 모순입니다; 인수'%s'가 기호로 메소드 리스트 오브젝"
"트에서\n"
"'%s'에 대응합니다"

#, fuzzy
msgid ""
"no S4 method for function %s and signature %s; consider getS3method() if you "
"wanted the S3 method"
msgstr ""
"함수'%s' 또는 기호 %s의 S4 메소드가 없습니다; S3의 메소드를 원한다면, "
"getS3method()를 \n"
"고려해야합니다"

#, fuzzy
msgid ""
"no method defined in methods list object for function %s and signature %s"
msgstr "함수 '%s'와 기호 %s를 위해서 정해지는 메소드가 아닙니다"

msgid "'file' must be a character string or a connection"
msgstr ""

msgid ""
"argument \"signature\" is not meaningful with the current implementation and "
"is ignored \n"
"(extract a subset of the methods list instead)"
msgstr ""

#, fuzzy
msgid "No method for %s matches class %s"
msgstr "generic '%s'때문에 검색되는 메소드가 아닙니다"

#, fuzzy
msgid "No method found for signature %s"
msgstr "generic '%s'때문에 검색되는 메소드가 아닙니다"

#, fuzzy
msgid "\"%s\" has no methods defined"
msgstr "'%s'는 메소드를 정해두지 않습니다"

msgid "selectMethod(): mlist is not an environment or NULL :"
msgstr ""

msgid "** should no longer happen!"
msgstr ""

msgid ""
"bad class specified for element %d (should be a single character string)"
msgstr ""
"요소 %d (하나의 문자열이 아니면 안됩니다) 때문에 지정되는 \n"
"잘못된 클래스입니다"

#, fuzzy
msgid ""
"first argument should be the name(s) of generic functions (got object of "
"class %s)"
msgstr ""
"첫번째 인수는 generic 함수(클래스 \"%s\"의 오브젝트를 얻을수 있습니다)의 이름"
"이어야만\n"
"합니다"

#, fuzzy
msgid "\"%s\" is not an S4 generic function in \"%s\"; methods not removed"
msgstr "'%s'는 '%s'의 일반적인 함수가 아닙니다; 제거되지 않는 메소드입니다"

#, fuzzy
msgid "cannot remove methods for %s in locked environment/package %s"
msgstr "락(lock)된 환경/패키지에 '%s'의 전 버전을 회복 할수가 없는 '%s'입니다"

#, fuzzy
msgid "restoring default function definition of \"%s\""
msgstr "'%s'의 default 함수 정의를 회복시킵니다"

#, fuzzy
msgid ""
"error in updating S4 generic function %s; the function definition is not an "
"S4 generic function (class %s)"
msgstr ""
"generic 함수 '%s'를 갱신하는데 에러가 있습니다; \n"
"generic 함수(클래스 \"%s\")가 아닙니다"

#, fuzzy
msgid "function %s is already a group generic; no change"
msgstr "함수 '%s'는 이미 group generic 입니다; 변화가 없습니다"

#, fuzzy
msgid "function %s is a group generic; do not call it directly"
msgstr ""
"함수 '%s'는 group generic 입니다; 직접 그것을 호출하지 않도록 해주십시오"

msgid ""
"'callGeneric' with a primitive needs explicit arguments (no formal args "
"defined)"
msgstr ""
"primitive에 의한 'callGeneric'로부터 명시적인 인수(정의 된 형식상의 args는 없"
"습니다)를\n"
"필요로 합니다"

msgid "'callGeneric' must be called from a generic function or method"
msgstr ""
"'callGeneric'는 generic 함수 또는 메소드로부터 호출되지 않으면 안됩니다"

msgid "expected a non-empty character string for argument name"
msgstr ""

#, fuzzy
msgid "generic function supplied was not created for \"%s\""
msgstr "'%s'를 위해서 검색되어진 generic 함수가 아닙니다"

#, fuzzy
msgid "\"%s\" is a primitive function; its generic form cannot be redefined"
msgstr "\"class\"는 예약의 slot명이어서 다시 정의 될 수가 없습니다"

msgid ""
"\"%s\" is not currently a generic:  define it first to create a non-default "
"implicit form"
msgstr ""

#, fuzzy
msgid "Must provide an environment table; got class %s"
msgstr "환경이 클래스 \"%s\"를 포함하고 있는것을 검색할수가 없습니다"

#, fuzzy
msgid "Original function is prohibited as a generic function"
msgstr "'%s'는 일반적인 함수(또는 여기서 보이지 않습니다)가 아닙니다"

msgid "not both functions!"
msgstr ""

msgid "Classes: %s, %s"
msgstr ""

msgid "argument %s is not S4"
msgstr ""

msgid "Formal arguments differ (in default values?)"
msgstr ""

msgid "Formal arguments differ: (%s), (%s)"
msgstr ""

msgid ","
msgstr ","

msgid "Value classes differ: %s, %s"
msgstr ""

msgid "Signatures differ:  (%s), (%s)"
msgstr ""

msgid "Package slots  differ: %s, %s"
msgstr ""

msgid "Groups differ: %s, %s"
msgstr ""

msgid "Generic names differ: %s, %s"
msgstr ""

#, fuzzy
msgid ""
"argument %s must be a generic function or a single character string; got an "
"object of class %s"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

#, fuzzy
msgid "non-generic function '%s' given to findMethods()"
msgstr "'%s'가 검색되어진 non-geteric 함수가 아닙니다"

msgid "Only FALSE is meaningful for 'inherited', when 'where' is supplied (got"
msgstr ""

#, fuzzy
msgid "argument \"f\" must be a generic function or %s"
msgstr "함수'%s'는 일반명 '%s'로 이외에, 일반적인 함수인 것처럼 보입니다"

#, fuzzy
msgid "'%s' is not a known generic function {and 'package' not specified}"
msgstr "'%s'는 '%s'의 일반적인 함수가 아닙니다; 제거되지 않는 메소드입니다"

msgid ""
"invalid first argument: should be the name of the first argument in the "
"dispatch"
msgstr "무효인 최초의 인수: 'dispatch'의 최초 인수의 이름이 아니면 안됩니다"

msgid "duplicate element names in 'MethodsList' at level %d: %s"
msgstr "이중의 요소는 레벨 %d를 'MethodList'로 이름을 붙입니다:%s"

#, fuzzy
msgid ""
"element %d at level %d (class %s) cannot be interpreted as a function or "
"named list"
msgstr ""
"레벨 %d(클래스 \"%s\")의 요소 %d는 함수으로 해석할수가 없고, 리스트라고 \n"
"명명할 수가 없습니다"

msgid "arguments 'names' and 'signature' must have the same length"
msgstr "'이름' 인수 그리고 '기호'는 동일 길이를 가지지 않으면 안됩니다"

#, fuzzy
msgid ""
"inserting method with invalid signature matching argument '...' to class %s"
msgstr ""
"\"%s\"클래스에서 '...'인수와 match하는 무효의 기호를 갖춘것으로 삽입하는 메소"
"드\n"
"입니다"

msgid "inserting method corresponding to empty signature"
msgstr "비어 있는 기호와 일치하고 있는 메소드를 삽입합니다"

#, fuzzy
msgid "inserting method into non-methods-list object (class %s)"
msgstr "메소드를 non-methods-list 오브젝트(클래스 \"%s\")에 삽입합니다"

msgid "invalid method sublist"
msgstr "무효인 메소드 sublist"

#, fuzzy
msgid ""
"%f is not a valid generic function: methods list was an object of class %s"
msgstr ""
"'%f'는 유효한 generic 함수가 아닙니다: 메소드 리스트는 클래스 \"%\" \"s\"의 "
"오브젝트이었습니다"

#, fuzzy
msgid ""
"%s must be TRUE, FALSE, or a named logical vector of those values; got an "
"object of class %s"
msgstr ""
"'useInherited'는 TRUE ,FALSE 또는 그러한 값의 지정된 논리적인 vector 이어야"
"만 합니다\n"
"; 클래스의 오브젝트 \"%s\"를 얻습니다"

#, fuzzy
msgid ""
"Default method must be a method definition, a primitive or NULL: got an "
"object of class %s"
msgstr ""
"유효성 메소드는 1개 인수의 함수이어야만 합니다, 클래스 \"%s\"의 오브젝트를 \n"
"얻었습니다"

#, fuzzy
msgid ""
"trying to match a method signature to an object (of class %s) that is not a "
"generic function"
msgstr ""
"generic 함수가 아닌 오브젝트(클래스 \"%s\"의 것)에 메소드 기호를 match시키려"
"고 합니다"

msgid "invalid \"package\" slot or attribute, wrong length"
msgstr ""

msgid ""
"invalid element in a list for \"signature\" argument; element %d is neither "
"a class definition nor a class name"
msgstr ""

#, fuzzy
msgid ""
"trying to match a method signature of class %s; expects a list or a "
"character vector"
msgstr ""
"클래스\"%s\"의 메소드 기호에 match하려고 합니다; 리스트 또는 문자 \n"
"vector를 예측합니다"

#, fuzzy
msgid ""
"object to use as a method signature for function %s does not look like a "
"legitimate signature (a vector of single class names): there were %d class "
"names, but %d elements in the signature object"
msgstr ""
"함수 '%s' 때문에 메소드 기호으로 사용하는 오브잭트는,\n"
"정규의 기호(단일 클래스명의 벡터)와 같이 되어지지 않습니다: %d 클래스명이 있"
"었지만,\n"
"기호 오브젝트에서 %d 요소가 있었습니다"

#, fuzzy
msgid ""
"more elements in the method signature (%d) than in the generic  signature "
"(%d)"
msgstr "메소드 정의에서 생략된 형식상의 인수는 기호(%s)에 있을 수 없습니다"

#, fuzzy
msgid ""
"in the method signature for function %s invalid argument names in the "
"signature: %s"
msgstr ""
"함수를 위해서 메소드 기호에서 '%s'는 기호으로 무효인 인수명을 지정합니다\n"
":%s"

#, fuzzy
msgid "No generic function found corresponding to \"%s\""
msgstr "'%s'를 위해서 검색되어진 generic 함수가 아닙니다"

#, fuzzy
msgid "skipping methods list element %s of unexpected class %s"
msgstr ""
"skip 하고 있는 메소드는 예상외의 클래스 \"%s\"의 요소 %s로 리스트합니다"

msgid ""
"%s, along with other use of the \"MethodsList\" metadata objects, is "
"deprecated."
msgstr ""

msgid "In %s: use of \"MethodsList\" metadata objects is deprecated."
msgstr ""

msgid "Use %s instead."
msgstr ""

msgid "invalid object for formal method definition: type \"%s\""
msgstr "정식적 메소드 정의의 무효인 오브젝트: 유형 \"%s\""

#, fuzzy
msgid "missing package slot (%s) in object of class %s (package info added)"
msgstr ""
"클래스\"%s\"(추가해진 패키지)의 오브젝트에서 잘못된 패키지 slot(%s)입니다"

#, fuzzy
msgid ""
"initialize method returned an object of class %s instead of the required "
"class %s"
msgstr ""
"initialize 메소드는 필수의 클래스 \"%s\"를 대신에 클래스\n"
"\"%s\"의 오브젝트를 돌려주었습니다"

msgid "Reported %d ambiguous selections out of %d for function %s"
msgstr ""

msgid "%d: target \"%s\": chose \"%s\" (others: %s)"
msgstr ""

msgid "Notes: %s."
msgstr ""

#, fuzzy
msgid "Class generator function for class \"%s\" from package \"%s\""
msgstr "'%s'으로 '%s'를 위해서 새로운 generic 함수를 작성합니다"

#, fuzzy
msgid "the names in signature for method (%s) do not match %s's arguments (%s)"
msgstr "메소드(%s)를 위한 기호의 이름은 함수 인수(%s)에 match하지 않습니다"

#, fuzzy
msgid ""
"a call to callNextMethod() appears in a call to \"%s\", but the call does "
"not seem to come from either a generic function or another 'callNextMethod'"
msgstr ""
"callNextMethod()에 호출이 %s에서 보여집니다.그러나 호출은 generic 함수 또"
"는 \n"
"다른 'callNextMethod'의 어느쪽이든지 되지 않습니다"

msgid ""
"call to 'callNextMethod' does not appear to be in a 'method' or "
"'callNextMethod' context"
msgstr ""
"'callNextMethod'에 호출 되어지는 'method' 또는 'callNextMethod context'이\n"
"보이지 않습니다"

#, fuzzy
msgid "bad object found as method (class %s)"
msgstr "메소드(클래스 \"%s\")으로서 검색되는 사이에 잘못된 오브젝트 입니다"

#, fuzzy
msgid ""
"in constructing the prototype for class %s: prototype has class %s, but the "
"data part specifies class %s"
msgstr ""
"클래스 \"%s\"의 prototype 유형을 구성합니다: prototype 유형은 클레스\"%s\"를 "
"가지고 있습니다,\n"
"그러나 데이터 부분은 클래스 \"%s\"를 지정합니다"

#, fuzzy
msgid ""
"in constructing the prototype for class %s, slots in prototype and not in "
"class: %s"
msgstr ""
"클래스 \"%s\"의 prototype 유형(클래수 %s에서 아니고 prototype 중의 slot)을 구"
"성합니다"

#, fuzzy
msgid ""
"in making the prototype for class %s elements of the prototype failed to "
"match the corresponding slot class: %s"
msgstr ""
"클래스 \"%s\"에 prototype 유형을 작성할때에 prototype 유형의 요소는\n"
"대응하는 slot 클래스에 match 할수 없었습니다:%s"

msgid ""
"potential cycle in class inheritance: \"%s\" has duplicates in superclasses "
"and subclasses (%s)"
msgstr ""
"클래스 계승으로 potential 사이클: \"%s\"는 슈퍼클래스 또는 하위클래스(%s)에 "
"복사를\n"
"행하여집니다"

#, fuzzy
msgid "undefined slot classes in definition of %s: %s"
msgstr "\"%s\"의 명확함이 정의하지 않는 slot 클래스 입니다: \"%s\""

#, fuzzy
msgid ""
"in definition of class %s, information for superclass %s is of class %s "
"(expected \"SClassExtension\")"
msgstr ""
"클래스 \"%s\"의 명확함에 두고 슈퍼클래스 \"%s\"을 위한 정보는 \n"
"클래스 \"%s\"(\"SClassExtension\") 입니다"

#, fuzzy
msgid "class %s extends an undefined class, %s"
msgstr "class \"%s\"는 정의하지 않는 클래스 \"%s\"를 연장합니다"

#, fuzzy
msgid "'Class' must be a valid class definition or class"
msgstr "'class1'는 클래스 또는 클래스 정의의 이름이 아니면 되지 않습니다"

#, fuzzy
msgid ""
"trying to assign an object of class %s as the definition of class %s: must "
"supply a \"classRepresentation\" object"
msgstr ""
"클래스 \"%s\"의 정의로서 클래스 \"%s\"의 오브젝트를 할당하려고 합니다\": \n"
"\"claaRepresentation\" 오브젝트를 주어져야 합니다"

msgid "assigning as \"%s\" a class representation with internal name \"%s\""
msgstr "\"%s\"로서 할당하는것은 내부 이름 \"%s\"를 갖춘 클래스 표시 입니다"

#, fuzzy
msgid "Class %s has a locked definition in package %s"
msgstr ""
"클래스 \"%s\"는 패키지 또는 환경 '%s'로부터 보이는 정의를 가지지 않습니다"

msgid "'externalptr' objects cannot be initialized from new()"
msgstr "'externalptr' 오브젝트는 새로운 것()으로부터 초기화가 될수 없습니다"

#, fuzzy
msgid ""
"initializing objects from class %s with these arguments is not supported"
msgstr ""
"이러한 인수를 갖춘 클래스 \"%s\"로부터 오브젝트의 초기화는 주어지지 않습니다"

#, fuzzy
msgid ""
"in defining class %s, the supplied data part class, %s is not valid (must be "
"a basic class or a virtual class combining basic classes)"
msgstr ""
"정의한 클래스 \"%s\"로 주어진 데이터 부분 클래스 또는 \"%s\"는 유호하지는 않"
"습니다\n"
"(basic classes를 결합하는 basic 클래스 또는 가상 클래스이어야만 합니다)"

#, fuzzy
msgid ""
"No definition was found for superclass %s in the specification of class %s"
msgstr "지정된 위치의 클래스 \"%s\", %s,(s) 정의가 없습니다: %s"

msgid ""
"conflicting definition of data part: .Data = \"%s\", superclass implies \"%s"
"\""
msgstr ""
"데이터 part가 모순되는 정의: .Data = \"%s\" , superclass \"%s\"를 의미합니다"

#, fuzzy
msgid ""
"a prototype object was supplied with object slot of class %s, but the class "
"definition requires an object that is class %s"
msgstr ""
"prototype 오브젝트에 클래스 \"%s\"의 오브젝트 slot이 주어집니다,그러나 클래"
"스 정의는 \n"
"클래스 \"%s\"인 오브젝트를 요구합니다"

#, fuzzy
msgid ""
"a prototype was supplied of class %s, but the class definition requires an "
"object that is class %s"
msgstr ""
"prototype 클래스 \"%s\"에 주어졌습니다. 그러나 클래스 정의는 클래스\"%s\"인\n"
"오브젝트를 요구합니다"

#, fuzzy
msgid ""
"slot \"%s\" in class %s currently defined (or inherited) as \"%s\", "
"conflicts with an inherited definition in class %s"
msgstr ""
"\"%s\"로서 현재 정의된(혹은 계승됩니다)클래스 \"%s\"에서 slot \"%s\",클래스 "
"\"%s\"로 \n"
"상속한 정의와의 모순입니다"

#, fuzzy
msgid "class %s extends an undefined class (%s)"
msgstr "클래스 \"%s\" 정의하지 않는 클래스 \"%s\"를 연장합니다"

msgid ""
"\"%s\" is not eligible to be the data part of another class (must be a basic "
"class or a virtual class with no slots)"
msgstr ""
"\"%s\"는 다른 클래스(기본적인 클래스 또는 slot이 없는 가상 클래스가 아니면 안"
"됩니다)의\n"
"데이터 일부분이 적합하지 않습니다"

msgid ""
"prototype is a list with named elements (could be ambiguous):  better to use "
"function prototype() to avoid trouble."
msgstr ""
"prototype는 이름이 붙여진 요소(애매하고 있었습니다)에 의한 리스트입니다: \n"
"문제를 피하기 위해서 함수 prototype()를 사용하는데 보다 좋습니다"

#, fuzzy
msgid "named elements of prototype do not correspond to slot names: %s"
msgstr ""
"클래스 \"%s\"에 prototype 유형을 작성할때에 prototype 유형의 요소는\n"
"대응하는 slot 클래스에 match 할수 없었습니다:%s"

#, fuzzy
msgid "the \"%s\" list for class %s, includes an undefined class %s"
msgstr ""
"클래스 '%s'을 위한 \"%s\" 리스트는 정의하지 않은 클래스 \"%s\"를 포함합니다"

msgid ""
"class %s is inheriting an inconsistent superclass structure from class %s, "
"inconsistent with %s"
msgstr ""

msgid ""
"unable to find a consistent ordering of superclasses for class %s: order "
"chosen is inconsistent with the superclasses of %s"
msgstr ""

msgid "\"class\" is a reserved slot name and cannot be redefined"
msgstr "\"class\"는 예약의 slot명이어서 다시 정의 될 수가 없습니다"

msgid "Data part is undefined for general S4 object"
msgstr ""

#, fuzzy
msgid "no '.Data' slot defined for class %s"
msgstr "클래스 \"%s\"때문에 정해지는 '.Data' slot이 아닙니다"

#, fuzzy
msgid "class %s does not have a data part (a .Data slot) defined"
msgstr "클래스 \"%s\"는 데이터 일부(.Data slot)를 정해지지 않습니다"

#, fuzzy
msgid "more than one possible class for the data part: using %s rather than %s"
msgstr ""
"데이터 part때문에 하나를 넘어가는 가능한 클래스: \"%s\"보다 오히려 \"$s\"를 "
"사용합니다"

msgid "class cannot have both an ordinary and hidden data type"
msgstr ""

#, fuzzy
msgid ""
"a validity method must be a function of one argument, got an object of class "
"%s"
msgstr ""
"유효성 메소드는 1개 인수의 함수이어야만 합니다, 클래스 \"%s\"의 오브젝트를 \n"
"얻었습니다"

#, fuzzy
msgid "unable to find required package %s"
msgstr "필수의 패키지 '%s'를 검색해낼 수가 없습니다"

#, fuzzy
msgid "unable to find an environment containing class %s"
msgstr "환경이 클래스 \"%s\"를 포함하고 있는것을 검색할수가 없습니다"

msgid ""
"A specification for S3 class %s in package %s seems equivalent to one from "
"package %s and is not turning on duplicate class definitions for this class"
msgstr ""

msgid ""
"Some super classes of class %s in package %s have duplicate definitions.  "
"This definition is not being treated as equivalent to that from package %s"
msgstr ""

msgid ""
"A specification for class %s in package %s seems equivalent to one from "
"package %s and is not turning on duplicate class definitions for this class"
msgstr ""

#, fuzzy
msgid "undefined subclass %s of class %s; definition not updated"
msgstr "\"%s\"의 명확함이 정의하지 않는 slot 클래스 입니다: \"%s\""

msgid ""
"subclass %s of class %s is not local and cannot be updated for new "
"inheritance information; consider setClassUnion()"
msgstr ""

msgid ""
"no definition of inheritance from %s to %s, though the relation was implied "
"by the setIs() from %s"
msgstr ""

msgid ""
"could not find superclass %s to clean up when removing subclass references "
"to class %s"
msgstr ""

#, fuzzy
msgid "no class %s found as expected in removing subclass %s"
msgstr "class \"%s\"는 정의하지 않는 클래스 \"%s\"를 연장합니다"

msgid ""
"argument includeSubclasses must be a logical, either one value or a vector "
"of the same length as argument classes"
msgstr ""

msgid "Argument abbreviate must be 0, 1, 2, or 3"
msgstr ""

msgid "Needed the supplied labels vector of length %n, got %n"
msgstr ""

#, fuzzy
msgid ""
"the function being used as %s in making a generic function for \"%s\" is "
"currently traced; the function used will have tracing removed"
msgstr ""
"'%s'에 generic 함수를 작성할때 %s로서 사용되어 있는 함수는 현재 결과로 되어집"
"니다;\n"
"사용되는 함수는 결과가 제거될것입니다"

#, fuzzy
msgid ""
"Must supply either a generic function or a function as default for \"%s\""
msgstr "'%s'를 위해서 검색되어진 generic 함수가 아닙니다"

#, fuzzy
msgid ""
"the %s argument must be NULL or a generic function object; got an object of "
"class %s"
msgstr ""
"'genericFunction'인수는 NULL 또는 generic 함수 오브젝트이어야만 합니다;\n"
"클래스 \"%s\"의 오브젝트를 얻었습니다"

msgid "non-arguments found in the signature: %s"
msgstr "기호으로 검색되는 non-arguments: %s"

msgid "no suitable arguments to dispatch methods in this function"
msgstr "이 함수에 있어서 dispatch 메소드를 보내는 정확한 인수가 아닙니다"

#, fuzzy
msgid ""
"the formal arguments of the generic function for \"%s\" (%s) differ from "
"those of the non-generic to be used as the default (%s)"
msgstr ""
"'%s'(%s)때문에 일반적인 함수의 가인수는 default(%s)로서 사용되는 non-generic"
"의 \n"
"그것들과는 다릅니다"

#, fuzzy
msgid "special function %s is not permitted to have methods"
msgstr "특별한 함수'%s'는 메소드를 가지는 것이 허용되지 않습니다"

#, fuzzy
msgid "special function %s has no known argument list; will assume '(x, ...)'"
msgstr ""
"특별한 함수'%s'는, 기존의 인수 리스트가 없습니다; '(x, ...)'이 가정할 것입니"
"다"

#, fuzzy
msgid "making a generic for special function %s"
msgstr "특별한 함수\"%s\"에 generic적으로 작성합니다"

#, fuzzy
msgid "invalid call in method dispatch to \"%s\" (no default method)"
msgstr "'%s'(디폴트 메소드는 없습니다)에서 메소드 dispatch는 무효의 호출입니다"

#, fuzzy
msgid "in method for %s with signature %s:"
msgstr "generic '%s'때문에 검색되는 메소드가 아닙니다"

#, fuzzy
msgid "formal arguments in method and generic do not appear in the same order"
msgstr "메소드와 함수의 가인수는 동일 순서로 나타나지 않습니다"

#, fuzzy
msgid ""
"formal arguments (%s) omitted in the method definition cannot be in the "
"signature"
msgstr "메소드 정의에서 생략된 형식상의 인수는 기호(%s)에 있을 수 없습니다"

msgid "expanding the signature to include omitted arguments in definition: %s"
msgstr "포함한 기호를 확대하는 것은 명확함으로 인수를 생략했습니다: %s"

msgid "= \"missing\""
msgstr "=\\\"이상하다\""

#, fuzzy
msgid ""
"methods can add arguments to the generic %s only if '...' is an argument to "
"the generic"
msgstr ""
"만약에 '...' 인수에 있다면 메소드는 generic 인수에서만 추가할 수 있습니다"

#, fuzzy
msgid ""
"arguments (%s) after '...' in the generic must appear in the method, in the "
"same place at the end of the argument list"
msgstr ""
"인수 '...' 후에  generic (%s)는 인수항리스트의 마지막에 동일 자리에 메소드"
"가\n"
"보여지지 않으면 않됩니다"

msgid ""
"Argument f must be a string, generic function, or primitive: got an ordinary "
"function"
msgstr ""

#, fuzzy
msgid "methods cannot be defined for the primitive function %s"
msgstr "메소드는 최초의 함수 '%s'때문에 정해질수가 없습니다"

#, fuzzy
msgid "no generic function found for \"%s\""
msgstr "'%s'를 위해서 검색되어진 generic 함수가 아닙니다"

msgid "Empty function name in .getGeneric"
msgstr ""

msgid ""
"Methods list objects are not maintained in this version of R:  request for "
"function %s may return incorrect information"
msgstr ""

msgid ""
"Package \"%s\" seems to have out-of-date methods; need to reinstall from "
"source"
msgstr ""

#, fuzzy
msgid ""
"no methods found for \"%s\"; cacheGenericsMetaData() will have no effect"
msgstr ""
"'%s' 때문에 검색되는 방법이 아닙니다; 'cacheGenericsMetaData'는 영향을 가지"
"지 않을것입니다"

#, fuzzy
msgid "invalid value from generic function %s, class %s, expected %s"
msgstr "'%s' generic 함수, 클래스 \"%s\", 예측되는 %s 로부터 무효의 값입니다"

#, fuzzy
msgid ""
"the body of the generic function for \"%s\" calls 'standardGeneric' to "
"dispatch on a different name (\"%s\")!"
msgstr ""
"'%s' 때문에 generic 함수의 body는 ('%s)으로 dispatch에 'standardGeneric'를 \n"
"부릅니다!"

#, fuzzy
msgid ""
"internal error: Bad methods list object in fixing methods for primitive "
"function %s"
msgstr ""
"내부의 에러: 최초의 기능 '%s'를 메소드를 고정하는것은 \n"
"잘못한 메소드 리스트 오브젝트입니다"

#, fuzzy
msgid ""
"trying to change the formal arguments in %s, in an object of class %s; "
"expected a function definition"
msgstr ""
"주어지는 클래스 \"%s\"의 오브젝트에서 %s로 가인수를 변경하려고 합니다;\n"
"함수 정의를 예측했습니다"

#, fuzzy
msgid ""
"trying to change the formal arguments in %s, but getting the new formals "
"from an object of class %s; expected a function definition"
msgstr ""
"%s으로 가인수를 변경하려고 하지만, 클래스 \"%s\"의 오브젝트로부터 \n"
"새로운 formals를 얻습니다;함수 정의를 예측했습니다"

msgid ""
"trying to change the formal arguments in %s, but the number of existing "
"arguments is less than the number of new arguments: (%s) vs (%s)"
msgstr ""
"%s 에서 형식상의 인수를 변경하려고 하는것입니다, 그러나 \n"
"기존 인수의 수는 새로운 인수의 수미만입니다: (%s) vs (%s)"

msgid ""
"trying to change the formal arguments in %s, but the number of existing "
"arguments is greater than the number of new arguments (the extra arguments "
"won't be used): (%s) vs (%s)"
msgstr ""
"%s 에서 형식상의 인수를 변경하려고 하는것입니다, 그러나\n"
"기존 인수의 수는 새로운 인수(extra 인수는 사용되지 않을 것입니다)의 수보다 큽"
"니다:\n"
"(%s) vs (%s)"

msgid ""
"in changing formal arguments in %s, some of the old names are not in fact "
"arguments: %s"
msgstr ""
"%s로 가인수를 변경할때에, 오래된 이름의 일부는 실제로 인수가 아닙니다\n"
":%s"

msgid "botched namespace: failed to find 'base' namespace in its parents"
msgstr ""
"실패한 namespace: 'base' 이름 공간을 그 parents으로 검색할 수가 없었습니다"

msgid "got a negative maximum number of frames to look at"
msgstr "보는 프레임의 negative 최대수를 얻었습니다"

#, fuzzy
msgid "\"%s\" is not a generic function (or not visible here)"
msgstr "'%s'는 일반적인 함수(또는 여기서 보이지 않습니다)가 아닙니다"

#, fuzzy
msgid "invalid element in the groupMembers slot (class %s)"
msgstr "groupMembers slot (클래스 \"%s\")의 무효인 요소입니다"

#, fuzzy
msgid "argument f must be a generic function with signature \"...\""
msgstr "함수'%s'는 일반명 '%s'로 이외에, 일반적인 함수인 것처럼 보입니다"

#, fuzzy
msgid "No method or default matching the \"...\" arguments in %s"
msgstr "\"%s\"에서 \"%s\"를 강제하기 때문에 메소드 또는 디폴트가 없습니다"

msgid "multiple direct matches:"
msgstr ""

msgid "; using the first of these"
msgstr ""

msgid "multiple equivalent inherited matches:"
msgstr ""

#, fuzzy
msgid "single string; got an object of class %s"
msgstr "무효인 메소드 정의: 함수를 예측해서 클래스 '%s'의 대상을 얻었습니다"

msgid ""
"Multiple definitions exist for class %s, but the supplied package (%s) is "
"not one of them (%s)"
msgstr ""

msgid ""
"Multiple definitions exist for class %s; should specify one of them (%s), e."
"g. by className()"
msgstr ""

#, fuzzy
msgid "No definition found for class %s"
msgstr "검색되는 클래스 \"%s\"의 정의가 아닙니다"

msgid "Trying to execute load actions without methods package"
msgstr ""

#, fuzzy
msgid "Missing  function for load action: %s"
msgstr "함수'%s'를 위한 기존의 정의가 아닙니다"

#, fuzzy
msgid "Error in load action %s for package %s: %s: %s"
msgstr "'%s'으로 '%s'를 위해서 새로운 generic 함수를 작성합니다"

#, fuzzy
msgid "non-function action: \"%s"
msgstr "검색되는 '%s' 때문에 함수 정의가 아닙니다"

msgid "action function \"%s\" has no arguments, should have at least 1"
msgstr ""

msgid "Some actions missing: %s"
msgstr ""

msgid "\"%s\" has a sealed class definition and cannot be redefined"
msgstr "\"%s\"는 밀폐된 클래스 정의를 가져, 다시 정의를 될수가 없습니다"

msgid ""
"only arguments 'Class' and 'where' can be supplied when argument "
"'representation' is a 'classRepresentation' object"
msgstr ""
"'Class' 그리고 'where' 인수만 'representation' \n"
"오브젝트인 경우 주어질수 있습니다"

#, fuzzy
msgid "Internal error: definition of class \"%s\" not properly assigned"
msgstr "검색되는 클래스 \"%s\"의 정의가 아닙니다"

#, fuzzy
msgid ""
"error in contained classes (%s) for class %s and unable to remove definition "
"from %s"
msgstr ""
"클래스 \"%s\" 때문에 '%s'로부터 명확함을 제거해서 수가 없는 것이 포함된 클래"
"스 \n"
"(%s)에 있어서 에러입니다"

#, fuzzy
msgid ""
"error in contained classes (%s) for class %s; class definition removed from "
"%s"
msgstr ""
"클래스 \"%s\"이기 때문에 (%s)를 포함된 에러입니다; \n"
"'%s'로부터 제거되는 클래스 정의입니다"

#, fuzzy
msgid ""
"error in contained classes (%s) for class %s and unable to restore previous "
"definition from %s"
msgstr ""
"클래스 \"%s\"이기 때문에 '%s'로부터 전의 정의를 회복시킬 수가 없는것이 포함"
"된\n"
"클래스(%s)에 있어서 에러입니다"

#, fuzzy
msgid ""
"error in contained classes (%s) for class %s; previous definition restored "
"to %s"
msgstr ""
"클레스\"%s\" 때문에 클래스(%s)를 포함된 에러입니다; %s 으로부터\n"
"전의 정의가 회복되었습니다"

msgid "element %d of the representation was not a single character string"
msgstr "대표의 요소 %d 는 하나의 문자열에서도 없었습니다"

msgid "duplicate class names among superclasses: %s"
msgstr "superclasses 사이에 클래스명을 복사 해주십시오: %s"

msgid "duplicated slot names: %s"
msgstr "중복된 slot 이름: %s"

msgid "only one data object (unnamed argument to prototype) allowed"
msgstr "1개의 데이터 오브젝트(prototype에 대한 이름이 없는 인수)만 허용됩니다"

msgid "\"%s\" is not a defined class"
msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

#, fuzzy
msgid "\"%s\" is not a slot in class %s"
msgstr "\"%s\" 클래스에서 \"%s\"의 slot이 아닙니다"

#, fuzzy
msgid ""
"assignment of an object of class %s is not valid for slot \"%s\" in an "
"object of class %s; is(value, \"%s\") is not TRUE"
msgstr ""
"클래스 \"%s\"의 오브젝트의 할당은 클래스 '%s'의 오브젝트에서 slot \"%s\"를 \n"
"유효하지 않습니다; \"%s\" 값이 TRUE가 아닙니다"

#, fuzzy
msgid "Class definition for \"%s\" not found  (no action taken)"
msgstr "\"%s\"는 클래스(되는 행동이 아닙니다)가 아닙니다"

#, fuzzy
msgid "class %s has multiple definitions visible; only the first removed"
msgstr "클래스 \"%s\"는 복수의 정의를 인정하도록 합니다; 첫번째에만 제거됩니다"

#, fuzzy
msgid "invalid class %s object:"
msgstr "무효인 클래스 \"%s\" 오브젝트입니다"

msgid "validity method must be NULL or a function of one argument"
msgstr "validity 메소드는 NULL 또는 1개 인수의 함수가 아니면 안됩니다"

#, fuzzy
msgid "class %s not found on %s; 'resetClass' will have no effect"
msgstr ""
"\"%s\"로 검색되지 않는 클래스 '%s' 입니다; 'resetClass'는 영향를 가지지 않습"
"니다"

#, fuzzy
msgid ""
"argument 'classDef' must be a string or a class representation; got an "
"object of class %s"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

#, fuzzy
msgid "class %s is sealed; 'resetClass' will have no effect"
msgstr ""
"클래스 \"%s\"은 밀폐를 하였습니다; 'resetClass'은 영향을 가지지 않습니다"

#, fuzzy
msgid ""
"cannot use object of class %s in new():  class %s does not extend that class"
msgstr ""
"클래스 \"%s\"의 오브젝트를 new()에서 취급할수가 없습니다: 클래스 \"%s\"는 \n"
"그 클래스를 연장하지 않습니다"

#, fuzzy
msgid "invalid names for slots of class %s: %s"
msgstr "클래스 \"%s\"의 slot 무효인 이름: %s 입니다"

msgid ""
"Class %s is defined, with package %s, but no corresponding metadata object "
"was found (not exported?)"
msgstr ""

#, fuzzy
msgid "no definition of %s to use for %s"
msgstr "%s를 사용하는 \"%s\"의 정의가 아닙니다"

#, fuzzy
msgid ""
"multiple definitions of class %s visible (%s); using the definition\n"
"   in package %s for %s"
msgstr "\"%s\"의 다수의 정의는 검색되었습니다; %s에서 사용합니다"

msgid "Class definition cannot extend more than one of these data types: %s"
msgstr ""

msgid ""
"Sorry, abnormal type \"%s\" is not supported as a superclass of a class "
"definition"
msgstr ""

#, fuzzy
msgid "Multiple class definitions for %s from packages: %s; picking the first"
msgstr "'%s'으로 '%s'를 위해서 새로운 generic 함수를 작성합니다"

#, fuzzy
msgid "No package name supplied and no class definition found for %s"
msgstr "검색되는 '%s' 때문에 함수 정의가 아닙니다"

#, fuzzy
msgid "argument classDef must be a class definition or the name of a class"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

msgid ""
"'traceOn' is deprecated: use the function 'trace' in the 'methods' package "
"instead"
msgstr ""
"'traceOn'은 반대됩니다: 그 대신에 'methods' 패키지로\n"
"함수'trace'를 사용해주십시오"

msgid ""
"'traceOff' is deprecated: use the function 'untrace' in the 'methods' "
"package instead"
msgstr ""
"'traceOff'는 반대됩니다: 그 대신에 'methods' 패키지로 \n"
"함수'untrace'를 사용해주십시오"

#, fuzzy
msgid "no function %s found"
msgstr "'%s'가 검색되어진 함수가 아닙니다"

#, fuzzy
msgid "no non-generic function %s found"
msgstr "'%s'가 검색되어진 non-geteric 함수가 아닙니다"

#, fuzzy
msgid "\"%s\" is not one of the element names"
msgstr "%s의 것은 요소명 중 하나가 아닙니다"

msgid ""
"internal problem in as(): \"%s\" is(object, \"%s\") is TRUE, but the "
"metadata asserts that the 'is' relation is FALSE"
msgstr ""
"as()으로 내부의 문제: \"%s\" (오브젝트, \"%s\") TRUE 입니다,그러나\n"
"metadata가 그것을 단정하는 'is' 관계가 FALSE 입니다"

msgid "no method or default for coercing \"%s\" to \"%s\""
msgstr "\"%s\"에서 \"%s\"를 강제하기 때문에 메소드 또는 디폴트가 없습니다"

msgid "no method or default for as() replacement of \"%s\" with Class=\"%s\""
msgstr ""
"Class=\"%s\"에 의한 \"%s\"의 as() 치환으로 메소드 또는 디폴트가 없습니다"

msgid "trying to set an 'as' relation from \"%s\" to itself"
msgstr "\"%s\"로부터 그 자체에의 'as' 관계로 세트하려고 합니다"

#, fuzzy
msgid "class %s is not defined in this environment"
msgstr "클레스 \"%s\"는 이 환경에서 정해지지 않습니다"

#, fuzzy
msgid ""
"class %s is a class union: 'coerce' relations to a class union are not "
"meaningful"
msgstr ""
"class \"%s\"는 클래스 결합입니다: 'coerce' 클래스 결합과의한 관계가\n"
"의미가 없습니다"

#, fuzzy
msgid ""
"'as' method should have one argument, or match the arguments of coerce(): "
"got  (%s)"
msgstr ""
"'as' 메소드는 1개 또는 2개의 인수를 가지고 있어야만 합니다, 'strict' 옵셥을 "
"더합니다;(%s) 얻습니다"

msgid ""
"a 'replace' method definition in 'setAs' must be a function of two "
"arguments, got %d"
msgstr ""
"'setAs'에서 'replace' 메소드 정의는 2개의 인수 함수이어야만 합니다,\n"
"%d를 얻었습니다"

msgid ""
"argument names in replace changed to agree with 'coerce<-' generic:\n"
"%s"
msgstr "'coerce<- generic를 합치하는 변경된 치환의 인수이름 입니다:%s"

msgid "ambiguous object (length!=1) to coerce to \"name\""
msgstr "\"name\"에서 강제해야 할 애매한 오브젝트(길이 !=1)입니다"

msgid "undefined coerce method"
msgstr "깅제하는 메소드를 정의하지 않습니다"

msgid ""
"methods currently exist for coercing from \"%s\" to \"%s\"; they will be "
"replaced."
msgstr ""
"메소드 \"%s\"로부터 \"%s\"까지 강제하기 위해서 현재 존재하는것이 변경될것입니"
"다"

#, fuzzy
msgid "object \"%s\" not found"
msgstr "검색되지 않는 오브젝트 '%s' 입니다"

#, fuzzy
msgid ""
"object \"%s\" not changed (it is not consistent with the current definition "
"of class %s from %s)"
msgstr ""
"오브젝트 '%s'는 변경되지 않습니다(그것은 '%s'로부터 클래스 \"%s\"의 현재 정의"
"와 일치하고 있지 않습니다)"

#, fuzzy
msgid "no definition for the class of %s (class %s) found"
msgstr "'%s'(클래스 \"%s\")의 클래스 정의는 검색하지 않았습니다"

#, fuzzy
msgid ""
"object \"%s\" not changed (it does not appear to be from a version of R "
"earlier than 1.8.0)"
msgstr ""
"오브젝트 '%s'는 변경되지 않는다(그것은 1.8.0 보다 전 R의 버전으로부터 보이지 "
"않습니다)"

msgid "'class1' must be the name of a class or a class definition"
msgstr "'class1'는 클래스 또는 클래스 정의의 이름이 아니면 되지 않습니다"

msgid "'class2' must be the name of a class or a class definition"
msgstr "'class2'는 클래스 또는 클래스 정의의 이름이 아니면 되지 않습니다"

#, fuzzy
msgid "class %s has no visible definition from package or environment %s"
msgstr ""
"클래스 \"%s\"는 패키지 또는 환경 '%s'로부터 보이는 정의를 가지지 않습니다"

msgid ""
"cannot create a 'setIs' relation when neither of the classes (\"%s\" and \"%s"
"\") is local and modifiable in this package"
msgstr ""
"클래스(\"%s\" 그리고 \"%s\")의 어느쪽이나, 이 패키지에 두고 국소적이지 않고 "
"한정 가능한 \n"
"경우 'setIs'관계를 작성할 수가 없습니다"

#, fuzzy
msgid ""
"class %s is sealed; new superclasses can not be defined, except by "
"'setClassUnion'"
msgstr ""
"클래스 \"%s\"는 밀봉되었습니다; 새로운 슈퍼클래스는 'setClassUnion'에 의한 경"
"우 이외는 \n"
"정의 할수가 없습니다"

msgid ""
"Class %s is defined (with package slot %s) but no metadata object found to "
"revise %s information---not exported?  Making a copy in package %s"
msgstr ""

#, fuzzy
msgid "class %s cannot extend class %s"
msgstr "클래스 \"%s\"는 클래스 \"%s\"를 연장시킬 수가 없습니다"

msgid "Both classes must be defined"
msgstr "양쪽 모두의 클래스는 정해지지 않으면 안됩니다"

#, fuzzy
msgid ""
"class %s is missing slots from class %s (%s), and no coerce method was "
"supplied"
msgstr ""
"\"%s\" 클래스가\"%s\"(%s)로부터 slot를 잘못되어진 클래스, 그리고 메소드가 제"
"공된 것을 \n"
"조금도 강제하지 않습니다"

#, fuzzy
msgid ""
"slots in class %s must extend corresponding slots in class %s: fails for %s"
msgstr ""
"클래스 \"%s\"의 slot는 클래스 \"%s\"로 대응하는 slot을 연장하여야만 합니다: "
"%s 때문에 실패합니다"

msgid "invalid index for function argument"
msgstr "함수 인수를 위한 무효의 인덱스"

#, fuzzy
msgid "No function definition found for \"%s\""
msgstr "검색되는 '%s' 때문에 함수 정의가 아닙니다"

msgid "Need a definition for the method here"
msgstr ""

msgid "Skeleton of method written to"
msgstr ""

msgid "connection"
msgstr ""

msgid ""
"Invalid object in meta table of methods for %s, label \"%s\", had class %s"
msgstr ""

msgid "Invalid mlist element for signature \""
msgstr ""

msgid "\" at level"
msgstr ""

msgid "( should be methods list or method, had class \""
msgstr ""

msgid "\")"
msgstr ""

#, fuzzy
msgid "bad method object stored in method table, class %s"
msgstr "메소드(클래스 \"%s\")으로서 검색되는 사이에 잘못된 오브젝트 입니다"

#, fuzzy
msgid "Invalid object in methods table (\""
msgstr "메소드(클래스 \"%s\")으로서 검색되는 사이에 잘못된 오브젝트 입니다"

#, fuzzy
msgid "\"), expected a method, got an object of class \""
msgstr "무효인 메소드 정의: 함수를 예측해서 클래스 '%s'의 대상을 얻었습니다"

msgid "Invalid or unset methods table in generic function \""
msgstr ""

#, fuzzy
msgid "Trying to find a methods table in a non-generic function"
msgstr ""
"generic 함수가 아닌 오브젝트(클래스 \"%s\"의 것)에 메소드 기호를 match시키려"
"고 합니다"

#, fuzzy
msgid ""
"The \"ambiguousMethodSelection\" option should be a function to be called as "
"the condition action; got an object of class %s"
msgstr ""
"'setIs'에서 'coerce' 인수는 하나의 인수함수이어야만 합니다,\n"
"클래스 \"%s\" 오브젝트를 얻었습니다"

#, fuzzy
msgid ""
"No simply inherited methods found for function %s; using non-simple method"
msgstr "함수'%s' 그리고 기호 %s 때문에 검색되는 메소드가 아닙니다"

msgid ""
"Note: Method with signature \"%s\" chosen for function \"%s\",\n"
" target signature \"%s\".\n"
" %s would also be valid"
msgstr ""

msgid "found"
msgstr ""

msgid "equally good next methods"
msgstr ""

#, fuzzy
msgid "unable to find an inherited method for function \""
msgstr "환경이 클래스 \"%s\"를 포함하고 있는것을 검색할수가 없습니다"

msgid "\", for signature"
msgstr ""

msgid ""
"Internal error in finding inherited methods; didn't return a unique method"
msgstr ""

msgid "Selecting %d methods of min. distance"
msgstr ""

msgid "Selecting %d non-group methods"
msgstr ""

msgid "Selecting %d partially exact-matching method(s)"
msgstr ""

msgid "Choosing method %s from %d ambiguous possibilities"
msgstr ""

msgid "Failed to find expected group generic function:"
msgstr ""

msgid "Invalid group generic function in search for inherited method (class \""
msgstr ""

#, fuzzy
msgid "Invalid methods table request"
msgstr "무효인 메소드 sublist"

msgid "Trying to check signature length of group generic \""
msgstr ""

msgid "\", but it is not a group generic"
msgstr ""

msgid "Trying to check signature length of generic \""
msgstr ""

#, fuzzy
msgid "\", but it is not a  generic function: i ="
msgstr "'%s'는 일반적인 함수(또는 여기서 보이지 않습니다)가 아닙니다"

msgid ", funs ="
msgstr ""

msgid "; gnames ="
msgstr ""

msgid "Something weird:  inconsistent number of args in methods table strings:"
msgstr ""

msgid "(using the largest value)"
msgstr ""

#, fuzzy
msgid "No methods table for generic %s from package %s in package %s"
msgstr "'%s'으로 '%s'를 위해서 새로운 generic 함수를 작성합니다"

#, fuzzy
msgid "Undefined classes ("
msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

msgid ") will be ignored, for argument"
msgstr ""

msgid ""
"Argument \"signatures\" must be a character matrix whose rows are method "
"signatures"
msgstr ""

msgid "not allowed to have test==TRUE and an S4Class definition"
msgstr ""

#, fuzzy
msgid "argument S4Class must be a class definition:  got an object of class %s"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

#, fuzzy
msgid ""
"inconsistent old-style class information for \"%s\"; the class is defined "
"but does not extend \"%s\" and is not valid as the data part"
msgstr ""
"\"%s\" (new 그리고 old 의 클래스를 혼합합니까?) 때문에 모순되고 있는 old-"
"style\n"
"클래스 정보입니다"

msgid ""
"The S3 class of the prototype, \"%s\", is undefined; only allowed when this "
"is the S3 class being registered (\"%s\")"
msgstr ""

#, fuzzy
msgid "Restoring definition of class %s"
msgstr "검색되는 클래스 \"%s\"의 정의가 아닙니다"

#, fuzzy
msgid "Slot \"%s\": class %s should extend class %s"
msgstr "클래스 \"%s\"는 클래스 \"%s\"를 연장시킬 수가 없습니다"

#, fuzzy
msgid ""
"invalid S4 class corresponding to S3 class: slots in  S4 version must extend "
"corresponding slots in S3 version: fails for %s"
msgstr ""
"클래스 \"%s\"의 slot는 클래스 \"%s\"로 대응하는 slot을 연장하여야만 합니다: "
"%s 때문에 실패합니다"

msgid "explicit coercion of old-style class (%s) is not defined"
msgstr "old-style 클래스(%s)의 명시적인 강제는 정의 되지 있지 않았습니다"

#, fuzzy
msgid ""
"explicit replacement not defined for as(x, \"%s\") <- value for old-style "
"class %s"
msgstr ""
"정의 되지 않는 명시적인 치환 때문에(x,\"%s\")<- old-style의 클래스 \n"
"\"%s\"에 적당한 값입니다"

msgid ""
"argument 'Classes' must be a vector of two classes; got an argument of "
"length %d"
msgstr ""
"인수 'Classes'는 2개 클래스의 벡터이어야만 합니다;\n"
"길이 %d의 인수를 얻었습니다"

msgid ""
"inconsistent old-style class information for \"%s\" (maybe mixing old and "
"new classes?)"
msgstr ""
"\"%s\" (new 그리고 old 의 클래스를 혼합합니까?) 때문에 모순되고 있는 old-"
"style\n"
"클래스 정보입니다"

msgid ""
"S3Class only defined for extensions of \"oldClass\" or classes with a data "
"part:  not true of class \""
msgstr ""

msgid ""
"S3Class can only be assigned to S4 objects that extend \"oldClass\"; not "
"true of class %s"
msgstr ""

#, fuzzy
msgid "Created a package name, %s, when none found"
msgstr "패키지명이 아닙니다:'%s'"

#, fuzzy
msgid "no definition of class %s found"
msgstr "검색되는 클래스 \"%s\"의 정의가 아닙니다"

msgid "multiple definitions of \"%s\" found; using the one on %s"
msgstr "\"%s\"의 다수의 정의는 검색되었습니다; %s에서 사용합니다"

#, fuzzy
msgid ""
"no definition of class %s in the specified position, %s, definition(s) on : "
"%s"
msgstr "지정된 위치의 클래스 \"%s\", %s,(s) 정의가 없습니다: %s"

#, fuzzy
msgid "\"%s\" is not a valid field or method name for reference class %s"
msgstr "\"%s\" 클래스에서 \"%s\"의 slot이 아닙니다"

msgid ""
"Method %s from class %s was not processed into a class method until being "
"installed.  Possible corruption of the methods in the class."
msgstr ""

msgid ""
"a call to superClass() is in the method \"%s\" but there is no superclass "
"definition of this method for class %s"
msgstr ""

#, fuzzy
msgid "\"%s\" is not a reference class"
msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

#, fuzzy
msgid "\"%s\" is not a field in class %s"
msgstr "\"%s\" 클래스에서 \"%s\"의 slot이 아닙니다"

#, fuzzy
msgid ""
"Unnamed arguments to $new() must be objects from a reference class; got an "
"object of class \"%s\""
msgstr ""
"'genericFunction'인수는 NULL 또는 generic 함수 오브젝트이어야만 합니다;\n"
"클래스 \"%s\"의 오브젝트를 얻었습니다"

#, fuzzy
msgid "\"%s\" is not a valid field or method name for this class"
msgstr "\"%s\" 클래스에서 \"%s\"의 slot이 아닙니다"

msgid ""
"The class of field \"%s\" in the object is not compatible with the desired "
"class %s in the target"
msgstr ""

#, fuzzy
msgid "\"%s\" is not a defined class in this environment"
msgstr "클레스 \"%s\"는 이 환경에서 정해지지 않습니다"

#, fuzzy
msgid "Invalid Class argument:  should be a single string"
msgstr ""
"요소 %d (하나의 문자열이 아니면 안됩니다) 때문에 지정되는 \n"
"잘못된 클래스입니다"

#, fuzzy
msgid "\"%s\" is not one of the reference super classes for this object"
msgstr "%s의 것은 요소명 중 하나가 아닙니다"

msgid ""
"direct calls to callSuper() are invalid:  should only be called from another "
"method"
msgstr ""

#, fuzzy
msgid "\"%s\" is not a field in this class"
msgstr "\"%s\" 클래스에서 \"%s\"의 slot이 아닙니다"

#, fuzzy
msgid ""
"The definition of class %s in package %s is locked, methods may not be "
"redefined"
msgstr "함수'%s' 또는 기호 %s의 메소드는 밀폐되어 다시 정의할수가 없습니다"

#, fuzzy
msgid "Arguments to methods() must be named, or one named list"
msgstr "메소드와 함수의 가인수는 동일 순서로 나타나지 않습니다"

#, fuzzy
msgid ""
"Topic \"%s\" is not a method name in class %s\n"
"The class definition follows"
msgstr "'class1'는 클래스 또는 클래스 정의의 이름이 아니면 되지 않습니다"

#, fuzzy
msgid ""
"The definition of class %s in package %s is locked, fields may not be "
"modified"
msgstr "함수'%s' 또는 기호 %s의 메소드는 밀폐되어 다시 정의할수가 없습니다"

msgid ""
"The overriding class(\"%s\") of field \"%s\" is not a subclass of the "
"existing field definition (\"%s\")"
msgstr ""

msgid "Field \""
msgstr ""

msgid "\" is read-only"
msgstr ""

#, fuzzy
msgid ""
"invalid replacement for field %s, should be from class %s or a subclass (was "
"class %s)"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

#, fuzzy
msgid ""
"The contains= argument should be the names of superclasses:  got an element "
"of class %s"
msgstr ""
"첫번째 인수는 generic 함수(클래스 \"%s\"의 오브젝트를 얻을수 있습니다)의 이름"
"이어야만\n"
"합니다"

#, fuzzy
msgid "No definition found for inherited class: %s"
msgstr "검색되는 클래스 \"%s\"의 정의가 아닙니다"

msgid ""
"Single class name needed for field \"%s\", got a character vector of length "
"%d"
msgstr ""

#, fuzzy
msgid "Class %s for field \"%s\" is not defined"
msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

msgid ""
"Field \"%s\" was supplied as an object of class %s; must be a class name or "
"a binding function"
msgstr ""

msgid ""
"Code for methods in class %s was not checked for suspicious field "
"assignments (recommended package %s not available?)"
msgstr ""

msgid "A list argument for fields must have nonempty names for all the fields"
msgstr ""

#, fuzzy
msgid ""
"Argument fields must be a list of the field classes or definitions, or else "
"just the names of the fields; got an object of class %s"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

#, fuzzy
msgid "Class %s is defined but is not a reference class"
msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

#, fuzzy
msgid ""
"Class must be a reference class representation or a character string; got an "
"object of class %s"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

#, fuzzy
msgid "Not a reference class:"
msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

msgid "(class %s)"
msgstr ""

msgid "for method %s()"
msgstr ""

msgid ""
"Local assignment to field name will not change the field:\n"
"    %s\n"
" Did you mean to use \"<<-\"? ( in method %s for class %s)"
msgstr ""

msgid ""
"Non-local assignment to non-field names (possibly misspelled?)\n"
"    %s\n"
"( in method %s for class %s)"
msgstr ""

msgid ""
"Non-local assignment to method names is not allowed\n"
"    %s\n"
"( in method %s for class %s)"
msgstr ""

msgid "Arguments must all be character string names of fields"
msgstr ""

msgid "Field \"%s\" is already locked"
msgstr ""

msgid "Field \"%s\" of class %s has a non-default binding and cannot be locked"
msgstr ""

#, fuzzy
msgid ""
"invalid ignore= argument; should be a class definition or a character "
"vector, got an object of class %s"
msgstr ""
"인수'classDef'는 문자열 또는 클래스는 representation가 아니면 안됩니다; 클래"
"스 \"%s\"\n"
"의 오브젝트를 얻었습니다"

msgid "An object of class \""
msgstr ""

#, fuzzy
msgid ""
"invalid call to 'classLabel': expected a name or a class definition, got an "
"object of class %s"
msgstr ""
"'classLabel'에서 무효인 호출입니다: 이름 또는 클래스 정의를 예측해 \n"
"클래스 \"%s\"의 오브젝트를 얻었습니다"

msgid "Argument signature= is not meaningful for tracing reference methods"
msgstr ""

#, fuzzy
msgid "\"%s\" is not a method for reference class %s"
msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

msgid "argument 'what' should be the name of a function"
msgstr "인수'what' 함수의 이름이어야 합니다"

msgid "Tracing the internal function %s is not allowed"
msgstr ""

msgid ".TraceWithMethods: after computing what, whereF"
msgstr ""

#, fuzzy
msgid "no function definition for \"%s\" found"
msgstr "검색되는 '%s' 때문에 함수 정의가 아닙니다"

#, fuzzy
msgid ""
"Can't untrace method for \"%s\"; no method defined for this signature: %s"
msgstr "이 기호와 일치하고 있는 특별한 메소드가 아닙니다"

msgid ".TraceWithMethods: untrace case"
msgstr ""

msgid "the method for \"%s\" for this signature was not being traced"
msgstr "이 signature의 \"%s\" 메소드는 영향이 되고 있지 않았습니다"

msgid ".TraceWithMethods: about to assign or setMethod"
msgstr ""

msgid ""
"making a traced version of a primitive; arguments will be treated as '...'"
msgstr "최초의 결과가 된 버전을 작성합니다; 인수는'...'로서 취급 될것입니다"

#, fuzzy
msgid ""
"the editing in trace() can only change the body of the function; got an "
"object of class %s"
msgstr ""
"trace()에서 편집은 단지 함수의 주요부를 변경할수 있습니다; 클래스 \n"
"\"%s\"의 오브젝트를 얻었습니다"

msgid ""
"the editing in trace() can only change the body of the function, not the "
"arguments or defaults"
msgstr ""
"trace()에서 편집은 단지 인수 또는 디폴트는 아닌 \n"
"함수의 주요부를 변경할 수가 있습니다"

msgid "cannot use 'at' argument without a trace expression"
msgstr "결과 표현이 없이 인수'at'를 사용할 수가 없습니다"

msgid ""
"cannot use 'at' argument unless the function body has the form '{ ... }'"
msgstr ""
"함수 전체가 형식 '{ ... }'을 가지지 않으면 'at' 인수를 사용할 수가 없습니다"

#, fuzzy
msgid "assigning over the binding of symbol %s in environment/package %s"
msgstr "환경/패키지 \"%s\"로 심벌 \"%s\"의 결합에 관해서 할당합니다"

#, fuzzy
msgid ""
"setting a method over the binding of symbol %s in environment/package %s"
msgstr "환경/패키지 '%s'에서 심벌 '%s'의 결합에 관한 메소드를 세트합니다"

msgid "Constructing traceable class \""
msgstr ""

msgid "Environment of class \""
msgstr ""

msgid "\" is locked; using global environment for new class"
msgstr ""

msgid ""
"None of the objects in the source code could be found:  need to attach or "
"specify the package"
msgstr ""

msgid "Objects found in multiple packages: using %s and ignoring %s"
msgstr ""

msgid "Package \"%s\" is not attached and no namespace found for it"
msgstr ""

#, fuzzy
msgid ""
"Invalid source argument: expected file names(s) or connection, got an object "
"of class %s"
msgstr "무효인 메소드 정의: 함수를 예측해서 클래스 '%s'의 대상을 얻었습니다"

#, fuzzy
msgid "Can't find an environment corresponding to package name '%s\""
msgstr "환경이 클래스 \"%s\"를 포함하고 있는것을 검색할수가 없습니다"

msgid "Supplied package, %s, differs from package inferred from source, %s"
msgstr ""

msgid "Can't insert these (not found in source): %s"
msgstr ""

#, fuzzy
msgid ""
"Can't insert methods for these functions (methods table not found in "
"source): %s"
msgstr "이 기호와 일치하고 있는 특별한 메소드가 아닙니다"

msgid "Non-function objects aren't currently inserted (not traceable): %s"
msgstr ""

msgid "New functions aren't currently inserted (not untraceable): %s"
msgstr ""

msgid "Modified functions inserted through trace(): %s"
msgstr ""

#, fuzzy
msgid ""
"%s() is not a generic function in the target environment--methods will not "
"be inserted"
msgstr "'%s'는 '%s'의 일반적인 함수가 아닙니다; 제거되지 않는 메소드입니다"

#, fuzzy
msgid "Methods inserted for function %s(): %s"
msgstr "함수'%s' 그리고 기호 %s 때문에 검색되는 메소드가 아닙니다"

msgid "Pretend we inserted class"
msgstr ""

#, fuzzy
msgid "No definition for object \"%s\" found in tracing environment"
msgstr "\"%s\"는 클래스(되는 행동이 아닙니다)가 아닙니다"

msgid "multiple generics match pattern, using table %s"
msgstr ""

msgid ""
"Does not seem to be a method table for generic  \"%s\" in tracing environment"
msgstr ""

#, fuzzy
msgid "No method in methods table for \"%s\" for signature \"%s\""
msgstr "함수 '%s'와 기호 %s를 위해서 정해지는 메소드가 아닙니다"

#, fuzzy
msgid "not a package name: %s"
msgstr "패키지명이 아닙니다:'%s'"

#, fuzzy
msgid "apparently bad method or class metadata in saved environment;"
msgstr "기호는 클래스 또는 환경의 벡터가 아니면 되지 않습니다"

msgid "move the file or remove the class/method"
msgstr ""

#, fuzzy
msgid "no definition for class %s"
msgid_plural "no definition for classes %s"
msgstr[0] "검색되는 클래스 \"%s\"의 정의가 아닙니다"

#, fuzzy
#~ msgid ""
#~ "does not seem to call 'standardGeneric'; no methods will be dispatched!"
#~ msgstr ""
#~ "제공된 generic 함수 정의는 'standardGeneric'를 호출하는것 같지는 않습니"
#~ "다;\n"
#~ "메소드는 보내지 않았습니다!"

#, fuzzy
#~ msgid "no generic function \"'%s\" found"
#~ msgstr "'%s'가 검색되어 일반적인 함수가 아닙니다"

#, fuzzy
#~ msgid ""
#~ "Value supplied for field \"%s\" (with class \"%s\") is not a subclass of "
#~ "required class \"%s\""
#~ msgstr ""
#~ "initialize 메소드는 필수의 클래스 \"%s\"를 대신에 클래스\n"
#~ "\"%s\"의 오브젝트를 돌려주었습니다"

#, fuzzy
#~ msgid ""
#~ "The fieldReadOnly argument must be the names of the read-only fields; got "
#~ "an object of class \"%s\""
#~ msgstr ""
#~ "첫번째 인수는 generic 함수(클래스 \"%s\"의 오브젝트를 얻을수 있습니다)의 "
#~ "이름이어야만\n"
#~ "합니다"

#, fuzzy
#~ msgid "Field classes undefined: %s"
#~ msgstr "양쪽 모두의 클래스는 정해지지 않으면 안됩니다"

#, fuzzy
#~ msgid "Trying to set a read-only field ("
#~ msgstr "\"%s\"로부터 그 자체에의 'as' 관계로 세트하려고 합니다"

#, fuzzy
#~ msgid "\"%s\" is not a known reference class"
#~ msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

#, fuzzy
#~ msgid "Invalid accessor function list: %s"
#~ msgstr "함수 인수를 위한 무효의 인덱스"

#, fuzzy
#~ msgid ""
#~ "invalid argument 'f', expected a function or its name, got an object of "
#~ "class %s"
#~ msgstr ""
#~ "무효의 인수 'f', 함수 또는 그 이름에 예측한 클래스 \n"
#~ "\"%s\"의 오브젝트를 얻었습니다"

#, fuzzy
#~ msgid ""
#~ "in the method signature for function \"%s\" no definition for class: %s"
#~ msgid_plural ""
#~ "in the method signature for function \"%s\" no definition for classes: %s"
#~ msgstr[0] ""
#~ "함수'%s'를 위한 메소드 signature으로, 클래스용 정의는 없습니다: %s"

#, fuzzy
#~ msgid "Some of the superclasses in the definition of class \""
#~ msgstr "지정된 위치의 클래스 \"%s\", %s,(s) 정의가 없습니다: %s"

#~ msgid "signature must be a vector of classes or an environment"
#~ msgstr "기호는 클래스 또는 환경의 벡터가 아니면 되지 않습니다"

#~ msgid "no unique method corresponding to this signature"
#~ msgstr "이 기호와 일치하고 있는 특별한 메소드가 아닙니다"

#~ msgid "unable to match signature to methods"
#~ msgstr "기호를 메소드으로 match할수가 없습니다"

#~ msgid "class \"%s\" cannot be used as the data part of another class"
#~ msgstr "클래스 \"%s\"가 다른 클래스의 데이터 일부로서 사용될 수가 없습니다"

#~ msgid "internal error: bad code for 'setPrimitiveMethods': %s"
#~ msgstr "내부의 에러: 'setPrimitiveMethids'를 위한 잘못한 코드: %s입니다"

#~ msgid ""
#~ "'NextMethod' not defined because the current method is not a "
#~ "'MethodDefinition' object"
#~ msgstr ""
#~ "정의 되지 않는 'NextMethod' 의 것으로 , 현재의 메소드는 \n"
#~ "'MethodDefinition' 오브젝트가 아닙니다"

#~ msgid "expected a list of signature objects, got \"%s\""
#~ msgstr "리스트는 기호에 예측하여 \"%s\"를 얻었습니다"

#, fuzzy
#~ msgid ""
#~ "Unable to find package environment for class \"%s\" to revise subclass "
#~ "information"
#~ msgstr "환경이 클래스 \"%s\"를 포함하고 있는것을 검색할수가 없습니다"

#, fuzzy
#~ msgid ""
#~ "the environment/package \"%s\" is locked; cannot remove methods data for "
#~ "\"%s\""
#~ msgstr ""
#~ "환경/패키지 '%s'는 락(lock)이 되었습니다; '%s'에 때문에 메소드 데이터를 \n"
#~ "제거할 수 없습니다"

#, fuzzy
#~ msgid ""
#~ "trying to change the argument list of %s with %d arguments to have "
#~ "arguments (%s)"
#~ msgstr ""
#~ "인수(%s) 때문에 %d 인수와 함수의 논의 리스트를 %d인수와 변경하려고 합니다"

#, fuzzy
#~ msgid ""
#~ "get rid of variables in definition %s (%s); they conflict with the needed "
#~ "change to argument names (%s)"
#~ msgstr ""
#~ "정의(%s)에서 변수를 제거 해주십시오;그것들은 인수명(%s)에의 \n"
#~ "필요하게 되는 변경과 모순됩니다 "

#, fuzzy
#~ msgid "arguments in definition %s changed from (%s) to (%s)"
#~ msgstr "(%s)에서(%s)부터 변경되어진 정의 인수입니다"

#, fuzzy
#~ msgid ""
#~ "the methods object name for \"%s\" must include the name of the package "
#~ "that contains the generic function, but no generic function of this name "
#~ "was found"
#~ msgstr ""
#~ "'%s' 메소드 오브젝트 이름은 generic 메소드를 포함한 패키지의 이름을 \n"
#~ "포함하지 않으면 안됩니다, 그러나 이 이름의 generic인 함수가 없습니다"

#~ msgid ""
#~ "no way to associate a generic function with an object of class \"%s\""
#~ msgstr ""
#~ "메소드는 인수 generic 함수를 클래스 \"%s\" 오브젝트와 묶는 방법이 아닙니다"

#, fuzzy
#~ msgid "no methods found for generic \"%s\""
#~ msgstr "generic '%s'때문에 검색되는 메소드가 아닙니다"

#, fuzzy
#~ msgid "\"%s\" is not one of the basic functions"
#~ msgstr "'%s'는 basic 함수중에 하나가 아닙니다"

#, fuzzy
#~ msgid "cannot reset \"%s\", the definition is not a generic function object"
#~ msgstr "'%s'를 reset 할수 없는 generic 함수 오브젝트가 아닙니다"

#, fuzzy
#~ msgid "No nongeneric version of function \"%s\" exists to be restored"
#~ msgstr "'%s'가 검색되어진 non-geteric 함수가 아닙니다"

#, fuzzy
#~ msgid "\"%s\" from \"%s\" is a non-generic function; no methods available"
#~ msgstr ""
#~ "'%s'로부터 '%s'는 non-generic 함수입니다; 이용할 수 있는 메소드가 아닙니다"

#, fuzzy
#~ msgid ""
#~ "invalid 'fdef' for \"%s\" in 'getAllMethods'; expected either a "
#~ "'genericFunction object' or a primitive function, got an object of class "
#~ "\"%s\""
#~ msgstr ""
#~ "'getAllMethods'의 '%s' 때문에 무효인 'def' 입니다; 'gerericFunction' 또"
#~ "는\n"
#~ "최초의 함수를 예측해 클래스'%s'에 오브젝트를 얻었습니다"

#, fuzzy
#~ msgid "Methods list for generic \""
#~ msgstr "generic '%s'때문에 검색되는 메소드가 아닙니다"

#, fuzzy
#~ msgid "\" not found"
#~ msgstr "검색되지 않는 오브젝트 '%s' 입니다"

#, fuzzy
#~ msgid "Package \"%s\" is not loaded"
#~ msgstr "\"%s\"는 정의가 끝난 상태 클래스가 아닙니다"

#~ msgid "no generic function '%s' found"
#~ msgstr "'%s'가 검색되어 일반적인 함수가 아닙니다"

#~ msgid "no method found for function '%s' and signature %s"
#~ msgstr "함수'%s' 그리고 기호 %s 때문에 검색되는 메소드가 아닙니다"

#~ msgid "'%s' is not a function visible from '%s'"
#~ msgstr "'%s'는 '%s'로부터 보이는 함수가 아닙니다"

#~ msgid "trying to use new() on a virtual class"
#~ msgstr "virtual 클래스에서 new() 사용 하도록 시도합니다"
