{
	"DATE": {
		"a": "(година; месец; ден)",
		"d": "Връща числото, което представлява датата в кода за дата и час"
	},
	"DATEDIF": {
		"a": "( start-date , end-date , unit )",
		"d": "Date and time function used to return the difference between two date values (start date and end date), based on the interval (unit) specified"
	},
	"DATEVALUE": {
		"a": "(дата_текст)",
		"d": "Преобразува дата от текстов вид в число, което представя датата в кода за дата и час"
	},
	"DAY": {
		"a": "(пореден_номер)",
		"d": "Връща деня от месеца – число от 1 до 31."
	},
	"DAYS": {
		"a": "(крайна_дата; начална_дата)",
		"d": "Връща броя на дните между двете дати."
	},
	"DAYS360": {
		"a": "(начална_дата; крайна_дата; [метод])",
		"d": "Връща броя на дните между две дати на базата на година от 360 дни (дванайсет месеца от 30 дни)"
	},
	"EDATE": {
		"a": "(начална_дата; месеци)",
		"d": "Връща поредния номер на датата, която е определен брой месеци преди или след началната дата"
	},
	"EOMONTH": {
		"a": "(начална_дата; месеци)",
		"d": "Връща поредния номер на последния ден на месеца, който е преди или след определен брой месеци"
	},
	"HOUR": {
		"a": "(пореден_номер)",
		"d": "Връща часа като число от 0 (12:00 преди обяд) до 23 (11:00 следобед.)."
	},
	"ISOWEEKNUM": {
		"a": "(дата)",
		"d": "Връща номера на седмицата (по ISO) на годината за дадена дата"
	},
	"MINUTE": {
		"a": "(пореден_номер)",
		"d": "Връща минутата – число от 0 до 59."
	},
	"MONTH": {
		"a": "(пореден_номер)",
		"d": "Връща месеца – число от 1 (януари) до 12 (декември)."
	},
	"NETWORKDAYS": {
		"a": "(начална_дата; крайна_дата; [празници])",
		"d": "Връща броя на пълните работни дни между две дати"
	},
	"NETWORKDAYS.INTL": {
		"a": "(начална_дата; крайна_дата; [уикенд]; [празници])",
		"d": "Връща броя на пълните работни дни между две дати със задавани по избор параметри за почивните дни"
	},
	"NOW": {
		"a": "()",
		"d": "Връща текущите дата и час, форматирани като дата и час."
	},
	"SECOND": {
		"a": "(пореден_номер)",
		"d": "Връща секундата – число от 0 до 59."
	},
	"TIME": {
		"a": "(час; минута; секунда)",
		"d": "Преобразува часове, минути и секунди, зададени като числа, в пореден номер, форматиран с часови формат"
	},
	"TIMEVALUE": {
		"a": "(време_текст)",
		"d": "Преобразува време от текстов вид в серийно число за време – число от 0 (12:00:00 AM) до 0,999988426 (11:59:59 PM). След въвеждането на формулата форматирайте числото с часови формати"
	},
	"TODAY": {
		"a": "()",
		"d": "Връща текущата дата, форматирана като дата."
	},
	"WEEKDAY": {
		"a": "(пореден_номер; [връщане_тип])",
		"d": "Връща число от 1 до 7, показващо деня от седмицата при зададена дата."
	},
	"WEEKNUM": {
		"a": "(пореден_номер; [връщане_тип])",
		"d": "Връща номерата на седмиците в годината"
	},
	"WORKDAY": {
		"a": "(начална_дата; дни; [празници])",
		"d": "Връща поредния номер на датата преди или след определен брой работни дни от началната дата"
	},
	"WORKDAY.INTL": {
		"a": "(начална_дата; дни; [уикенд]; [празници])",
		"d": "Връща пореден номер на датата преди или след определен брой работни дни с параметри по избор за почивните дни"
	},
	"YEAR": {
		"a": "(пореден_номер)",
		"d": "Връща годината от дата – цяло число в диапазона 1900 – 9999."
	},
	"YEARFRAC": {
		"a": "(начална_дата; крайна_дата; [база])",
		"d": "Връща частта от годината, представляваща броя цели дни между началната и крайната дата"
	},
	"BESSELI": {
		"a": "(x; n)",
		"d": "Връща модифицираната Беселова функция In(x)"
	},
	"BESSELJ": {
		"a": "(x; n)",
		"d": "Връща Беселовата функция Jn(x)"
	},
	"BESSELK": {
		"a": "(x; n)",
		"d": "Връща модифицираната Беселова функция Kn(x)"
	},
	"BESSELY": {
		"a": "(x; n)",
		"d": "Връща Беселовата функция Yn(x)"
	},
	"BIN2DEC": {
		"a": "(число)",
		"d": " Превръща едно двоично число в десетично"
	},
	"BIN2HEX": {
		"a": "(число; [позиции])",
		"d": " Превръща едно двоично число в шестнайсетично"
	},
	"BIN2OCT": {
		"a": "(число; [позиции])",
		"d": " Превръща едно двоично число в осмично"
	},
	"BITAND": {
		"a": "(число1; число2)",
		"d": "Връща побитово \"И\" на две числа"
	},
	"BITLSHIFT": {
		"a": "(число; размер_на_изместване)",
		"d": "Връща число, изместено наляво с размер_на_изместване бита"
	},
	"BITOR": {
		"a": "(число1; число2)",
		"d": "Връща побитово \"Или\" на две числа"
	},
	"BITRSHIFT": {
		"a": "(число; размер_на_изместване)",
		"d": "Връща число, изместено надясно с размер_на_изместване бита"
	},
	"BITXOR": {
		"a": "(число1; число2)",
		"d": "Връща побитово \"Изключващо Или\" на две числа"
	},
	"COMPLEX": {
		"a": "(реално_число; i_число; [суфикс])",
		"d": "Преобразува реалния и имагинерния коефициент в комплексно число"
	},
	"CONVERT": {
		"a": "(число; от_единица; в_единица)",
		"d": "Преобразува числена стойност от една измервателна система в друга"
	},
	"DEC2BIN": {
		"a": "(число; [позиции])",
		"d": "Превръща едно десетично число в двоично"
	},
	"DEC2HEX": {
		"a": "(число; [позиции])",
		"d": " Превръща едно десетично число в шестнайсетично"
	},
	"DEC2OCT": {
		"a": "(число; [позиции])",
		"d": " Превръща едно десетично число в осмично"
	},
	"DELTA": {
		"a": "(число1; [число2])",
		"d": "Проверява дали две числа са равни"
	},
	"ERF": {
		"a": "(долна_граница; [горна_граница])",
		"d": "Връща функцията на грешките"
	},
	"ERF.PRECISE": {
		"a": "(X)",
		"d": "Връща функцията на грешки"
	},
	"ERFC": {
		"a": "(x)",
		"d": "Връща функцията на допълнителните грешки"
	},
	"ERFC.PRECISE": {
		"a": "(x)",
		"d": "Връща функцията на допълнителните грешки"
	},
	"GESTEP": {
		"a": "(число; [стъпка])",
		"d": "Проверява дали едно число е по-голямо от една прагова стойност"
	},
	"HEX2BIN": {
		"a": "(число; [позиции])",
		"d": "Преобразува едно шестнайсетично число в двоично"
	},
	"HEX2DEC": {
		"a": "(число)",
		"d": " Преобразува едно шестнайсетично число в десетично"
	},
	"HEX2OCT": {
		"a": "(число; [позиции])",
		"d": " Преобразува едно шестнайсетично число в осмично"
	},
	"IMABS": {
		"a": "(iчисло)",
		"d": "Връща абсолютната стойност (модула) на едно комплексно число"
	},
	"IMAGINARY": {
		"a": "(iчисло)",
		"d": "Връща имагинерния коефициент на едно комплексно число"
	},
	"IMARGUMENT": {
		"a": "(iчисло)",
		"d": "Връща аргумента q, ъгъл изразен в радиани"
	},
	"IMCONJUGATE": {
		"a": "(iчисло)",
		"d": "Връща комплексното спрегнато число на едно комплексно число"
	},
	"IMCOS": {
		"a": "(iчисло)",
		"d": "Връща косинуса на едно комплексно число"
	},
	"IMCOSH": {
		"a": "(комплексно_число)",
		"d": "Връща хиперболичния косинус на комплексно число"
	},
	"IMCOT": {
		"a": "(число)",
		"d": "Връща котангенса от комплексно число"
	},
	"IMCSC": {
		"a": "(число)",
		"d": "Връща косеканса от комплексно число"
	},
	"IMCSCH": {
		"a": "(число)",
		"d": "Връща хиперболичния косеканс от комплексно число"
	},
	"IMDIV": {
		"a": "(iчисло1; iчисло2)",
		"d": "Връща частното на две комплексни числа"
	},
	"IMEXP": {
		"a": "(iчисло)",
		"d": "Връща експонентата на едно комплексно число"
	},
	"IMLN": {
		"a": "(iчисло)",
		"d": "Връща натуралния логаритъм на едно комплексно число"
	},
	"IMLOG10": {
		"a": "(iчисло)",
		"d": "Връща логаритъма с основа 10 на едно комплексно число"
	},
	"IMLOG2": {
		"a": "(iчисло)",
		"d": "Връща логаритъма с основа 2 на едно комплексно число"
	},
	"IMPOWER": {
		"a": "(iчисло; число)",
		"d": "Връща комплексно число, повдигнато на цяла степен"
	},
	"IMPRODUCT": {
		"a": "(iчисло1; [iчисло2]; ...)",
		"d": "Връща произведението на 1 до 255 комплексни числа"
	},
	"IMREAL": {
		"a": "(iчисло)",
		"d": "Връща реалния коефициент на едно комплексно число"
	},
	"IMSEC": {
		"a": "(число)",
		"d": "Връща секанса от комплексно число"
	},
	"IMSECH": {
		"a": "(число)",
		"d": "Връща хиперболичния секанс на комплексно число"
	},
	"IMSIN": {
		"a": "(iчисло)",
		"d": "Връща синуса на едно комплексно число"
	},
	"IMSINH": {
		"a": "(комплексно_число)",
		"d": "Връща хиперболичния синус на комплексно число"
	},
	"IMSQRT": {
		"a": "(iчисло)",
		"d": "Връща квадратния корен на едно комплексно число"
	},
	"IMSUB": {
		"a": "(iчисло1; iчисло2)",
		"d": "Връща разликата на две комплексни числа"
	},
	"IMSUM": {
		"a": "(iчисло1; [iчисло2]; ...)",
		"d": "Връща сумата на комплексни числа"
	},
	"IMTAN": {
		"a": "(число)",
		"d": "Връща тангенса от комплексно число"
	},
	"OCT2BIN": {
		"a": "(число; [позиции])",
		"d": "Превръща едно осмично число в двоично"
	},
	"OCT2DEC": {
		"a": "(число)",
		"d": " Превръща едно осмично число в десетично"
	},
	"OCT2HEX": {
		"a": "(число; [позиции])",
		"d": "Превръща едно осмично число в шестнайсетично"
	},
	"DAVERAGE": {
		"a": "(база_данни; поле; критерий)",
		"d": "Осреднява стойностите в колона от списък или база_данни, които отговарят на зададените от вас условия"
	},
	"DCOUNT": {
		"a": "(база_данни; поле; критерий)",
		"d": "Преброява клетките, съдържащи числа в полето (колоната) от записите в базата данни, които отговарят на зададените от вас условия"
	},
	"DCOUNTA": {
		"a": "(база_данни; поле; критерий)",
		"d": "Преброява непразните клетки в полето (колоната) на записите в база_данни, които отговарят на зададени от вас условия"
	},
	"DGET": {
		"a": "(база_данни; поле; критерий)",
		"d": "Извлича от база данни единствен запис, който изпълнява зададени от вас условия"
	},
	"DMAX": {
		"a": "(база_данни; поле; критерий)",
		"d": " Връща най-голямото число в полето (колоната) от записите в базата данни, които отговарят на зададените от вас условия"
	},
	"DMIN": {
		"a": "(база_данни; поле; критерий)",
		"d": "Връща най-малкото число в полето (колоната) от записите в базата данни, които отговарят на зададените от вас условия"
	},
	"DPRODUCT": {
		"a": "(база_данни; поле; критерий)",
		"d": "Умножава стойностите в полето (колоната) на записите в базата данни, които отговарят на зададени от вас условия"
	},
	"DSTDEV": {
		"a": "(база_данни; поле; критерий)",
		"d": "Оценява стандартното отклонение, базирано на извадка от избрани елементи от база данни"
	},
	"DSTDEVP": {
		"a": "(база_данни; поле; критерий)",
		"d": "Изчислява стандартното отклонение на базата на цялата генерална съвкупност от избрани елементи от база данни"
	},
	"DSUM": {
		"a": "(база_данни; поле; критерий)",
		"d": "Сумира числата в полето (колоната) от записите в базата данни, които отговарят на зададените от вас условия"
	},
	"DVAR": {
		"a": "(база_данни; поле; критерий)",
		"d": "Оценява дисперсия, базирана на извадка от избрани елементи от база данни"
	},
	"DVARP": {
		"a": "(база_данни; поле; критерий)",
		"d": "Изчислява дисперсия на базата на цялата генерална съвкупност от избрани елементи от база данни"
	},
	"CHAR": {
		"a": "(число)",
		"d": "Връща знака, съответстващ на кодовото число от набора знаци на вашия компютър"
	},
	"CLEAN": {
		"a": "(текст)",
		"d": "Премахва всички непечатаеми знаци от текст"
	},
	"CODE": {
		"a": "(текст)",
		"d": "Връща числовия код на първия знак в текстов низ, съставен от набора знаци, използван от вашия компютър"
	},
	"CONCATENATE": {
		"a": "(текст1; [текст2]; ...)",
		"d": "Съединява няколко текстови низа в един текстов низ"
	},
	"CONCAT": {
		"a": "(текст1; ...)",
		"d": "Конкатенира списък или диапазон от текстови низове"
	},
	"DOLLAR": {
		"a": "(число; [десетични])",
		"d": "Преобразува число в текст, като използва валутен формат"
	},
	"EXACT": {
		"a": "(текст1; текст2)",
		"d": "Проверява дали два текстови низа са напълно еднакви и връща TRUE или FALSE. EXACT различава малките и главните букви"
	},
	"FIND": {
		"a": "(намери_текст; в_текст; [начален_ном])",
		"d": "Връща началната позиция на един текстов низ в друг текстов низ. FIND различава малките и главните букви"
	},
	"FINDB": {
		"a": "( string-1 , string-2 [ , start-pos ] )",
		"d": "Text and data function used to find the specified substring (string-1) within a string (string-2) and is intended for languages the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
	},
	"FIXED": {
		"a": "(число; [десетични]; [брой_запетаи])",
		"d": "Закръглява число до зададения брой десетични знаци и връща резултата като текст със или без запетаи"
	},
	"LEFT": {
		"a": "(текст; [брой_знаци])",
		"d": "Връща зададения брой знаци от началото на текстов низ"
	},
	"LEFTB": {
		"a": "( string [ , number-chars ] )",
		"d": "Text and data function used to extract the substring from the specified string starting from the left character and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
	},
	"LEN": {
		"a": "(текст)",
		"d": "Връща броя на знаците в текстов низ"
	},
	"LENB": {
		"a": "( string )",
		"d": "Text and data function used to analyse the specified string and return the number of characters it contains and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
	},
	"LOWER": {
		"a": "(текст)",
		"d": "Преобразува всички букви от текстов низ в малки букви"
	},
	"MID": {
		"a": "(текст; начален_ном; брой_знаци)",
		"d": "Връща знаците от средата на текстов низ при зададени начална позиция и дължина"
	},
	"MIDB": {
		"a": "( string , start-pos , number-chars )",
		"d": "Text and data function used to extract the characters from the specified string starting from any position and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
	},
	"NUMBERVALUE": {
		"a": "(текст; [десетичен_разделител]; [разделител_на_групи])",
		"d": "Преобразува текст в число по езиково независим начин"
	},
	"PROPER": {
		"a": "(текст)",
		"d": "Преобразува по подходящ начин буквите в текстов низ; първата буква от всяка дума в главна, а всички други букви в малки"
	},
	"REPLACE": {
		"a": "(стар_текст; начален_ном; брой_знаци; нов_текст)",
		"d": "Замества част от текстов низ с друг текстов низ"
	},
	"REPLACEB": {
		"a": "( string-1, start-pos, number-chars, string-2 )",
		"d": "Text and data function used to replace a set of characters, based on the number of characters and the start position you specify, with a new set of characters and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
	},
	"REPT": {
		"a": "(текст; брой_пъти)",
		"d": "Повтаря текст зададен брой пъти. Използвайте REPT, за да запълните клетка с множество екземпляри от текстов низ"
	},
	"RIGHT": {
		"a": "(текст; [брой_знаци])",
		"d": "Връща зададения брой знаци от края на текстов низ"
	},
	"RIGHTB": {
		"a": "( string [ , number-chars ] )",
		"d": "Text and data function used to extract a substring from a string starting from the right-most character, based on the specified number of characters and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
	},
	"SEARCH": {
		"a": "(намери_текст; в_текст; [начален_ном])",
		"d": "Връща броя на знаците, с които определен знак или текстов низ е намерен първоначално при обхождане отляво надясно (без да се отчитат разликите между малки и главни букви)"
	},
	"SEARCHB": {
		"a": "( string-1 , string-2 [ , start-pos ] )",
		"d": "Text and data function used to return the location of the specified substring in a string and is intended for languages that use the double-byte character set (DBCS) like Japanese, Chinese, Korean etc."
	},
	"SUBSTITUTE": {
		"a": "(текст; стар_текст; нов_текст; [срещане_ном])",
		"d": "Замества с нов текст съществуващ текст в текстов низ"
	},
	"T": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е текст и връща текста, ако е, или двойни кавички (празен текст), ако не е"
	},
	"TEXT": {
		"a": "(value; format_text)",
		"d": "                                                                                                                                                                                                      Преобразува стойност в текст със зададен числов формат"
	},
	"TEXTJOIN": {
		"a": "(разделител; игнориране_празни; текст1; ...)",
		"d": "Конкатенира списък или диапазон от текстови низове, като използва разделител"
	},
	"TRIM": {
		"a": "(текст)",
		"d": "Премахва всички интервали от текстов низ, освен единичните интервали между думите"
	},
	"UNICHAR": {
		"a": "(число)",
		"d": "Връща Unicode знака, сочен от дадената числена стойност"
	},
	"UNICODE": {
		"a": "(текст)",
		"d": "Връща номера (кодова точка), който съответства на първия знак на текста"
	},
	"UPPER": {
		"a": "(текст)",
		"d": "Преобразува всички букви от текстов низ в главни букви"
	},
	"VALUE": {
		"a": "(текст)",
		"d": "Преобразува в число текстов низ, съдържащ число"
	},
	"AVEDEV": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща средната стойност на абсолютните отклонения на точки данни от тяхната средна стойност. Аргументите могат да бъдат или числа, или имена, масиви или препратки, съдържащи числа"
	},
	"AVERAGE": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща средната стойност (средно аритметичното) на аргументите си, които могат да бъдат числа или имена, масиви или препратки, съдържащи числа"
	},
	"AVERAGEA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Връща средната стойност (аритметичното средно) на аргументите си, като оценява текст и FALSE в аргументите като 0; TRUE се оценява като 1. Аргументите могат да бъдат имена на числа, масиви или препратки"
	},
	"AVERAGEIF": {
		"a": "(диапазон; критерий; [среден_диапазон])",
		"d": "Намира средното (средно аритметичното) за клетките, удовлетворяващи дадено условие или критерии"
	},
	"AVERAGEIFS": {
		"a": "(среден_диапазон; критерий_диапазон; критерий; ...)",
		"d": " Намира средното (средно аритметичното) за клетките, удовлетворяващи даден набор от условия или критерии"
	},
	"BETADIST": {
		"a": "(x; алфа; бета; [A]; [B])",
		"d": "Връща кумулативната бета функция на вероятностната плътност"
	},
	"BETAINV": {
		"a": "(вероятност; алфа; бета; [A]; [B])",
		"d": "Връща обратната кумулативна бета функция на вероятностната плътност (BETADIST)"
	},
	"BETA.DIST": {
		"a": "(x; алфа; бета; кумулативна; [A]; [B])",
		"d": "Връща функцията за бета разпределение на вероятностите"
	},
	"BETA.INV": {
		"a": "(вероятност; алфа; бета; [A]; [B])",
		"d": "Връща обратната кумулативна бета функция на вероятностната плътност (BETA.DIST)"
	},
	"BINOMDIST": {
		"a": "(число_s; опити; вероятност_s; кумулативна)",
		"d": "Връща вероятност за биномиално разпределение на отделния член"
	},
	"BINOM.DIST": {
		"a": "(число_s; опити; вероятност_s; кумулативна)",
		"d": "Връща вероятност за биномиално разпределение на отделния член"
	},
	"BINOM.DIST.RANGE": {
		"a": "(опити; вероятност_s; брой_s; [брой_s2])",
		"d": "Връща вероятността за резултат от опит с използване на биномиално разпределение"
	},
	"BINOM.INV": {
		"a": "(опити; вероятност_s; алфа)",
		"d": "Връща най-малката стойност, за която кумулативното биномиално разпределение е по-голямо или равно на една стойност, избрана за критерий"
	},
	"CHIDIST": {
		"a": "(x; степ_свобода)",
		"d": "Връща едностранната вероятност на разпределението хи-квадрат"
	},
	"CHIINV": {
		"a": "(вероятност; степ_свобода)",
		"d": "Връща обратната на едностранната вероятност на хи-квадрат разпределението"
	},
	"CHITEST": {
		"a": "(действителен_диапазон; очакван_диапазон)",
		"d": "Връща теста за независимост: стойността от разпределението хи-квадрат за статистиката и съответните степени на свобода"
	},
	"CHISQ.DIST": {
		"a": "(x; степ_свобода; кумулативна)",
		"d": "Връща ограниченото отляво разпределение на вероятност хи-квадрат"
	},
	"CHISQ.DIST.RT": {
		"a": "(x; степ_свобода)",
		"d": "Връща ограниченото отдясно разпределение на вероятност хи-квадрат"
	},
	"CHISQ.INV": {
		"a": "(вероятност; степ_свобода)",
		"d": "Връща обратното на ограниченото отдясно разпределение на вероятност хи-квадрат"
	},
	"CHISQ.INV.RT": {
		"a": "(вероятност; степ_свобода)",
		"d": "Връща обратното на ограниченото отдясно разпределение на вероятност хи-квадрат"
	},
	"CHISQ.TEST": {
		"a": "(действителен_диапазон; очакван_диапазон)",
		"d": "Връща теста за независимост: стойността от разпределението хи-квадрат за статистиката и съответните степени на свобода"
	},
	"CONFIDENCE": {
		"a": "(алфа; стандартно_откл; размер)",
		"d": "Връща доверителния интервал за средната стойност на генералната съвкупност"
	},
	"CONFIDENCE.NORM": {
		"a": "(алфа; стандартно_откл; размер)",
		"d": "Връща доверителния интервал за средната стойност на генералната съвкупност, използвайки нормално разпределение"
	},
	"CONFIDENCE.T": {
		"a": "(алфа; стандартно_откл; размер)",
		"d": "Връща доверителния интервал за средната стойност на генералната съвкупност, използвайки T-разпределението на Стюдънт"
	},
	"CORREL": {
		"a": "(масив1; масив2)",
		"d": "Връща коефициента на корелация между два набора данни"
	},
	"COUNT": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Преброява клетките, които съдържат числа"
	},
	"COUNTA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Преброява клетките в диапазона, които не са празни"
	},
	"COUNTBLANK": {
		"a": "(диапазон)",
		"d": "Преброява празните клетки в зададен диапазон от клетки"
	},
	"COUNTIF": {
		"a": "(диапазон; критерий)",
		"d": "Преброява клетките в диапазон, отговарящи на зададено условие"
	},
	"COUNTIFS": {
		"a": "(критерий_диапазон; критерий; ...)",
		"d": "Преброява броя на клетките, удовлетворяващи даден набор от условия или критерии"
	},
	"COVAR": {
		"a": "(масив1; масив2)",
		"d": "Връща ковариацията – средната стойност на произведенията от отклоненията за всяка двойка от точки от данни в два набора от данни"
	},
	"COVARIANCE.P": {
		"a": "(масив1; масив2)",
		"d": "Връща ковариацията на генералната съвкупност – средната стойност на произведенията от отклоненията за всяка двойка от точки от данни в два набора от данни"
	},
	"COVARIANCE.S": {
		"a": "(масив1; масив2)",
		"d": "Връща ковариацията на извадката – средната стойност на произведенията от отклоненията за всяка двойка от точки от данни в два набора от данни"
	},
	"CRITBINOM": {
		"a": "(опити; вероятност_s; алфа)",
		"d": "Връща най-малката стойност, за която кумулативното биномиално разпределение е по-голямо или равно на една стойност, избрана за критерий"
	},
	"DEVSQ": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща сумата на квадратите на отклоненията на точки данни от средната стойност на тяхната извадка"
	},
	"EXPONDIST": {
		"a": "(x; ламбда; кумулативна)",
		"d": "Връща експоненциалното разпределение"
	},
	"EXPON.DIST": {
		"a": "(x; ламбда; кумулативна)",
		"d": "Връща експоненциалното разпределение"
	},
	"FDIST": {
		"a": "(x; степ_свобода1; степ_свобода2)",
		"d": "Връща вероятностното разпределение F (степента на различие) за два набора данни"
	},
	"FINV": {
		"a": "(вероятност; степ_свобода1; степ_свобода2)",
		"d": "Връща обратното на вероятностното разпределение F: ако p = FDIST(x,...), тогава FINV(p,...) = x"
	},
	"FTEST": {
		"a": "(масив1; масив2)",
		"d": "Връща резултата от F-тест – двустранната вероятност, че дисперсиите в \"масив1\" и \"масив2\" не са съществено различни"
	},
	"F.DIST": {
		"a": "(x; степ_свобода1; степ_свобода2; кумулативна)",
		"d": "Връща (ограничено отляво) F разпределение на вероятността (степента на различие) за два набора данни"
	},
	"F.DIST.RT": {
		"a": "(x; степ_свобода1; степ_свобода2)",
		"d": "Връща (ограничено отдясно) F разпределение на вероятността (степента на различие) за два набора данни"
	},
	"F.INV": {
		"a": "(вероятност; степ_свобода1; степ_свобода2)",
		"d": "Връща обратното на (ограничено отляво) F разпределението на вероятността: ако p = F.DIST(x,...), тогава F.INV(p,...) = x"
	},
	"F.INV.RT": {
		"a": "(вероятност; степ_свобода1; степ_свобода2)",
		"d": "Връща обратното на (ограничено отдясно) F разпределението на вероятността: ако p = F.DIST.RT(x,...), тогава F.INV.RT(p,...) = x"
	},
	"F.TEST": {
		"a": "(масив1; масив2)",
		"d": "Връща резултата от F-тест – двустранната вероятност, че дисперсиите в \"масив1\" и \"масив2\" не са съществено различни"
	},
	"FISHER": {
		"a": "(x)",
		"d": "Връща трансформацията на Фишер"
	},
	"FISHERINV": {
		"a": "(y)",
		"d": "Връща обратната трансформация на Фишер: ако y = FISHER(x), тогава FISHERINV(y) = x"
	},
	"FORECAST": {
		"a": "(x; известни_y; известни_x)",
		"d": "Изчислява или прогнозира бъдеща стойност при линейна тенденция, като използва съществуващи стойности"
	},
	"FORECAST.ETS": {
		"a": "(целева_дата; стойности; времева_линия; [сезонност]; [допълване_данни]; [агрегиране])",
		"d": "Връща прогнозната стойност за определена целева дата в бъдещето, като използва метода на експоненциално изглаждане."
	},
	"FORECAST.ETS.CONFINT": {
		"a": "(целева_дата; стойности; времева_линия; [степен_вероятност]; [сезонност]; [допълване_данни]; [агрегиране])",
		"d": "Връща интервала на вероятност за прогнозната стойност на зададената целева дата."
	},
	"FORECAST.ETS.SEASONALITY": {
		"a": "(стойности; времева_линия; [допълване_данни]; [агрегиране])",
		"d": "Връща дължината на повтарящия се модел, който приложението открива за определени времеви серии."
	},
	"FORECAST.ETS.STAT": {
		"a": "(стойности; времева_линия; тип_статистика; [сезонност]; [допълване_данни]; [агрегиране])",
		"d": "Връща исканата статистика за прогнозата."
	},
	"FORECAST.LINEAR": {
		"a": "(x; известни_y; известни_x)",
		"d": "Изчислява или прогнозира бъдеща стойност при линейна тенденция, като използва съществуващи стойности"
	},
	"FREQUENCY": {
		"a": "(данни_масив; двоични_масив)",
		"d": "Изчислява колко често се срещат стойностите в диапазон от стойности и връща вертикален масив от числа, който има един елемент повече от \"двоични_масив\""
	},
	"GAMMA": {
		"a": "(x)",
		"d": "Връща стойността на гама функцията"
	},
	"GAMMADIST": {
		"a": "(x; алфа; бета; кумулативна)",
		"d": "Връща гама разпределението"
	},
	"GAMMA.DIST": {
		"a": "(x; алфа; бета; кумулативна)",
		"d": "Връща гама разпределението"
	},
	"GAMMAINV": {
		"a": "(вероятност; алфа; бета)",
		"d": "Връща обратното на кумулативното гама разпределение: ако p = GAMMADIST(x,...), тогава GAMMAINV(p,...) = x"
	},
	"GAMMA.INV": {
		"a": "(вероятност; алфа; бета)",
		"d": "Връща обратното на кумулативното гама разпределение: ако p = GAMMA.DIST(x,...), тогава GAMMA.INV(p,...) = x"
	},
	"GAMMALN": {
		"a": "(x)",
		"d": "Връща натуралните логаритми от гама функцията"
	},
	"GAMMALN.PRECISE": {
		"a": "(x)",
		"d": "Връща натуралните логаритми от гама функцията"
	},
	"GAUSS": {
		"a": "(x)",
		"d": "Връща с 0,5 по-малко от стандартното нормално кумулативно разпределение"
	},
	"GEOMEAN": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща геометричната средна стойност на масив или диапазон от положителни числови данни"
	},
	"GROWTH": {
		"a": "(известни_y; [известни_x]; [нови_x]; [конст])",
		"d": " Връща числа в тенденция с експоненциално нарастване, отговаряща на известни точки данни"
	},
	"HARMEAN": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща хармоничната средна стойност на набор данни от положителни числа - реципрочната стойност на аритметичното средно на реципрочните стойности"
	},
	"HYPGEOM.DIST": {
		"a": "(извадка_s; число_извадка; съвкупност_s; число_съвк; кумулативна)",
		"d": "Връща хипергеометричното разпределение"
	},
	"HYPGEOMDIST": {
		"a": "(извадка_s; брой_извадка; ген_съвкупност_s; брой_съвк)",
		"d": "Връща хипергеометричното разпределение"
	},
	"INTERCEPT": {
		"a": "(известни_y; известни_x)",
		"d": "Изчислява точката, в която една линия ще пресече оста y, като използва регресионна линия с най-добро приближение, прекарана през известните x-стойности и y-стойности"
	},
	"KURT": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща ексцеса на набор данни"
	},
	"LARGE": {
		"a": "(масив; k)",
		"d": "Връща k-тата по големина стойност в набор данни, например петото по големина число"
	},
	"LINEST": {
		"a": "(известни_y; [известни_x]; [конст]; [състояния])",
		"d": "Връща статистики, описващи линейната тенденция, отговаряща на известни точки данни, чрез интерполиране с права линия, като използва метода на най-малките квадрати"
	},
	"LOGEST": {
		"a": "(известни_y; [известни_x]; [конст]; [състояния])",
		"d": " Връща статистики, описващи експоненциална крива, отговаряща на известни точки данни"
	},
	"LOGINV": {
		"a": "(вероятност; средно; стандартно_откл)",
		"d": "Връща обратното на логонормалната кумулативна функция на разпределение на x, където ln(x) е нормално разпределена с параметри \"средно\" и \"стандартно_откл\""
	},
	"LOGNORM.DIST": {
		"a": "(x; средно; стандартно_откл; кумулативна)",
		"d": "Връща логнормално разпределение на x, където ln(x) е нормално разпределено с параметри \"средно\" и \"стандартно_откл\""
	},
	"LOGNORM.INV": {
		"a": "(вероятност; средно; стандартно_откл)",
		"d": "Връща обратното на логонормалната кумулативна функция на разпределение на x, където ln(x) е нормално разпределена с параметри \"средно\" и \"стандартно_откл\""
	},
	"LOGNORMDIST": {
		"a": "(x; средно; стандартно_откл)",
		"d": "Връща кумулативното логонормално разпределение на x, където ln(x) е нормално разпределена с параметри \"средно\" и \"стандартно_откл\""
	},
	"MAX": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща най-голямата стойност в набор от стойности. Игнорира логически стойности и текст"
	},
	"MAXA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Връща най-голямата стойност в набор от стойности. Не игнорира логически стойности и текст"
	},
	"MAXIFS": {
		"a": "(макс_диапазон; критерий_диапазон; критерий; ...)",
		"d": "Връща максималната стойност от клетките, зададени от даден набор от условия или критерии"
	},
	"MEDIAN": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща медианата или числото в средата на набора от зададени числа"
	},
	"MIN": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща най-малкото число в набор от стойности. Игнорира логически стойности и текст"
	},
	"MINA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Връща най-малката стойност в набор от стойности. Не игнорира логически стойности и текст"
	},
	"MINIFS": {
		"a": "(мин_диапазон; критерий_диапазон; критерий; ...)",
		"d": "Връща минималната стойност от клетките, зададени от даден набор от условия или критерии"
	},
	"MODE": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща най-често срещащата се или повтаряща се стойност в масив или диапазон от данни – мода"
	},
	"MODE.MULT": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща вертикален масив на най-често появяващите се или повтарящи се стойности в масив или диапазон от данни. За хоризонтален масив използвайте =TRANSPOSE(MODE.MULT(число1,число2,...))"
	},
	"MODE.SNGL": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща най-често срещащата се или повтаряща се стойност в масив или диапазон от данни – мода"
	},
	"NEGBINOM.DIST": {
		"a": "(число_f; число_s; вероятност_s; кумулативна)",
		"d": "Връща отрицателното биномиално разпределение – вероятността да има \"число_f\" неуспешни опита преди \"число_s\"-я успех, с вероятност за успех \"вероятност_s\""
	},
	"NEGBINOMDIST": {
		"a": "(число_f; число_s; вероятност_s)",
		"d": "Връща отрицателното биномиално разпределение – вероятността да има \"число_f\" неуспешни опита преди \"число_s\"-я успех, с вероятност за успех \"вероятност_s\""
	},
	"NORM.DIST": {
		"a": "(x; средно; стандартно_откл; кумулативна)",
		"d": "Връща нормалното разпределение за зададени средна стойност и стандартно отклонение"
	},
	"NORMDIST": {
		"a": "(x; средно; стандартно_откл; кумулативна)",
		"d": "Връща нормалното кумулативно разпределение при зададени средна стойност и стандартно отклонение"
	},
	"NORM.INV": {
		"a": "(вероятност; средно; стандартно_откл)",
		"d": "Връща обратното на нормалното кумулативно разпределение за зададени средна стойност и стандартно отклонение"
	},
	"NORMINV": {
		"a": "(вероятност; средно; стандартно_откл)",
		"d": "Връща обратното на нормалното кумулативно разпределение за зададени средна стойност и стандартно отклонение"
	},
	"NORM.S.DIST": {
		"a": "(z; кумулативна)",
		"d": "Връща стандартното нормално разпределение (има средна стойност нула и стандартно отклонение единица)"
	},
	"NORMSDIST": {
		"a": "(z)",
		"d": "Връща стандартното нормално кумулативно разпределение (със средна стойност нула и стандартно отклонение единица)"
	},
	"NORM.S.INV": {
		"a": "(вероятност)",
		"d": "Връща обратното на стандартното нормално кумулативно разпределение (със средна стойност нула и стандартното отклонение единица)"
	},
	"NORMSINV": {
		"a": "(вероятност)",
		"d": "Връща обратното на стандартното нормално кумулативно разпределение (със средна стойност нула и стандартното отклонение единица)"
	},
	"PEARSON": {
		"a": "(масив1; масив2)",
		"d": "Връща коефициента на моментна корелация на Пиърсоново произведение r"
	},
	"PERCENTILE": {
		"a": "(масив; k)",
		"d": "Връща k-тия процентил на стойностите в диапазон"
	},
	"PERCENTILE.EXC": {
		"a": "(масив; k)",
		"d": "Връща k-тия процентил на стойностите в диапазон, където k е в диапазона 0..1, включително"
	},
	"PERCENTILE.INC": {
		"a": "(масив; k)",
		"d": "Връща k-тия процентил на стойностите в диапазон, където k е в диапазона 0..1, включително"
	},
	"PERCENTRANK": {
		"a": "(масив; x; [значимост])",
		"d": "Връща ранга на една стойност в набор данни във вид на процент от набора данни"
	},
	"PERCENTRANK.EXC": {
		"a": "(масив; x; [значимост])",
		"d": "Връща ранга на стойност в набор от данни като процент (0..1, включително) от набора данни"
	},
	"PERCENTRANK.INC": {
		"a": "(масив; x; [значимост])",
		"d": "Връща ранга на стойност в набор от данни като процент (0..1, включително) от набора данни"
	},
	"PERMUT": {
		"a": "(число; число_избрано)",
		"d": "Връща броя на пермутациите за зададено множество обекти, избрани от всички обекти"
	},
	"PERMUTATIONA": {
		"a": "(число; избран_брой)",
		"d": "Връща броя пермутации за даден брой обекти (с повторения), които могат да бъдат избрани от всички обекти"
	},
	"PHI": {
		"a": "(x)",
		"d": "Връща стойността на функцията на плътността на вероятностите за стандартно нормално разпределение"
	},
	"POISSON": {
		"a": "(x; средно; кумулативна)",
		"d": "Връща разпределението на Поасон"
	},
	"POISSON.DIST": {
		"a": "(x; средно; кумулативна)",
		"d": "Връща разпределението на Поасон"
	},
	"PROB": {
		"a": "(x_диапазон; вероятн_диапазон; долна_граница; [горна_граница])",
		"d": "Връща вероятността стойностите в един диапазон да са между две граници или равни на една долна граница"
	},
	"QUARTILE": {
		"a": "(масив; кварт)",
		"d": "Връща квартила на набор данни"
	},
	"QUARTILE.INC": {
		"a": "(масив; кварт)",
		"d": "Връща квартила на набор от данни, базиран на процентилни стойности от 0..1, включително"
	},
	"QUARTILE.EXC": {
		"a": "(масив; кварт)",
		"d": "Връща квартила на набор от данни, базиран на процентилни стойности от 0..1, включително"
	},
	"RANK": {
		"a": "(число; препр; [ред])",
		"d": "Връща ранга на число в списък от числа: големината на числото спрямо другите стойности в списъка"
	},
	"RANK.AVG": {
		"a": "(число; препр; [ред])",
		"d": "Връща ранга на число в списък от числа: големината на числото спрямо другите стойности в списъка; ако повече от едно числа имат еднакъв ранг, връща се средният ранг"
	},
	"RANK.EQ": {
		"a": "(число; препр; [ред])",
		"d": "Връща ранга на число в списък от числа: големината на числото спрямо другите стойности в списъка; ако повече от едно числа имат еднакъв ранг, връща се най-високият ранг на този набор от стойности"
	},
	"RSQ": {
		"a": "(известни_y; известни_x)",
		"d": "Връща квадрата на коефициента на моментна корелация на Пиърсоново произведение през дадените точки данни"
	},
	"SKEW": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща несиметричността на разпределение - характеристика на степента на асиметрия на едно разпределение около неговата средна стойност"
	},
	"SKEW.P": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща несиметричността на разпределение на базата на генерална съвкупност: характеризиране на асиметрията на разпределение около средната му стойност"
	},
	"SLOPE": {
		"a": "(известни_y; известни_x)",
		"d": "Връща наклона на линията на линейна регресия през зададените точки данни"
	},
	"SMALL": {
		"a": "(масив; k)",
		"d": "Връща k-тата най-малка стойност в набор данни, например петото най-малко число"
	},
	"STANDARDIZE": {
		"a": "(x; средно; стандартно_откл)",
		"d": "Връща нормализирана стойност от разпределение, определено чрез средна стойност и стандартно отклонение"
	},
	"STDEV": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща най-често срещащата се или повтаряща се стойност в масив или диапазон от данни – мода"
	},
	"STDEV.P": {
		"a": "(число1; [число2]; ...)",
		"d": "Изчислява стандартното отклонение на базата на цялата генерална съвкупност, зададена като аргументи (игнорира логически стойности и текст)"
	},
	"STDEV.S": {
		"a": "(число1; [число2]; ...)",
		"d": "Изчислява стандартното отклонение на базата на извадка (игнорира логически стойности и текст в извадката)"
	},
	"STDEVA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Оценява стандартното отклонение на базата на извадка, включваща логически стойности и текст. Текстът и логическата стойност FALSE имат стойност 0; логическата стойност TRUE има стойност 1"
	},
	"STDEVP": {
		"a": "(число1; [число2]; ...)",
		"d": "Изчислява стандартното отклонение на базата на цялата генерална съвкупност, зададена като аргументи (игнорира логически стойности и текст)"
	},
	"STDEVPA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Изчислява стандартното отклонение на базата на цялата генерална съвкупност, включително логическите стойности и текста. Текстът и логическата стойност FALSE имат стойност 0; логическата стойност TRUE има стойност 1"
	},
	"STEYX": {
		"a": "(известни_y; известни_x)",
		"d": "Връща стандартната грешка на предсказаната стойност на y за всяко x в регресия"
	},
	"TDIST": {
		"a": "(x; степ_свобода; опашки)",
		"d": "Връща t-разпределението на Стюдънт"
	},
	"TINV": {
		"a": "(вероятност; степ_свобода)",
		"d": "Връща обратното на t-разпределението на Стюдънт"
	},
	"T.DIST": {
		"a": "(x; степ_свобода; кумулативна)",
		"d": "Връща ограниченото отляво t-разпределение на Стюдънт"
	},
	"T.DIST.2T": {
		"a": "(x; степ_свобода)",
		"d": "Връща двустранно ограниченото t-разпределение на Стюдънт"
	},
	"T.DIST.RT": {
		"a": "(x; степ_свобода)",
		"d": "Връща ограниченото отдясно t-разпределение на Стюдънт"
	},
	"T.INV": {
		"a": "(вероятност; степ_свобода)",
		"d": "Връща ограниченото отляво t-разпределение на Стюдънт"
	},
	"T.INV.2T": {
		"a": "(вероятност; степ_свобода)",
		"d": "Връща обратното на двустранно ограниченото t-разпределение на Стюдънт"
	},
	"T.TEST": {
		"a": "(масив1; масив2; опашки; тип)",
		"d": "Връща вероятността, свързана с t-теста на Стюдънт"
	},
	"TREND": {
		"a": "(известни_y; [известни_x]; [нови_x]; [конст])",
		"d": "Връща числа в линейна тенденция, отговаряща на известни точки данни, като използва метода на най-малките квадрати"
	},
	"TRIMMEAN": {
		"a": "(масив; процент)",
		"d": "Връща средната стойност на вътрешна част от стойности  в набор от данни"
	},
	"TTEST": {
		"a": "(масив1; масив2; опашки; тип)",
		"d": "Връща вероятността, свързана с t-теста на Стюдънт"
	},
	"VAR": {
		"a": "(число1; [число2]; ...)",
		"d": "Изчислява дисперсия, базирана на извадка (игнорира логическите стойности и текста в извадката)"
	},
	"VAR.P": {
		"a": "(число1; [число2]; ...)",
		"d": "Изчислява дисперсия на базата на цялата генерална съвкупност (игнорира логическите стойности и текста в съвкупността)"
	},
	"VAR.S": {
		"a": "(число1; [число2]; ...)",
		"d": "Изчислява дисперсия, базирана на извадка (игнорира логическите стойности и текста в извадката)"
	},
	"VARA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Оценява дисперсия на базата на извадка, включваща логически стойности и текст. Текстът и логическата стойност FALSE имат стойност 0; логическата стойност TRUE има стойност 1"
	},
	"VARP": {
		"a": "(число1; [число2]; ...)",
		"d": "Изчислява дисперсия на базата на цялата генерална съвкупност (игнорира логическите стойности и текста в съвкупността)"
	},
	"VARPA": {
		"a": "(стойност1; [стойност2]; ...)",
		"d": "Изчислява дисперсия на базата на цялата генерална съвкупност, включително логически стойности и текст. Текстът и логическата стойност FALSE имат стойност 0; логическата стойност TRUE има стойност 1"
	},
	"WEIBULL": {
		"a": "(x; алфа; бета; кумулативна)",
		"d": "Връща разпределението на Уейбул"
	},
	"WEIBULL.DIST": {
		"a": "(x; алфа; бета; кумулативна)",
		"d": "Връща разпределението на Уейбул"
	},
	"Z.TEST": {
		"a": "(масив; x; [сигма])",
		"d": "Връща едностранната P-стойност на z-тест"
	},
	"ZTEST": {
		"a": "(масив; x; [сигма])",
		"d": "Връща едностранната P-стойност на z-тест"
	},
	"ACCRINT": {
		"a": "(издание; първа_лихва; разчет; ставка; пар; честота; [база]; [изч_метод])",
		"d": "Връща натрупаната лихва за ценни книжа, по които периодично се плаща лихва."
	},
	"ACCRINTM": {
		"a": "(издание; разчет; ставка; пар; [база])",
		"d": "Връща натрупаната лихва за ценни книжа, по които се плаща лихва при погасяване"
	},
	"AMORDEGRC": {
		"a": "(стойност; дата_покупка; първи_период; ликвидационна_стойност; период; ставка; [база])",
		"d": "Връща величината на пропорционално разпределената амортизация на актива за всеки осчетоводяван период."
	},
	"AMORLINC": {
		"a": "(стойност; дата_покупка; първи_период; ликвидационна_стойност; период; ставка; [база])",
		"d": "Връща величината на пропорционално разпределената амортизация на актива за всеки осчетоводяван период."
	},
	"COUPDAYBS": {
		"a": "(разчет; погасяване; честота; [база])",
		"d": "Връща броя на дните от началото на действие на купона до датата на разчета"
	},
	"COUPDAYS": {
		"a": "(разчет; погасяване; честота; [база])",
		"d": "Връща броя на дните в периода на купона, който съдържа датата на разчета"
	},
	"COUPDAYSNC": {
		"a": "(разчет; погасяване; честота; [база])",
		"d": "Връща броя на дните от датата на разчета до датата на следващия купон"
	},
	"COUPNCD": {
		"a": "(разчет; погасяване; честота; [база])",
		"d": "Връща номера на датата на следващия купон след датата на разчета"
	},
	"COUPNUM": {
		"a": "(разчет; погасяване; честота; [база])",
		"d": "Връща броя на изплащаните купони между датата на разчета и датата на погасяване на ценните книжа"
	},
	"COUPPCD": {
		"a": "(разчет; погасяване; честота; [база])",
		"d": "Връща поредния номер на датата на предишния купон преди датата на разчета"
	},
	"CUMIPMT": {
		"a": "(ставка; периоди; pv; начален_период; краен_период; тип)",
		"d": "Връща кумулативната (с натрупване) стойност на лихвата, изплащана между два периода"
	},
	"CUMPRINC": {
		"a": "(ставка; периоди; pv; начален_период; краен_период; тип)",
		"d": "Връща кумулативната (с натрупване) сума, изплащана за погасяване основната сума на заема в промеждутъка между два периода"
	},
	"DB": {
		"a": "(стойност; ликвидационна_стойност; живот; период; [месец])",
		"d": "Връща амортизацията на актив за зададен период, като използва балансния метод с фиксирано намаление"
	},
	"DDB": {
		"a": "(стойност; ликвидационна_стойност; живот; период; [коефициент])",
		"d": "Връща амортизацията на актив за зададен период, като използва балансния метод с двойно намаляване или някой друг зададен от вас метод"
	},
	"DISC": {
		"a": "(разчет; погасяване; pr; изкупуване; [база])",
		"d": "Връща ставката за отстъпка за ценни книжа"
	},
	"DOLLARDE": {
		"a": "(дробен_долар; дроб)",
		"d": "Преобразува цена в долари, изразена като дроб, в цена в долари, изразена като десетично число"
	},
	"DOLLARFR": {
		"a": "(десетичен_долар; дроб)",
		"d": "Преобразува цена в долари, изразена като десетично число, в цена в долари, изразена като дроб"
	},
	"DURATION": {
		"a": "(разчет; погасяване; купон; доходност; честота; [база])",
		"d": "Връща годишното времетраене на ценни книжа, по които се изплаща периодична лихва"
	},
	"EFFECT": {
		"a": "(номинална_ставка; периоди_г)",
		"d": "Връща фактическата (ефективна) годишна лихвена ставка"
	},
	"FV": {
		"a": "(процент; периоди; плащ; [pv]; [тип])",
		"d": "Връща бъдещата стойност на инвестиция, базирана на периодични постоянни плащания и постоянна лихва"
	},
	"FVSCHEDULE": {
		"a": "(главница; график)",
		"d": "Връща бъдещото значение на първоначалната основна сума след прилагане на редица (планови) сложни лихвени ставки"
	},
	"INTRATE": {
		"a": "(разчет; погасяване; инвестиция; изкупуване; [база])",
		"d": "Връща лихвената ставка за напълно инвестирани ценни книжа"
	},
	"IPMT": {
		"a": "(ставка; период; периоди; pv; [fv]; [тип])",
		"d": "Връща лихвеното плащане за даден период за инвестиция, базирана на периодични постоянни плащания и постоянна лихва"
	},
	"IRR": {
		"a": "(стойности; [предположение])",
		"d": "Връща вътрешната норма на печалба за серия от парични потоци"
	},
	"ISPMT": {
		"a": "(ставка; пер; периоди; pv)",
		"d": "Връща лихвата, плащана по време на определен период на инвестиция"
	},
	"MDURATION": {
		"a": "(разчет; погасяване; купон; доходност; честота; [база])",
		"d": "Връща модифицираното времетраене на Макалей за ценни книжа с предполагаема номинална стойност 100 лв."
	},
	"MIRR": {
		"a": "(стойности; финансиране_коефициент; реинвестиране_коефициент)",
		"d": "Връща вътрешната норма на печалба за серия от периодични парични потоци, отчитайки както цената на инвестицията, така и лихвата при реинвестиране на наличностите"
	},
	"NOMINAL": {
		"a": "(факт_ставка; периоди)",
		"d": "Връща номиналната годишна лихвена ставка"
	},
	"NPER": {
		"a": "(ставка; плащ; pv; [fv]; [тип])",
		"d": "Връща броя периоди за инвестиция, базирана на периодични постоянни плащания и постоянна лихва"
	},
	"NPV": {
		"a": "(ставка; стойност1; [стойност2]; ...)",
		"d": "Връща нетната настояща стойност на инвестиция, базирана на дисконтова ставка, и серия от бъдещи плащания (отрицателни стойности) и приход (положителни стойности)"
	},
	"ODDFPRICE": {
		"a": "(разчет; погасяване; издаване; пръв_купон; ставка; доходност; изкупуване; честота; [база])",
		"d": "Връща цената на ценни книжа с номинална стойност 100 лв. и с нередовен пръв период"
	},
	"ODDFYIELD": {
		"a": "(разчет; погасяване; издаване; пръв_купон; ставка; pr; изкупуване; честота; [база])",
		"d": "Връща доход по ценни книжа с нередовен пръв период"
	},
	"ODDLPRICE": {
		"a": "(разчет; погасяване; последна_лихва; ставка; доходност; изкупуване; честота; [база])",
		"d": "Връща цената за номинална стойност 100 лв.на ценни книжа с нередовен последен период на купона"
	},
	"ODDLYIELD": {
		"a": "(разчет; погасяване; последна_лихва; ставка; pr; изкупуване; честота; [база])",
		"d": "Връща доходността на ценни книжа с нередовен последен период"
	},
	"PDURATION": {
		"a": "(оценка; настояща_стойност; бъдеща_стойност)",
		"d": "Връща броя периоди, необходими, за да достигне дадена инвестиция указана стойност"
	},
	"PMT": {
		"a": "(ставка; периоди; pv; [fv]; [тип])",
		"d": "Изчислява изплащането за заем на базата на постоянни плащания и постоянна лихва"
	},
	"PPMT": {
		"a": "(ставка; период; периоди; pv; [fv]; [тип])",
		"d": "Връща плащането върху главницата за дадена инвестиция, базирана на периодични постоянни плащания и постоянна лихва"
	},
	"PRICE": {
		"a": "(разчет; погасяване; ставка; доходност; изкупуване; честота; [база])",
		"d": "Връща цената за номинална стойност 100 лв. на ценни книжа, по които се изплаща периодична лихва"
	},
	"PRICEDISC": {
		"a": "(разчет; погасяване; отстъпка; изкупуване; [база])",
		"d": "Връща цената за номинална стойност 100 лв. на ценни книжа, за които е направена отстъпка"
	},
	"PRICEMAT": {
		"a": "(разчет; погасяване; издание; ставка; доходност; [база])",
		"d": "Връща цената за 100 лв. номинална стойност на ценни книжа, по които се изплаща лихва при погасяване"
	},
	"PV": {
		"a": "(ставка; периоди; плащ; [fv]; [тип])",
		"d": "Връща настоящата стойност на инвестиция: общата сума, която серията от бъдещи плащания струва сега"
	},
	"RATE": {
		"a": "(периоди; плащ; pv; [fv]; [тип]; [предположение])",
		"d": "Връща лихвата за период на заем или инвестиция. Например използвайте 6%/4 за тримесечни плащания при 6% APR"
	},
	"RECEIVED": {
		"a": "(разчет; погасяване; инвестиция; отстъпка; [база])",
		"d": "Връща сумата, получена към срока на погасяване за напълно инвестирани ценни книжа"
	},
	"RRI": {
		"a": "(периоди; настояща_стойност; бъдеща_стойност)",
		"d": "Връща еквивалентна лихва за нарастването на инвестиция"
	},
	"SLN": {
		"a": "(стойност; ликвидационна_стойност; живот)",
		"d": "Връща линейната амортизация на един актив за един период"
	},
	"SYD": {
		"a": "(стойност; ликвидационна_стойност; живот; пер)",
		"d": "Връща амортизацията на актив за зададен период, изчислена по метода \"Сума на годините\""
	},
	"TBILLEQ": {
		"a": "(разчет; погасяване; отстъпка)",
		"d": "Връща еквивалентен доход за съкровищни бонове"
	},
	"TBILLPRICE": {
		"a": "(разчет; погасяване; отстъпка)",
		"d": "Връща цената за номинална стойност 100 лв. на един съкровищен бон"
	},
	"TBILLYIELD": {
		"a": "(разчет; погасяване; pr)",
		"d": "Връща доходността на съкровищен бон"
	},
	"VDB": {
		"a": "(стойност; ликвидационна_стойност; живот; начален_период; краен_период; [коефициент]; [не_превключвай])",
		"d": "Връща амортизацията на актив за произволен зададен период, включващ частични периоди, като използва балансния метод с двойно намаляване или някой друг зададен от вас метод"
	},
	"XIRR": {
		"a": "(стойности; дати; [предположение])",
		"d": "Връща вътрешната ставка на доходност за график от парични потоци"
	},
	"XNPV": {
		"a": "(ставка; стойности; дати)",
		"d": "Връща чистата приведена стойност за график от парични потоци"
	},
	"YIELD": {
		"a": "(разчет; погасяване; ставка; pr; изкупуване; честота; [база])",
		"d": "Връща доходността на ценни книжа, по които се плаща периодична лихва"
	},
	"YIELDDISC": {
		"a": "(разчет; погасяване; pr; изкупуване; [база])",
		"d": "Връща годишната доходност на ценни книжа, за които е направена отстъпка. Например един съкровищен бон"
	},
	"YIELDMAT": {
		"a": "(разчет; погасяване; издание; ставка; pr; [база])",
		"d": "Връща годишната доходност на ценни книжа, по които се изплаща лихва при погасяване"
	},
	"ABS": {
		"a": "(число)",
		"d": "Връща абсолютната стойност на число, която представлява числото без знака му"
	},
	"ACOS": {
		"a": "(число)",
		"d": "Връща аркускосинуса от число в радиани в диапазона от 0 до Pi. Аркускосинусът е ъгълът, чийто косинус е \"число\""
	},
	"ACOSH": {
		"a": "(число)",
		"d": "Връща обратния хиперболичен косинус от число"
	},
	"ACOT": {
		"a": "(число)",
		"d": "Връща аркускотангенса от число в радиани в диапазона от 0 до пи."
	},
	"ACOTH": {
		"a": "(число)",
		"d": "Връща обратния хиперболичен котангенс от число"
	},
	"AGGREGATE": {
		"a": "(function_ном; опции; препр1; ...)",
		"d": "Връща агрегат в списък или база данни"
	},
	"ARABIC": {
		"a": "(текст)",
		"d": "Преобразува римска цифра в арабска"
	},
	"ASC": {
		"a": "( text )",
		"d": "Text function for Double-byte character set (DBCS) languages, the function changes full-width (double-byte) characters to half-width (single-byte) characters"
	},
	"ASIN": {
		"a": "(число)",
		"d": "Връща аркуссинуса от число в радиани в диапазона -Pi/2 до Pi/2"
	},
	"ASINH": {
		"a": "(число)",
		"d": "Връща обратния хиперболичен синус от число"
	},
	"ATAN": {
		"a": "(число)",
		"d": "Връща аркустангенса от число в радиани в диапазона от -Pi/2 до Pi/2"
	},
	"ATAN2": {
		"a": "(x_числ; y_числ)",
		"d": "Връща аркустангенса от зададените x и y координати в радиани между -Pi и Pi, с изключение на -Pi"
	},
	"ATANH": {
		"a": "(число)",
		"d": "Връща обратния хиперболичен тангенс от число"
	},
	"BASE": {
		"a": "(число; основа; [минимална_дължина])",
		"d": "Преобразува число в текстово представяне с дадена основа (база)"
	},
	"CEILING": {
		"a": "(число; значимост)",
		"d": "Закръглява число нагоре до най-близкото кратно на значимост"
	},
	"CEILING.MATH": {
		"a": "(число; [значимост]; [режим])",
		"d": "Закръглява число нагоре до най-близкото цяло число или най-близкото кратно на \"значимост\""
	},
	"CEILING.PRECISE": {
		"a": "( x [ , significance ] )",
		"d": "Math and trigonometry function used to return a number that is rounded up to the nearest integer or to the nearest multiple of significance"
	},
	"COMBIN": {
		"a": "(число; число_избрано)",
		"d": "Връща броя комбинации за зададен брой елементи"
	},
	"COMBINA": {
		"a": "(число; избран_брой)",
		"d": "Връща броя комбинации с повторения за даден брой от елементи"
	},
	"COS": {
		"a": "(число)",
		"d": "Връща косинуса от ъгъл"
	},
	"COSH": {
		"a": "(число)",
		"d": "Връща хиперболичния косинус от число"
	},
	"COT": {
		"a": "(число)",
		"d": "Връща котангенса от ъгъл"
	},
	"COTH": {
		"a": "(число)",
		"d": "Връща хиперболичния котангенс от число"
	},
	"CSC": {
		"a": "(число)",
		"d": "Връща косеканса от ъгъл"
	},
	"CSCH": {
		"a": "(число)",
		"d": "Връща хиперболичния косеканс от ъгъл"
	},
	"DECIMAL": {
		"a": "(число; основа)",
		"d": "Преобразува текстово представяне на число с дадена база в десетично число"
	},
	"DEGREES": {
		"a": "(ъгъл)",
		"d": "Преобразува радиани в градуси"
	},
	"ECMA.CEILING": {
		"a": "( x, significance )",
		"d": "Math and trigonometry function used to round the number up to the nearest multiple of significance"
	},
	"EVEN": {
		"a": "(число)",
		"d": "Закръглява положително число нагоре и отрицателно число надолу до най-близкото четно цяло число"
	},
	"EXP": {
		"a": "(число)",
		"d": "Връща \"e\" на степен зададено число"
	},
	"FACT": {
		"a": "(число)",
		"d": "Връща факториела на число, който е равен на 1*2*3*...* число"
	},
	"FACTDOUBLE": {
		"a": "(число)",
		"d": "Връща двойния факториел на едно число"
	},
	"FLOOR": {
		"a": "(число; значимост)",
		"d": "Закръглява число надолу до най-близкото кратно на \"значимост\""
	},
	"FLOOR.PRECISE": {
		"a": "( x [, significance] )",
		"d": "Math and trigonometry function used to return a number that is rounded down to the nearest integer or to the nearest multiple of significance"
	},
	"FLOOR.MATH": {
		"a": "(число; [значимост]; [режим])",
		"d": "Закръглява число надолу до най близкото цяло число или най-близкото кратно на \"значимост\""
	},
	"GCD": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща най-големия общ делител"
	},
	"INT": {
		"a": "(число)",
		"d": "Закръглява число надолу до най-близкото цяло число"
	},
	"ISO.CEILING": {
		"a": "( number [ , significance ] )",
		"d": "Math and trigonometry function used to return a number that is rounded up to the nearest integer or to the nearest multiple of significance regardless of the sign of the number. However, if the number or the significance is zero, zero is returned."
	},
	"LCM": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща най-малкото общо кратно"
	},
	"LN": {
		"a": "(число)",
		"d": "Връща натуралния логаритъм от число"
	},
	"LOG": {
		"a": "(число; [основа])",
		"d": "Връща логаритъма от число при зададена от вас основа"
	},
	"LOG10": {
		"a": "(число)",
		"d": "Връща логаритъма с основа 10 от число"
	},
	"MDETERM": {
		"a": "(масив)",
		"d": "Връща детерминантата на матрица, представена като масив"
	},
	"MINVERSE": {
		"a": "(масив)",
		"d": "Връща обратната матрица на матрица, записана в масив"
	},
	"MMULT": {
		"a": "(масив1; масив2)",
		"d": "Връща матричното произведение на два масива, което представлява масив със същия брой редове като \"масив1\" и същия брой колони като \"масив2\""
	},
	"MOD": {
		"a": "(число; делител)",
		"d": "Връща остатъка, след като едно число е разделено с делител"
	},
	"MROUND": {
		"a": "(число; точност)",
		"d": "Връща закръглено число с желана точност"
	},
	"MULTINOMIAL": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща отношението на факториела на сума стойности към произведението от факториелите на стойностите на едно множество от числа"
	},
	"MUNIT": {
		"a": "(размер)",
		"d": "Връща единична матрица за указания размер"
	},
	"ODD": {
		"a": "(число)",
		"d": "Закръглява положително число нагоре и отрицателно число надолу до най-близкото нечетно цяло число"
	},
	"PI": {
		"a": "()",
		"d": "Връща стойността на Pi, 3,14159265358979 с точност до 15 цифри"
	},
	"POWER": {
		"a": "(число; степен)",
		"d": "Връща резултата от повдигането на число на степен"
	},
	"PRODUCT": {
		"a": "(число1; [число2]; ...)",
		"d": "Умножава всички числа, зададени като аргументи"
	},
	"QUOTIENT": {
		"a": "(числител; знаменател)",
		"d": "Връща цялата част при деление"
	},
	"RADIANS": {
		"a": "(ъгъл)",
		"d": "Преобразува градуси в радиани"
	},
	"RAND": {
		"a": "()",
		"d": "Връща случайно число, по-голямо или равно на 0 и по-малко от 1, равномерно разпределено (променя се при преизчисляване)"
	},
	"RANDARRAY": {
		"a": "([редове]; [колони]; [мин]; [макс]; [цяло_число])",
		"d": "Връща масив от случайни числа"
	},
	"RANDBETWEEN": {
		"a": "(долно; горно)",
		"d": "Връща случайно число между две зададени числа"
	},
	"ROMAN": {
		"a": "(число; [форма])",
		"d": "Преобразува арабско число в римско във вид на текст"
	},
	"ROUND": {
		"a": "(число; брой_цифри)",
		"d": "Закръглява число до зададен брой цифри"
	},
	"ROUNDDOWN": {
		"a": "(число; брой_цифри)",
		"d": "Закръглява число надолу към нулата"
	},
	"ROUNDUP": {
		"a": "(число; брой_цифри)",
		"d": "Закръглява число нагоре, в обратна на нулата посока"
	},
	"SEC": {
		"a": "(число)",
		"d": "Връща секанса от ъгъл"
	},
	"SECH": {
		"a": "(число)",
		"d": "Връща хиперболичния секанс от ъгъл"
	},
	"SERIESSUM": {
		"a": "(x; n; m; коефициенти)",
		"d": "Връща сумата на един степенен ред, основан на формула"
	},
	"SIGN": {
		"a": "(число)",
		"d": "Връща знака на число: 1, ако числото е положително, нула, ако числото е нула, или -1, ако числото е отрицателно"
	},
	"SIN": {
		"a": "(число)",
		"d": "Връща синуса от ъгъл"
	},
	"SINH": {
		"a": "(число)",
		"d": "Връща хиперболичния синус от число"
	},
	"SQRT": {
		"a": "(число)",
		"d": "Връща квадратния корен от число"
	},
	"SQRTPI": {
		"a": "(число)",
		"d": "Връща квадратния корен на (числото * пи)"
	},
	"SUBTOTAL": {
		"a": "(функция_ном; препр1; ...)",
		"d": "Връща междинна сума в списък или база данни"
	},
	"SUM": {
		"a": "(число1; [число2]; ...)",
		"d": "Сумира всички числа в диапазон от клетки"
	},
	"SUMIF": {
		"a": "(диапазон; критерий; [сум_диапазон])",
		"d": "Сумира клетките, зададени с определено условие или критерий"
	},
	"SUMIFS": {
		"a": "(сум_диапазон; критерий_диапазон; критерий; ...)",
		"d": "Сумира клетките, които удовлетворяват даден набор от условия или критерии"
	},
	"SUMPRODUCT": {
		"a": "(масив1; [масив2]; [масив3]; ...)",
		"d": "Връща сумата на произведенията от съответните диапазони или масиви"
	},
	"SUMSQ": {
		"a": "(число1; [число2]; ...)",
		"d": "Връща сумата на квадратите на аргументите. Аргументите могат да бъдат числа, имена на масиви или препратки към клетки, съдържащи числа"
	},
	"SUMX2MY2": {
		"a": "(масив_x; масив_y)",
		"d": "Сумира разликите между квадратите на два съответстващи си диапазона или масива"
	},
	"SUMX2PY2": {
		"a": "(масив_x; масив_y)",
		"d": " Връща общата сума на квадратите на числата в два съответстващи си диапазона или масива"
	},
	"SUMXMY2": {
		"a": "(масив_x; масив_y)",
		"d": "Сумира квадратите на разликите в два съответстващи си диапазона или масиви"
	},
	"TAN": {
		"a": "(число)",
		"d": "Връща тангенса от ъгъл"
	},
	"TANH": {
		"a": "(число)",
		"d": "Връща хиперболичния тангенс от число"
	},
	"TRUNC": {
		"a": "(число; [брой_цифри])",
		"d": "Отрязва число до цяло число, като премахва десетичната, или дробната, част от числото"
	},
	"ADDRESS": {
		"a": "(ред_ном; колона_ном; [абс_ном]; [a1]; [лист_текст])",
		"d": "Създава препратка към клетка във вид на текст при зададени номера на ред и колона"
	},
	"CHOOSE": {
		"a": "(индекс_числ; стойност1; [стойност2]; ...)",
		"d": "Избира стойност или действие за изпълнение от списък стойности на базата на индекс"
	},
	"COLUMN": {
		"a": "([препратка])",
		"d": "Връща номера на колоната на препратка"
	},
	"COLUMNS": {
		"a": "(масив)",
		"d": "Връща броя на колоните в масив или препратка"
	},
	"FORMULATEXT": {
		"a": "(препратка)",
		"d": "Връща формула като низ"
	},
	"HLOOKUP": {
		"a": "(справочна_стойност; масив_таблица; рез_индекс_номер; [диапазон_справка])",
		"d": "Търси стойност в горния ред на таблица или масив от стойности и връща стойността в същата колона на реда, който сте задали"
	},
	"HYPERLINK": {
		"a": "(връзка_местоположение; [истинско_име])",
		"d": "Създава пряк път или преход за отваряне на документ, записан на вашия твърд диск, мрежов сървър или в интернет"
	},
	"INDEX": {
		"a": "(масив; ред_ном; [колона_ном]!препратка; ред_ном; [колона_ном]; [област_ном])",
		"d": "Връща стойност или препратка към клетката в пресечната точка на зададени ред и колона, в зададен диапазон"
	},
	"INDIRECT": {
		"a": "(препр_текст; [a1])",
		"d": "Връща препратка, зададена с текстов низ"
	},
	"LOOKUP": {
		"a": "(справка_стойност; справка_вектор; [резултат_вектор]!справка_стойност; масив)",
		"d": "Търси стойност или от едноредов, или от едноколонен диапазон, или от масив. Предоставя се за обратна съвместимост"
	},
	"MATCH": {
		"a": "(справка_стойност; справка_масив; [съвпадение_тип])",
		"d": "Връща относителното положение на елемент в масив, което отговаря на зададена стойност при зададена подредба"
	},
	"OFFSET": {
		"a": "(препратка; редове; колони; [височина]; [ширина])",
		"d": "Връща препратка към диапазон, за който са зададени броя на редовете и колоните спрямо дадена препратка"
	},
	"ROW": {
		"a": "([препратка])",
		"d": "Връща номера на реда на препратка"
	},
	"ROWS": {
		"a": "(масив)",
		"d": "Връща броя на редовете в препратка или масив"
	},
	"TRANSPOSE": {
		"a": "(масив)",
		"d": "Преобразува вертикален диапазон от клетки в хоризонтален и обратно"
	},
	"UNIQUE": {
		"a": "(масив; [по_кол]; [точно_веднъж])",
		"d": "Връща уникалните стойности от диапазон или масив."
	},
	"VLOOKUP": {
		"a": "(справка_стойност; масив_таблица; кол_индекс_ном; [диапазон_справка])",
		"d": "Търси стойност в най-лявата колона на таблица и връща стойност в същия ред на колона, която зададете. По подразбиране таблицата трябва да бъде сортирана в нарастващ ред"
	},
	"XLOOKUP": {
		"a": "(стойност_справка; масив_справка; масив_връщане; [ако_не_е_намерено]; [режим_съвпадение]; [режим_търсене])",
		"d": "Търси в диапазон или масив и връща съответния елемент от втори диапазон или масив. По подразбиране се използва точно съвпадение"
	},
	"CELL": {
		"a": "(info_type, [reference])",
		"d": "Information function used to return information about the formatting, location, or contents of a cell"
	},
	"ERROR.TYPE": {
		"a": "(грешка_стойност)",
		"d": "Връща число, отговарящо на грешна стойност."
	},
	"ISBLANK": {
		"a": "(стойност)",
		"d": "Проверява дали една препратка е към празна клетка и връща TRUE или FALSE"
	},
	"ISERR": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е грешка, различна от #N/A, и връща TRUE или FALSE"
	},
	"ISERROR": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е грешка и връща TRUE или FALSE"
	},
	"ISEVEN": {
		"a": "(число)",
		"d": "Връща значение TRUE, ако числото е четно"
	},
	"ISFORMULA": {
		"a": "(препратка)",
		"d": "Проверява дали дадена препратка е към клетка, която съдържа формула, и връща ИСТИНА или НЕИСТИНА"
	},
	"ISLOGICAL": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е логическа стойност (TRUE или FALSE) и връща TRUE или FALSE"
	},
	"ISNA": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е #N/A и връща TRUE или FALSE"
	},
	"ISNONTEXT": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност не е текст (празните клетки не са текст) и връща TRUE или FALSE"
	},
	"ISNUMBER": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е число и връща TRUE или FALSE"
	},
	"ISODD": {
		"a": "(число)",
		"d": "Връща значение TRUE, ако числото е нечетно"
	},
	"ISREF": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е препратка и връща TRUE или FALSE"
	},
	"ISTEXT": {
		"a": "(стойност)",
		"d": "Проверява дали една стойност е текст и връща TRUE или FALSE"
	},
	"N": {
		"a": "(стойност)",
		"d": "Преобразува нечислова стойност в число, дати - в поредни номера, TRUE - в 1, а всичко друго - в 0 (нула)"
	},
	"NA": {
		"a": "()",
		"d": "Връща грешната стойност #N/A (липсва стойност)"
	},
	"SHEET": {
		"a": "([стойност])",
		"d": "Връща номера на листа за посочения лист"
	},
	"SHEETS": {
		"a": "([препратка])",
		"d": "Връща броя на листовете в препратка"
	},
	"TYPE": {
		"a": "(стойност)",
		"d": "Връща цяло число, представляващо типа данни за стойност: число = 1; текст = 2; логическа стойност = 4; грешна стойност = 16; масив = 64; сложни данни = 128"
	},
	"AND": {
		"a": "(логически1; [логически2]; ...)",
		"d": "Проверява дали всички аргументи са TRUE и връща TRUE, ако всички аргументи са TRUE"
	},
	"FALSE": {
		"a": "()",
		"d": "Връща логическата стойност FALSE"
	},
	"IF": {
		"a": "(логически_тест; [стойност_ако_вярно]; [стойност_ако_невярно])",
		"d": "Проверява дали е спазено зададено условие и връща една стойност при TRUE и друга стойност при FALSE"
	},
	"IFS": {
		"a": "(логически_тест; стойност_ако_вярно; ...)",
		"d": "Проверява дали са изпълнени едно или повече условия и връща стойност, съответстваща на първото вярно условие"
	},
	"IFERROR": {
		"a": "(стойност; стойност_ако_грешка)",
		"d": "Връща \"стойност_ако_грешка\", ако изразът е грешен, а в противен случай - самата стойност на израза"
	},
	"IFNA": {
		"a": "(стойност; стойност_ако_няма)",
		"d": "Връща стойността, която задавате, ако изразът се свежда до #N/A, в противен случай връща израза"
	},
	"NOT": {
		"a": "(логически)",
		"d": "Променя FALSE в TRUE или TRUE във FALSE"
	},
	"OR": {
		"a": "(логически1; [логически2]; ...)",
		"d": "Проверява дали някой от аргументите е TRUE и връща TRUE или FALSE. FALSE се връща само ако всички аргументи са FALSE"
	},
	"SWITCH": {
		"a": "(израз; стойност1; резултат1; [по_подразбиране_или_стойност2]; [резултат2]; ...)",
		"d": "Оценява израз спрямо списък от стойности и връща резултата, съответстващ на първата съвпадаща стойност. Ако няма съвпадение, се връща незадължителна стойност по избор"
	},
	"TRUE": {
		"a": "()",
		"d": "Връща логическата стойност TRUE"
	},
	"XOR": {
		"a": "(логическо1; [логическо2]; ...)",
		"d": "Връща логическо \"Изключващо или\" на всички аргументи"
	}
}