web-apps/apps/spreadsheeteditor/main/resources/formula-lang/en_desc.json

{
	"DATE": {
		"a": "( year, month, day )",
		"d": "Date and time function used to add dates in the default format MM/dd/yyyy"
	},
	"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": "( date-time-string )",
		"d": "Date and time function used to return a serial number of the specified date"
	},
	"DAY": {
		"a": "( date-value )",
		"d": "Date and time function which returns the day (a number from 1 to 31) of the date given in the numerical format (MM/dd/yyyy by default)"
	},
	"DAYS": {
		"a": "( end-date , start-date )",
		"d": "Date and time function used to return the number of days between two dates"
	},
	"DAYS360": {
		"a": "( start-date , end-date [ , method-flag ] )",
		"d": "Date and time function used to return the number of days between two dates (start-date and end-date) based on a 360-day year using one of the calculation method (US or European)"
	},
	"EDATE": {
		"a": "( start-date , month-offset )",
		"d": "Date and time function used to return the serial number of the date which comes the indicated number of months (month-offset) before or after the specified date (start-date)"
	},
	"EOMONTH": {
		"a": "( start-date , month-offset )",
		"d": "Date and time function used to return the serial number of the last day of the month that comes the indicated number of months before or after the specified start date"
	},
	"HOUR": {
		"a": "( time-value )",
		"d": "Date and time function which returns the hour (a number from 0 to 23) of the time value"
	},
	"ISOWEEKNUM": {
		"a": "( date )",
		"d": "Date and time function used to return number of the ISO week number of the year for a given date"
	},
	"MINUTE": {
		"a": "( time-value )",
		"d": "Date and time function which returns the minute (a number from 0 to 59) of the time value"
	},
	"MONTH": {
		"a": "( date-value )",
		"d": "Date and time function which returns the month (a number from 1 to 12) of the date given in the numerical format (MM/dd/yyyy by default)"
	},
	"NETWORKDAYS": {
		"a": "( start-date , end-date [ , holidays ] )",
		"d": "Date and time function used to return the number of the work days between two dates (start date and end-date) excluding weekends and dates considered as holidays"
	},
	"NETWORKDAYS.INTL": {
		"a": "( start_date , end_date , [ , weekend ] , [ , holidays ] )",
		"d": "Date and time function used to return the number of whole workdays between two dates using parameters to indicate which and how many days are weekend days"
	},
	"NOW": {
		"a": "()",
		"d": "Date and time function used to return the serial number of the current date and time; if the cell format was General before the function was entered, the application changes the cell format so that it matches the date and time format of your regional settings"
	},
	"SECOND": {
		"a": "( time-value )",
		"d": "Date and time function which returns the second (a number from 0 to 59) of the time value"
	},
	"TIME": {
		"a": "( hour, minute, second )",
		"d": "Date and time function used to add a particular time in the selected format (hh:mm tt by default)"
	},
	"TIMEVALUE": {
		"a": "( date-time-string )",
		"d": "Date and time function used to return the serial number of a time"
	},
	"TODAY": {
		"a": "()",
		"d": "Date and time function used to add the current day in the following format MM/dd/yy. This function does not require an argument"
	},
	"WEEKDAY": {
		"a": "( serial-value [ , weekday-start-flag ] )",
		"d": "Date and time function used to determine which day of the week the specified date is"
	},
	"WEEKNUM": {
		"a": "( serial-value [ , weekday-start-flag ] )",
		"d": "Date and time function used to return the number of the week the specified date falls within the year"
	},
	"WORKDAY": {
		"a": "( start-date , day-offset [ , holidays ] )",
		"d": "Date and time function used to return the date which comes the indicated number of days (day-offset) before or after the specified start date excluding weekends and dates considered as holidays"
	},
	"WORKDAY.INTL": {
		"a": "( start_date , days , [ , weekend ] , [ , holidays ] )",
		"d": "Date and time function used to return the serial number of the date before or after a specified number of workdays with custom weekend parameters; weekend parameters indicate which and how many days are weekend days"
	},
	"YEAR": {
		"a": "( date-value )",
		"d": "Date and time function which returns the year (a number from 1900 to 9999) of the date given in the numerical format (MM/dd/yyyy by default)"
	},
	"YEARFRAC": {
		"a": "(  start-date , end-date [ , basis ] )",
		"d": "Date and time function used to return the fraction of a year represented by the number of whole days from start-date to end-date calculated on the specified basis"
	},
	"BESSELI": {
		"a": "( X , N )",
		"d": "Engineering function used to return the modified Bessel function, which is equivalent to the Bessel function evaluated for purely imaginary arguments"
	},
	"BESSELJ": {
		"a": "( X , N )",
		"d": "Engineering function used to return the Bessel function"
	},
	"BESSELK": {
		"a": "( X , N )",
		"d": "Engineering function used to return the modified Bessel function, which is equivalent to the Bessel functions evaluated for purely imaginary arguments"
	},
	"BESSELY": {
		"a": "( X , N )",
		"d": "Engineering function used to return the Bessel function, which is also called the Weber function or the Neumann function"
	},
	"BIN2DEC": {
		"a": "( number )",
		"d": "Engineering function used to convert a binary number into a decimal number"
	},
	"BIN2HEX": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert a binary number into a hexadecimal number"
	},
	"BIN2OCT": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert a binary number into an octal number"
	},
	"BITAND": {
		"a": "( number1 , number2 )",
		"d": "Engineering function used to return a bitwise 'AND' of two numbers"
	},
	"BITLSHIFT": {
		"a": "( number, shift_amount )",
		"d": "Engineering function used to return a number shifted left by the specified number of bits"
	},
	"BITOR": {
		"a": "( number1, number2 )",
		"d": "Engineering function used to return a bitwise 'OR' of two numbers"
	},
	"BITRSHIFT": {
		"a": "( number, shift_amount )",
		"d": "Engineering function used to return a number shifted right by the specified number of bits"
	},
	"BITXOR": {
		"a": "( number1, number2 )",
		"d": "Engineering function used to return a bitwise 'XOR' of two numbers"
	},
	"COMPLEX": {
		"a": "( real-number , imaginary-number [ , suffix ] )",
		"d": "Engineering function used to convert a real part and an imaginary part into the complex number expressed in a + bi or a + bj form"
	},
	"CONVERT": {
		"a": "( number , from-unit , to-unit )",
		"d": "Engineering function used to convert a number from one measurement system to another; for example, CONVERT can translate a table of distances in miles to a table of distances in kilometers"
	},
	"DEC2BIN": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert a decimal number into a binary number"
	},
	"DEC2HEX": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert a decimal number into a hexadecimal number"
	},
	"DEC2OCT": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert a decimal number into an octal number"
	},
	"DELTA": {
		"a": "( number-1 [ , number-2 ] )",
		"d": "Engineering function used to test if two numbers are equal. The function returns 1 if the numbers are equal and 0 otherwise"
	},
	"ERF": {
		"a": "( lower-bound [ , upper-bound ] )",
		"d": "Engineering function used to calculate the error function integrated between the specified lower and upper limits"
	},
	"ERF.PRECISE": {
		"a": "( x )",
		"d": "Engineering function used to returns the error function"
	},
	"ERFC": {
		"a": "( lower-bound )",
		"d": "Engineering function used to calculate the complementary error function integrated between the specified lower limit and infinity"
	},
	"ERFC.PRECISE": {
		"a": "( x )",
		"d": "Engineering function used to return the complementary ERF function integrated between x and infinity"
	},
	"GESTEP": {
		"a": "( number [ , step ] )",
		"d": "Engineering function used to test if a number is greater than a threshold value. The function returns 1 if the number is greater than or equal to the threshold value and 0 otherwise"
	},
	"HEX2BIN": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert a hexadecimal number to a binary number"
	},
	"HEX2DEC": {
		"a": "( number )",
		"d": "Engineering function used to convert a hexadecimal number into a decimal number"
	},
	"HEX2OCT": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert a hexadecimal number to an octal number"
	},
	"IMABS": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the absolute value of a complex number"
	},
	"IMAGINARY": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the imaginary part of the specified complex number"
	},
	"IMARGUMENT": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the argument Theta, an angle expressed in radians"
	},
	"IMCONJUGATE": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the complex conjugate of a complex number"
	},
	"IMCOS": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the cosine of a complex number"
	},
	"IMCOSH": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the hyperbolic cosine of a complex number"
	},
	"IMCOT": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the cotangent of a complex number"
	},
	"IMCSC": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the cosecant of a complex number"
	},
	"IMCSCH": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the hyperbolic cosecant of a complex number"
	},
	"IMDIV": {
		"a": "( complex-number-1 , complex-number-2 )",
		"d": "Engineering function used to return the quotient of two complex numbers expressed in a + bi or a + bj form"
	},
	"IMEXP": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the e constant raised to the to the power specified by a complex number. The e constant is equal to 2,71828182845904"
	},
	"IMLN": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the natural logarithm of a complex number"
	},
	"IMLOG10": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the logarithm of a complex number to a base of 10"
	},
	"IMLOG2": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the logarithm of a complex number to a base of 2"
	},
	"IMPOWER": {
		"a": "( complex-number, power )",
		"d": "Engineering function used to return the result of a complex number raised to the desired power"
	},
	"IMPRODUCT": {
		"a": "( argument-list )",
		"d": "Engineering function used to return the product of the specified complex numbers"
	},
	"IMREAL": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the real part of the specified complex number"
	},
	"IMSEC": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the secant of a complex number"
	},
	"IMSECH": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the hyperbolic secant of a complex number"
	},
	"IMSIN": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the sine of a complex number"
	},
	"IMSINH": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the hyperbolic sine of a complex number"
	},
	"IMSQRT": {
		"a": "( complex-number )",
		"d": "Engineering function used to return the square root of a complex number"
	},
	"IMSUB": {
		"a": "( complex-number-1 , complex-number-2 )",
		"d": "Engineering function used to return the difference of two complex numbers expressed in a + bi or a + bj form"
	},
	"IMSUM": {
		"a": "( argument-list )",
		"d": "Engineering function used to return the sum of the specified complex numbers"
	},
	"IMTAN": {
		"a": "( complex-number )",
		"d": "Engineering function used return to the tangent of a complex number"
	},
	"OCT2BIN": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert an octal number to a binary number"
	},
	"OCT2DEC": {
		"a": "( number )",
		"d": "Engineering function used to convert an octal number to a decimal number"
	},
	"OCT2HEX": {
		"a": "( number [ , num-hex-digits ] )",
		"d": "Engineering function used to convert an octal number to a hexadecimal number"
	},
	"DAVERAGE": {
		"a": "( database , field , criteria )",
		"d": "Database function used to average the values in a field (column) of records in a list or database that match conditions you specify"
	},
	"DCOUNT": {
		"a": "( database , field , criteria )",
		"d": "Database function used to count the cells that contain numbers in a field (column) of records in a list or database that match conditions that you specify"
	},
	"DCOUNTA": {
		"a": "( database , field , criteria )",
		"d": "Database function used to count the nonblank cells in a field (column) of records in a list or database that match conditions that you specify"
	},
	"DGET": {
		"a": "( database , field , criteria )",
		"d": "Database function used to extract a single value from a column of a list or database that matches conditions that you specify"
	},
	"DMAX": {
		"a": "( database , field , criteria )",
		"d": "Database function used to return the largest number in a field (column) of records in a list or database that matches conditions you that specify"
	},
	"DMIN": {
		"a": "( database , field , criteria )",
		"d": "Database function used to return the smallest number in a field (column) of records in a list or database that matches conditions that you specify"
	},
	"DPRODUCT": {
		"a": "( database , field , criteria )",
		"d": "Database function used to multiplie the values in a field (column) of records in a list or database that match conditions that you specify"
	},
	"DSTDEV": {
		"a": "( database , field , criteria )",
		"d": "Database function used to estimate the standard deviation of a population based on a sample by using the numbers in a field (column) of records in a list or database that match conditions that you specify"
	},
	"DSTDEVP": {
		"a": "( database , field , criteria )",
		"d": "Database function used to calculate the standard deviation of a population based on the entire population by using the numbers in a field (column) of records in a list or database that match conditions that you specify"
	},
	"DSUM": {
		"a": "( database , field , criteria )",
		"d": "Database function used to add the numbers in a field (column) of records in a list or database that match conditions that you specify"
	},
	"DVAR": {
		"a": "( database , field , criteria )",
		"d": "Database function used to estimates the variance of a population based on a sample by using the numbers in a field (column) of records in a list or database that match conditions that you specify"
	},
	"DVARP": {
		"a": "( database , field , criteria )",
		"d": "Database function used to calculate the variance of a population based on the entire population by using the numbers in a field (column) of records in a list or database that match conditions that you specify"
	},
	"CHAR": {
		"a": "( number )",
		"d": "Text and data function used to return the ASCII character specified by a number"
	},
	"CLEAN": {
		"a": "( string )",
		"d": "Text and data function used to remove all the nonprintable characters from the selected string"
	},
	"CODE": {
		"a": "( string )",
		"d": "Text and data function used to return the ASCII value of the specified character or the first character in a cell"
	},
	"CONCATENATE": {
		"a": "(text1, text2, ...)",
		"d": "Text and data function used to combine the data from two or more cells into a single one"
	},
	"CONCAT": {
		"a": "(text1, text2, ...)",
		"d": "Text and data function used to combine the data from two or more cells into a single one. This function replaces the CONCATENATE function."
	},
	"DOLLAR": {
		"a": "( number [ , num-decimal ] )",
		"d": "Text and data function used to convert a number to text, using a currency format $#.##"
	},
	"EXACT": {
		"a": "(text1, text2)",
		"d": "Text and data function used to compare data in two cells. The function returns TRUE if the data are the same, and FALSE if not"
	},
	"FIND": {
		"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 that use the single-byte character set (SBCS)"
	},
	"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": "( number [ , [ num-decimal ] [ , suppress-commas-flag ] ] )",
		"d": "Text and data function used to return the text representation of a number rounded to a specified number of decimal places"
	},
	"LEFT": {
		"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 single-byte character set (SBCS)"
	},
	"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": "( 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 single-byte character set (SBCS)"
	},
	"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": "(text)",
		"d": "Text and data function used to convert uppercase letters to lowercase in the selected cell"
	},
	"MID": {
		"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 single-byte character set (SBCS)"
	},
	"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": "( text , [ , [ decimal-separator ] [ , [ group-separator ] ] )",
		"d": "Text and data function used to convert text to a number, in a locale-independent way"
	},
	"PROPER": {
		"a": "( string )",
		"d": "Text and data function used to convert the first character of each word to uppercase and all the remaining characters to lowercase"
	},
	"REPLACE": {
		"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 single-byte character set (SBCS)"
	},
	"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": "(text, number_of_times)",
		"d": "Text and data function used to repeat the data in the selected cell as many time as you wish"
	},
	"RIGHT": {
		"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 single-byte character set (SBCS)"
	},
	"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": "( 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 single-byte character set (SBCS)"
	},
	"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": "( string , old-string , new-string [ , occurence ] )",
		"d": "Text and data function used to replace a set of characters with a new one"
	},
	"T": {
		"a": "( value )",
		"d": "Text and data function used to check whether the value in the cell (or used as argument) is text or not. In case it is not text, the function returns blank result. In case the value/argument is text, the function returns the same text value"
	},
	"TEXT": {
		"a": "( value , format )",
		"d": "Text and data function used to convert a value to a text in the specified format"
	},
	"TEXTJOIN": {
		"a": "( delimiter , ignore_empty , text1 [ , text2 ] , … )",
		"d": "Text and data function used to combine the text from multiple ranges and/or strings, and includes a delimiter you specify between each text value that will be combined; if the delimiter is an empty text string, this function will effectively concatenate the ranges"
	},
	"TRIM": {
		"a": "( string )",
		"d": "Text and data function used to remove the leading and trailing spaces from a string"
	},
	"UNICHAR": {
		"a": "( number )",
		"d": "Text and data function used to return the Unicode character that is referenced by the given numeric value."
	},
	"UNICODE": {
		"a": "( text )",
		"d": "Text and data function used to return the number (code point) corresponding to the first character of the text"
	},
	"UPPER": {
		"a": "(text)",
		"d": "Text and data function used to convert lowercase letters to uppercase in the selected cell"
	},
	"VALUE": {
		"a": "( string )",
		"d": "Text and data function used to convert a text value that represents a number to a number. If the converted text is not a number, the function will return a #VALUE! error"
	},
	"AVEDEV": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and return the average of the absolute deviations of numbers from their mean"
	},
	"AVERAGE": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and find the average value"
	},
	"AVERAGEA": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data including text and logical values and find the average value. The AVERAGEA function treats text and FALSE as a value of 0 and TRUE as a value of 1"
	},
	"AVERAGEIF": {
		"a": "( cell-range, selection-criteria [ , average-range ] )",
		"d": "Statistical function used to analyze the range of data and find the average value of all numbers in a range of cells, based on the specified criterion"
	},
	"AVERAGEIFS": {
		"a": "( average-range, criteria-range-1, criteria-1 [ criteria-range-2, criteria-2 ], ... )",
		"d": "Statistical function used to analyze the range of data and find the average value of all numbers in a range of cells, based on the multiple criterions"
	},
	"BETADIST": {
		"a": " ( probability , alpha , beta , [ , [ A ] [ , [ B ] ] ) ",
		"d": "Statistical function used to return the cumulative beta probability density function"
	},
	"BETAINV": {
		"a": " ( x , alpha , beta , [ , [ A ] [ , [ B ] ] ) ",
		"d": "Statistical function used return the inverse of the cumulative beta probability density function for a specified beta distribution"
	},
	"BETA.DIST": {
		"a": " ( x , alpha , beta , cumulative , [ , [ A ] [ , [ B ] ] ) ",
		"d": "Statistical function used to return the beta distribution"
	},
	"BETA.INV": {
		"a": " ( probability , alpha , beta , [ , [ A ] [ , [ B ] ] ) ",
		"d": "Statistical function used to return the inverse of the beta cumulative probability density function"
	},
	"BINOMDIST": {
		"a": "( number-successes , number-trials , success-probability , cumulative-flag )",
		"d": "Statistical function used to return the individual term binomial distribution probability"
	},
	"BINOM.DIST": {
		"a": "( number-s , trials , probability-s , cumulative )",
		"d": "Statistical function used to return the individual term binomial distribution probability"
	},
	"BINOM.DIST.RANGE": {
		"a": "( trials , probability-s , number-s [ , number-s2 ] )",
		"d": "Statistical function used to return the probability of a trial result using a binomial distribution"
	},
	"BINOM.INV": {
		"a": "( trials , probability-s , alpha )",
		"d": "Statistical function used to return the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value"
	},
	"CHIDIST": {
		"a": "( x , deg-freedom )",
		"d": "Statistical function used to return the right-tailed probability of the chi-squared distribution"
	},
	"CHIINV": {
		"a": "( probability , deg-freedom )",
		"d": "Statistical function used to return the inverse of the right-tailed probability of the chi-squared distribution"
	},
	"CHITEST": {
		"a": "( actual-range , expected-range )",
		"d": "Statistical function used to return the test for independence, value from the chi-squared (χ2) distribution for the statistic and the appropriate degrees of freedom"
	},
	"CHISQ.DIST": {
		"a": "( x , deg-freedom , cumulative )",
		"d": "Statistical function used to return the chi-squared distribution"
	},
	"CHISQ.DIST.RT": {
		"a": "( x , deg-freedom )",
		"d": "Statistical function used to return the right-tailed probability of the chi-squared distribution"
	},
	"CHISQ.INV": {
		"a": "( probability , deg-freedom )",
		"d": "Statistical function used to return the inverse of the left-tailed probability of the chi-squared distribution"
	},
	"CHISQ.INV.RT": {
		"a": "( probability , deg-freedom )",
		"d": "Statistical function used to return the inverse of the right-tailed probability of the chi-squared distribution"
	},
	"CHISQ.TEST": {
		"a": "( actual-range , expected-range )",
		"d": "Statistical function used to return the test for independence, value from the chi-squared (χ2) distribution for the statistic and the appropriate degrees of freedom"
	},
	"CONFIDENCE": {
		"a": "( alpha , standard-dev , size )",
		"d": "Statistical function used to return the confidence interval"
	},
	"CONFIDENCE.NORM": {
		"a": "( alpha , standard-dev , size )",
		"d": "Statistical function used to return the confidence interval for a population mean, using a normal distribution"
	},
	"CONFIDENCE.T": {
		"a": "( alpha , standard-dev , size )",
		"d": "Statistical function used to return the confidence interval for a population mean, using a Student's t distribution"
	},
	"CORREL": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to analyze the range of data and return the correlation coefficient of two range of cells"
	},
	"COUNT": {
		"a": "( argument-list )",
		"d": "Statistical function used to count the number of the selected cells which contain numbers ignoring empty cells or those contaning text"
	},
	"COUNTA": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of cells and count the number of cells that are not empty"
	},
	"COUNTBLANK": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of cells and return the number of the empty cells"
	},
	"COUNTIF": {
		"a": "( cell-range, selection-criteria )",
		"d": "Statistical function used to count the number of the selected cells based on the specified criterion"
	},
	"COUNTIFS": {
		"a": "( criteria-range-1, criteria-1, [ criteria-range-2, criteria-2 ], ... )",
		"d": "Statistical function used to count the number of the selected cells based on the multiple criterions"
	},
	"COVAR": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to return the covariance of two ranges of data"
	},
	"COVARIANCE.P": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to return population covariance, the average of the products of deviations for each data point pair in two data sets; use covariance to determine the relationship between two data sets"
	},
	"COVARIANCE.S": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to return the sample covariance, the average of the products of deviations for each data point pair in two data sets"
	},
	"CRITBINOM": {
		"a": "( number-trials , success-probability , alpha )",
		"d": "Statistical function used to return the smallest value for which the cumulative binomial distribution is greater than or equal to the specified alpha value"
	},
	"DEVSQ": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and sum the squares of the deviations of numbers from their mean"
	},
	"EXPONDIST": {
		"a": "( x , lambda , cumulative-flag )",
		"d": "Statistical function used to return the exponential distribution"
	},
	"EXPON.DIST": {
		"a": "( x , lambda , cumulative )",
		"d": "Statistical function used to return the exponential distribution"
	},
	"FDIST": {
		"a": "( x , deg-freedom1 , deg-freedom2 )",
		"d": "Statistical function used to return the (right-tailed) F probability distribution (degree of diversity) for two data sets. You can use this function to determine whether two data sets have different degrees of diversity"
	},
	"FINV": {
		"a": "( probability , deg-freedom1 , deg-freedom2 )",
		"d": "Statistical function used to return the inverse of the (right-tailed) F probability distribution; the F distribution can be used in an F-test that compares the degree of variability in two data sets"
	},
	"FTEST": {
		"a": "( array1 , array2 )",
		"d": "Statistical function used to return the result of an F-test. An F-test returns the two-tailed probability that the variances in array1 and array2 are not significantly different; use this function to determine whether two samples have different variances"
	},
	"F.DIST": {
		"a": "( x , deg-freedom1 , deg-freedom2 , cumulative )",
		"d": "Statistical function used to return the F probability distribution. You can use this function to determine whether two data sets have different degrees of diversity"
	},
	"F.DIST.RT": {
		"a": "( x , deg-freedom1 , deg-freedom2 )",
		"d": "Statistical function used to return the (right-tailed) F probability distribution (degree of diversity) for two data sets. You can use this function to determine whether two data sets have different degrees of diversity"
	},
	"F.INV": {
		"a": "( probability , deg-freedom1 , deg-freedom2 )",
		"d": "Statistical function used to return the inverse of the (right-tailed) F probability distribution; the F distribution can be used in an F-test that compares the degree of variability in two data sets"
	},
	"F.INV.RT": {
		"a": "( probability , deg-freedom1 , deg-freedom2 )",
		"d": "Statistical function used to return the inverse of the (right-tailed) F probability distribution; the F distribution can be used in an F-test that compares the degree of variability in two data sets"
	},
	"F.TEST": {
		"a": "( array1 , array2 )",
		"d": "Statistical function used to return the result of an F-test, the two-tailed probability that the variances in array1 and array2 are not significantly different; use this function to determine whether two samples have different variances"
	},
	"FISHER": {
		"a": "( number )",
		"d": "Statistical function used to return the Fisher transformation of a number"
	},
	"FISHERINV": {
		"a": "( number )",
		"d": "Statistical function used to perform the inverse of Fisher transformation"
	},
	"FORECAST": {
		"a": "( x , array-1 , array-2 )",
		"d": "Statistical function used to predict a future value based on existing values provided"
	},
	"FORECAST.ETS": {
		"a": "( target_date , values , timeline , [ seasonality ] , [ data_completion ] , [ aggregation ] )",
		"d": "Statistical function used to calculate or predict a future value based on existing (historical) values by using the AAA version of the Exponential Smoothing (ETS) algorithm"
	},
	"FORECAST.ETS.CONFINT": {
		"a": "( target_date , values , timeline , [ confidence_level ] , [ seasonality ], [ data_completion ] , [aggregation ] )",
		"d": "Statistical function used to return a confidence interval for the forecast value at the specified target date"
	},
	"FORECAST.ETS.SEASONALITY": {
		"a": "( values , timeline , [ data_completion ] , [ aggregation ] )",
		"d": "Statistical function used to return the length of the repetitive pattern  an application detects for the specified time series"
	},
	"FORECAST.ETS.STAT": {
		"a": "( values , timeline , statistic_type , [ seasonality ] , [ data_completion ] , [ aggregation ] )",
		"d": "Statistical function used to return a statistical value as a result of time series forecasting; statistic type indicates which statistic is requested by this function"
	},
	"FORECAST.LINEAR": {
		"a": "( x, known_y's, known_x's )",
		"d": "Statistical function used to calculate, or predict, a future value by using existing values; the predicted value is a y-value for a given x-value, the known values are existing x-values and y-values, and the new value is predicted by using linear regression"
	},
	"FREQUENCY": {
		"a": "(  data-array , bins-array )",
		"d": "Statistical function used to сalculate how often values occur within the selected range of cells and display the first value of the returned vertical array of numbers"
	},
	"GAMMA": {
		"a": "( number )",
		"d": "Statistical function used to return the gamma function value"
	},
	"GAMMADIST": {
		"a": "( x , alpha , beta , cumulative )",
		"d": "Statistical function used to return the gamma distribution"
	},
	"GAMMA.DIST": {
		"a": "( x , alpha , beta , cumulative )",
		"d": "Statistical function used to return the gamma distribution"
	},
	"GAMMAINV": {
		"a": "( probability , alpha , beta )",
		"d": "Statistical function used to return the inverse of the gamma cumulative distribution"
	},
	"GAMMA.INV": {
		"a": "( probability , alpha , beta )",
		"d": "Statistical function used to return the inverse of the gamma cumulative distribution"
	},
	"GAMMALN": {
		"a": "( number )",
		"d": "Statistical function used to return the natural logarithm of the gamma function"
	},
	"GAMMALN.PRECISE": {
		"a": "( x )",
		"d": "Statistical function used to return the natural logarithm of the gamma function"
	},
	"GAUSS": {
		"a": "( z )",
		"d": "Statistical function used to calculate the probability that a member of a standard normal population will fall between the mean and z standard deviations from the mean"
	},
	"GEOMEAN": {
		"a": "( argument-list )",
		"d": "Statistical function used to calculate the geometric mean of the argument list"
	},
	"HARMEAN": {
		"a": "( argument-list )",
		"d": "Statistical function used to calculate the harmonic mean of the argument list"
	},
	"HYPGEOM.DIST": {
		"a": "( sample_s, number_sample, population_s, number_pop, cumulative )",
		"d": "Statistical function used to return the hypergeometric distribution, the probability of a given number of sample successes, given the sample size, population successes, and population size"
	},
	"HYPGEOMDIST": {
		"a": "( sample-successes , number-sample , population-successes , number-population )",
		"d": "Statistical function used to return the hypergeometric distribution, the probability of a given number of sample successes, given the sample size, population successes, and population size"
	},
	"INTERCEPT": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to analyze the first array values and second array values to calculate the intersection point"
	},
	"KURT": {
		"a": "( argument-list )",
		"d": "Statistical function used to return the kurtosis of the argument list"
	},
	"LARGE": {
		"a": "(  array , k )",
		"d": "Statistical function used to analyze the range of cells and return the k-th largest value"
	},
	"LOGINV": {
		"a": "( x , mean , standard-deviation )",
		"d": "Statistical function used to return the inverse of the lognormal cumulative distribution function of the given x value with the specified parameters"
	},
	"LOGNORM.DIST": {
		"a": "( x , mean , standard-deviation , cumulative )",
		"d": "Statistical function used to return the lognormal distribution of x, where ln(x) is normally distributed with parameters Mean and Standard-deviation"
	},
	"LOGNORM.INV": {
		"a": "( probability , mean , standard-deviation )",
		"d": "Statistical function used to return the inverse of the lognormal cumulative distribution function of x, where ln(x) is normally distributed with parameters Mean and Standard-deviation"
	},
	"LOGNORMDIST": {
		"a": "( x , mean , standard-deviation )",
		"d": "Statistical function used to analyze logarithmically transformed data and return the lognormal cumulative distribution function of the given x value with the specified parameters"
	},
	"MAX": {
		"a": "( number1 , number2 , ...)",
		"d": "Statistical function used to analyze the range of data and find the largest number"
	},
	"MAXA": {
		"a": "( number1 , number2 , ...)",
		"d": "Statistical function used to analyze the range of data and find the largest value"
	},
	"MAXIFS": {
		"a": "( max_range , criteria_range1 , criteria1 [ , criteria_range2 , criteria2 ] , ...)",
		"d": "Statistical function used to return the maximum value among cells specified by a given set of conditions or criteria"
	},
	"MEDIAN": {
		"a": "( argument-list )",
		"d": "Statistical function used to calculate the median of the argument list"
	},
	"MIN": {
		"a": "( number1 , number2 , ...)",
		"d": "Statistical function used to analyze the range of data and find the smallest number"
	},
	"MINA": {
		"a": "( number1 , number2 , ...)",
		"d": "Statistical function used to analyze the range of data and find the smallest value"
	},
	"MINIFS": {
		"a": "( min_range , criteria_range1 , criteria1 [ , criteria_range2 , criteria2 ] , ...)",
		"d": "Statistical function used to return the minimum value among cells specified by a given set of conditions or criteria"
	},
	"MODE": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and return the most frequently occurring value"
	},
	"MODE.MULT": {
		"a": "( number1 , [ , number2 ] ... )",
		"d": "Statistical function used to return a vertical array of the most frequently occurring, or repetitive values in an array or range of data"
	},
	"MODE.SNGL": {
		"a": "( number1 , [ , number2 ] ... )",
		"d": "Statistical function used to return the most frequently occurring, or repetitive, value in an array or range of data"
	},
	"NEGBINOM.DIST": {
		"a": "( (number-f , number-s , probability-s , cumulative )",
		"d": "Statistical function used to return the negative binomial distribution, the probability that there will be Number-f failures before the Number-s-th success, with Probability-s probability of a success"
	},
	"NEGBINOMDIST": {
		"a": "( number-failures , number-successes , success-probability )",
		"d": "Statistical function used to return the negative binomial distribution"
	},
	"NORM.DIST": {
		"a": "( x , mean , standard-dev , cumulative )",
		"d": "Statistical function used to return the normal distribution for the specified mean and standard deviation"
	},
	"NORMDIST": {
		"a": "( x , mean , standard-deviation , cumulative-flag )",
		"d": "Statistical function used to return the normal distribution for the specified mean and standard deviation"
	},
	"NORM.INV": {
		"a": "( probability , mean , standard-dev )",
		"d": "Statistical function used to return the inverse of the normal cumulative distribution for the specified mean and standard deviation"
	},
	"NORMINV": {
		"a": "( x , mean , standard-deviation )",
		"d": "Statistical function used to return the inverse of the normal cumulative distribution for the specified mean and standard deviation"
	},
	"NORM.S.DIST": {
		"a": "( z , cumulative )",
		"d": "Statistical function used to return the standard normal distribution (has a mean of zero and a standard deviation of one)"
	},
	"NORMSDIST": {
		"a": "( number )",
		"d": "Statistical function used to return the standard normal cumulative distribution function"
	},
	"NORM.S.INV": {
		"a": "( probability )",
		"d": "Statistical function used to return the inverse of the standard normal cumulative distribution; the distribution has a mean of zero and a standard deviation of one"
	},
	"NORMSINV": {
		"a": "( probability )",
		"d": "Statistical function used to return the inverse of the standard normal cumulative distribution"
	},
	"PEARSON": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to return the Pearson product moment correlation coefficient"
	},
	"PERCENTILE": {
		"a": "(  array , k )",
		"d": "Statistical function used to analyze the range of data and return the k-th percentile"
	},
	"PERCENTILE.EXC": {
		"a": "(  array , k )",
		"d": "Statistical function used to return the k-th percentile of values in a range, where k is in the range 0..1, exclusive"
	},
	"PERCENTILE.INC": {
		"a": "(  array , k )",
		"d": "Statistical function used to return the k-th percentile of values in a range, where k is in the range 0..1, exclusive"
	},
	"PERCENTRANK": {
		"a": "( array , k )",
		"d": "Statistical function used to return the rank of a value in a set of values as a percentage of the set"
	},
	"PERCENTRANK.EXC": {
		"a": "( array , x [ , significance ] )",
		"d": "Statistical function used to return the rank of a value in a data set as a percentage (0..1, exclusive) of the data set"
	},
	"PERCENTRANK.INC": {
		"a": "( array , x [ , significance ] )",
		"d": "Statistical function used to return the rank of a value in a data set as a percentage (0..1, inclusive) of the data set"
	},
	"PERMUT": {
		"a": "( number , number-chosen )",
		"d": "Statistical function used to return the rank of a value in a data set as a percentage (0..1, inclusive) of the data set"
	},
	"PERMUTATIONA": {
		"a": "( number , number-chosen )",
		"d": "Statistical function used to return the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects"
	},
	"PHI": {
		"a": "( x )",
		"d": "Statistical function used to return the value of the density function for a standard normal distribution"
	},
	"POISSON": {
		"a": "( x , mean , cumulative-flag )",
		"d": "Statistical function used to return the Poisson distribution"
	},
	"POISSON.DIST": {
		"a": "( x , mean , cumulative )",
		"d": "Statistical function used to return the Poisson distribution; a common application of the Poisson distribution is predicting the number of events over a specific time, such as the number of cars arriving at a toll plaza in 1 minute"
	},
	"PROB": {
		"a": "( x-range , probability-range , lower-limit [ , upper-limit ] )",
		"d": "Statistical function used to return the probability that values in a range are between lower and upper limits"
	},
	"QUARTILE": {
		"a": "(  array , result-category )",
		"d": "Statistical function used to analyze the range of data and return the quartile"
	},
	"QUARTILE.INC": {
		"a": "(  array , quart )",
		"d": "Statistical function used to return the quartile of a data set, based on percentile values from 0..1, inclusive"
	},
	"QUARTILE.EXC": {
		"a": "(  array , quart )",
		"d": "Statistical function used to return the quartile of the data set, based on percentile values from 0..1, exclusive"
	},
	"RANK": {
		"a": "( number , ref [ , order ] )",
		"d": "Statistical function used to return the rank of a number in a list of numbers; the rank of a number is its size relative to other values in a list, so If you were to sort the list, the rank of the number would be its position"
	},
	"RANK.AVG": {
		"a": "( number , ref [ , order ] )",
		"d": "Statistical function used to return the rank of a number in a list of numbers: its size relative to other values in the list; if more than one value has the same rank, the average rank is returned"
	},
	"RANK.EQ": {
		"a": "( number , ref [ , order ] )",
		"d": "Statistical function used to return the rank of a number in a list of numbers: its size is relative to other values in the list; if more than one value has the same rank, the top rank of that set of values is returned"
	},
	"RSQ": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to return the square of the Pearson product moment correlation coefficient"
	},
	"SKEW": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and return the skewness of a distribution of the argument list"
	},
	"SKEW.P": {
		"a": "( number-1 [ , number 2 ] , … )",
		"d": "Statistical function used to return the skewness of a distribution based on a population: a characterization of the degree of asymmetry of a distribution around its mean"
	},
	"SLOPE": {
		"a": "( array-1 , array-2 )",
		"d": "Statistical function used to return the slope of the linear regression line through data in two arrays"
	},
	"SMALL": {
		"a": "(  array , k )",
		"d": "Statistical function used to analyze the range of data and find the k-th smallest value"
	},
	"STANDARDIZE": {
		"a": "( x , mean , standard-deviation )",
		"d": "Statistical function used to return a normalized value from a distribution characterized by the specified parameters"
	},
	"STDEV": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and return the standard deviation of a population based on a set of numbers"
	},
	"STDEV.P": {
		"a": "( number1 [ , number2 ] , ... )",
		"d": "Statistical function used to calculate standard deviation based on the entire population given as arguments (ignores logical values and text)"
	},
	"STDEV.S": {
		"a": "( number1 [ , number2 ] , ... )",
		"d": "Statistical function used to estimates standard deviation based on a sample (ignores logical values and text in the sample)"
	},
	"STDEVA": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and return the standard deviation of a population based on a set of numbers, text, and logical values (TRUE or FALSE). The STDEVA function treats text and FALSE as a value of 0 and TRUE as a value of 1"
	},
	"STDEVP": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and return the standard deviation of an entire population"
	},
	"STDEVPA": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the range of data and return the standard deviation of an entire population"
	},
	"STEYX": {
		"a": "( known-ys , known-xs )",
		"d": "Statistical function used to return the standard error of the predicted y-value for each x in the regression line"
	},
	"TDIST": {
		"a": "( x , deg-freedom , tails )",
		"d": "Statistical function used to return the Percentage Points (probability) for the Student t-distribution where a numeric value (x) is a calculated value of t for which the Percentage Points are to be computed; the t-distribution is used in the hypothesis testing of small sample data sets"
	},
	"TINV": {
		"a": "( probability , deg_freedom )",
		"d": "Statistical function used to return the two-tailed inverse of the Student's t-distribution"
	},
	"T.DIST": {
		"a": "( x , deg-freedom , cumulative )",
		"d": "Statistical function used to return the Student's left-tailed t-distribution. The t-distribution is used in the hypothesis testing of small sample data sets. Use this function in place of a table of critical values for the t-distribution."
	},
	"T.DIST.2T": {
		"a": "( x , deg-freedom )",
		"d": "Statistical function used to return the two-tailed Student's t-distribution.The Student's t-distribution is used in the hypothesis testing of small sample data sets. Use this function in place of a table of critical values for the t-distribution"
	},
	"T.DIST.RT": {
		"a": "( x , deg-freedom )",
		"d": "Statistical function used to return the right-tailed Student's t-distribution. The t-distribution is used in the hypothesis testing of small sample data sets. Use this function in place of a table of critical values for the t-distribution"
	},
	"T.INV": {
		"a": "( probability , deg-freedom )",
		"d": "Statistical function used to return the left-tailed inverse of the Student's t-distribution"
	},
	"T.INV.2T": {
		"a": "( probability , deg-freedom )",
		"d": "Statistical function used to return the two-tailed inverse of the Student's t-distribution"
	},
	"T.TEST": {
		"a": "( array1 , array2 , tails , type )",
		"d": "Statistical function used to return the probability associated with a Student's t-Test; use T.TEST to determine whether two samples are likely to have come from the same two underlying populations that have the same mean"
	},
	"TRIMMEAN": {
		"a": "( array , percent )",
		"d": "Statistical function used to return the mean of the interior of a data set; TRIMMEAN calculates the mean taken by excluding a percentage of data points from the top and bottom tails of a data set"
	},
	"TTEST": {
		"a": "( array1 , array2 , tails , type )",
		"d": "Statistical function used to returns the probability associated with a Student's t-Test; use TTEST to determine whether two samples are likely to have come from the same two underlying populations that have the same mean"
	},
	"VAR": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the set of values and calculate the sample variance"
	},
	"VAR.P": {
		"a": "( number1 [ , number2 ], ... )",
		"d": "Statistical function used to calculates variance based on the entire population (ignores logical values and text in the population)"
	},
	"VAR.S": {
		"a": "( number1 [ , number2 ], ... )",
		"d": "Statistical function used to estimate variance based on a sample (ignores logical values and text in the sample)"
	},
	"VARA": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the set of values and calculate the sample variance"
	},
	"VARP": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the set of values and calculate the variance of an entire population"
	},
	"VARPA": {
		"a": "( argument-list )",
		"d": "Statistical function used to analyze the set of values and return the variance of an entire population"
	},
	"WEIBULL": {
		"a": "( x , alpha , beta , cumulative )",
		"d": "Statistical function used to return the Weibull distribution; use this distribution in reliability analysis, such as calculating a device's mean time to failure"
	},
	"WEIBULL.DIST": {
		"a": "( x , alpha , beta , cumulative )",
		"d": "Statistical function used to return the Weibull distribution; use this distribution in reliability analysis, such as calculating a device's mean time to failure"
	},
	"Z.TEST": {
		"a": "( array , x [ , sigma ] )",
		"d": "Statistical function used to return the one-tailed P-value of a z-test; for a given hypothesized population mean, x, Z.TEST returns the probability that the sample mean would be greater than the average of observations in the data set (array) — that is, the observed sample mean"
	},
	"ZTEST": {
		"a": "( array , x [ , sigma ] )",
		"d": "Statistical function used to return the one-tailed probability-value of a z-test; for a given hypothesized population mean, μ0, ZTEST returns the probability that the sample mean would be greater than the average of observations in the data set (array) — that is, the observed sample mean"
	},
	"ACCRINT": {
		"a": "( issue , first-interest , settlement , rate , [ par ] , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the accrued interest for a security that pays periodic interest"
	},
	"ACCRINTM": {
		"a": "( issue , settlement , rate , [ [ par ] [ , [ basis ] ] ] )",
		"d": "Financial function used to calculate the accrued interest for a security that pays interest at maturity"
	},
	"AMORDEGRC": {
		"a": "( cost , date-purchased , first-period , salvage , period , rate [ , [ basis ] ] )",
		"d": "Financial function used to calculate the depreciation of an asset for each accounting period using a degressive depreciation method"
	},
	"AMORLINC": {
		"a": "( cost , date-purchased , first-period , salvage , period , rate [ , [ basis ] ] )",
		"d": "Financial function used to calculate the depreciation of an asset for each accounting period using a linear depreciation method"
	},
	"COUPDAYBS": {
		"a": "( settlement , maturity , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the number of days from the beginning of the coupon period to the settlement date"
	},
	"COUPDAYS": {
		"a": "( settlement , maturity , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the number of days in the coupon period that contains the settlement date"
	},
	"COUPDAYSNC": {
		"a": "( settlement , maturity , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the number of days from the settlement date to the next coupon payment"
	},
	"COUPNCD": {
		"a": "( settlement , maturity , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the next coupon date after the settlement date"
	},
	"COUPNUM": {
		"a": "( settlement , maturity , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the number of coupons between the settlement date and the maturity date"
	},
	"COUPPCD": {
		"a": "( settlement , maturity , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the previous coupon date before the settlement date"
	},
	"CUMIPMT": {
		"a": "( rate , nper , pv , start-period , end-period , type )",
		"d": "Financial function used to calculate the cumulative interest paid on an investment between two periods based on a specified interest rate and a constant payment schedule"
	},
	"CUMPRINC": {
		"a": "( rate , nper , pv , start-period , end-period , type )",
		"d": "Financial function used to calculate the cumulative principal paid on an investment between two periods based on a specified interest rate and a constant payment schedule"
	},
	"DB": {
		"a": "( cost , salvage , life , period [ , [ month ] ] )",
		"d": "Financial function used to calculate the depreciation of an asset for a specified accounting period using the fixed-declining balance method"
	},
	"DDB": {
		"a": "( cost , salvage , life , period [ , factor ] )",
		"d": "Financial function used to calculate the depreciation of an asset for a specified accounting period using the double-declining balance method"
	},
	"DISC": {
		"a": "( settlement , maturity , pr , redemption [ , [ basis ] ] )",
		"d": "Financial function used to calculate the discount rate for a security"
	},
	"DOLLARDE": {
		"a": "( fractional-dollar , fraction )",
		"d": "Financial function used to convert a dollar price represented as a fraction into a dollar price represented as a decimal number"
	},
	"DOLLARFR": {
		"a": "( decimal-dollar , fraction )",
		"d": "Financial function used to convert a dollar price represented as a decimal number into a dollar price represented as a fraction"
	},
	"DURATION": {
		"a": "( settlement , maturity , coupon , yld , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the Macaulay duration of a security with an assumed par value of $100"
	},
	"EFFECT": {
		"a": "( nominal-rate , npery )",
		"d": "Financial function used to calculate the effective annual interest rate for a security based on a specified nominal annual interest rate and the number of compounding periods per year"
	},
	"FV": {
		"a": "( rate , nper , pmt [ , [ pv ] [ ,[ type ] ] ] )",
		"d": "Financial function used to calculate the future value of an investment based on a specified interest rate and a constant payment schedule"
	},
	"FVSCHEDULE": {
		"a": "( principal , schedule )",
		"d": "Financial function used to calculate the future value of an investment based on a series of changeable interest rates"
	},
	"INTRATE": {
		"a": "( settlement , maturity , pr , redemption [ , [ basis ] ] )",
		"d": "Financial function used to calculate the interest rate for a fully invested security that pays interest only at maturity"
	},
	"IPMT": {
		"a": "( rate , per , nper , pv [ , [ fv ] [ , [ type ] ] ] )",
		"d": "Financial function used to calculate the interest payment for an investment based on a specified interest rate and a constant payment schedule"
	},
	"IRR": {
		"a": "( values [ , [ guess ] ] )",
		"d": "Financial function used to calculate the internal rate of return for a series of periodic cash flows"
	},
	"ISPMT": {
		"a": "( rate , per , nper , pv )",
		"d": "Financial function used to calculate the interest payment for a specified period of an investment based on a constant payment schedule"
	},
	"MDURATION": {
		"a": "( settlement , maturity , coupon , yld , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the modified Macaulay duration of a security with an assumed par value of $100"
	},
	"MIRR": {
		"a": "( values , finance-rate , reinvest-rate )",
		"d": "Financial function used to calculate the modified internal rate of return for a series of periodic cash flows"
	},
	"NOMINAL": {
		"a": "( effect-rate , npery )",
		"d": "Financial function used to calculate the nominal annual interest rate for a security based on a specified effective annual interest rate and the number of compounding periods per year"
	},
	"NPER": {
		"a": "( rate , pmt , pv [ , [ fv ] [ , [ type ] ] ] )",
		"d": "Financial function used to calculate the number of periods for an investment based on a specified interest rate and a constant payment schedule"
	},
	"NPV": {
		"a": "( rate , argument-list )",
		"d": "Financial function used to calculate the net present value of an investment based on a specified discount rate"
	},
	"ODDFPRICE": {
		"a": "( settlement , maturity , issue , first-coupon , rate , yld , redemption , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the price per $100 par value for a security that pays periodic interest but has an odd first period (it is shorter or longer than other periods)"
	},
	"ODDFYIELD": {
		"a": "( settlement , maturity , issue , first-coupon , rate , pr , redemption , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the yield of a security that pays periodic interest but has an odd first period (it is shorter or longer than other periods)"
	},
	"ODDLPRICE": {
		"a": "( settlement , maturity , last-interest , rate , yld , redemption , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the price per $100 par value for a security that pays periodic interest but has an odd last period (it is shorter or longer than other periods)"
	},
	"ODDLYIELD": {
		"a": "( settlement , maturity , last-interest , rate , pr , redemption , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the yield of a security that pays periodic interest but has an odd last period (it is shorter or longer than other periods)"
	},
	"PDURATION": {
		"a": "( rate , pv , fv )",
		"d": "Financial function used return the number of periods required by an investment to reach a specified value"
	},
	"PMT": {
		"a": "( rate , nper , pv [ , [ fv ] [ ,[ type ] ] ] )",
		"d": "Financial function used to calculate the payment amount for a loan based on a specified interest rate and a constant payment schedule"
	},
	"PPMT": {
		"a": "( rate , per , nper , pv [ , [ fv ] [ , [ type ] ] ] )",
		"d": "Financial function used to calculate the principal payment for an investment based on a specified interest rate and a constant payment schedule"
	},
	"PRICE": {
		"a": "( settlement , maturity , rate , yld , redemption , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the price per $100 par value for a security that pays periodic interest"
	},
	"PRICEDISC": {
		"a": "( settlement , maturity , discount , redemption [ , [ basis ] ] )",
		"d": "Financial function used to calculate the price per $100 par value for a discounted security"
	},
	"PRICEMAT": {
		"a": "( settlement , maturity , issue , rate , yld [ , [ basis ] ] )",
		"d": "Financial function used to calculate the price per $100 par value for a security that pays interest at maturity"
	},
	"PV": {
		"a": "( rate , nper , pmt [ , [ fv ] [ ,[ type ] ] ] )",
		"d": "Financial function used to calculate the present value of an investment based on a specified interest rate and a constant payment schedule"
	},
	"RATE": {
		"a": "( nper , pmt , pv  [ , [ [ fv ] [ , [ [ type ] [ , [ guess ] ] ] ] ] ] )",
		"d": "Financial function used to calculate the interest rate for an investment based on a constant payment schedule"
	},
	"RECEIVED": {
		"a": "( settlement , maturity , investment , discount [ , [ basis ] ] )",
		"d": "Financial function used to calculate the amount received at maturity for a fully invested security"
	},
	"RRI": {
		"a": "( nper , pv , fv )",
		"d": "Financial function used to return an equivalent interest rate for the growth of an investment"
	},
	"SLN": {
		"a": "( cost , salvage , life )",
		"d": "Financial function used to calculate the depreciation of an asset for one accounting period using the straight-line depreciation method"
	},
	"SYD": {
		"a": "( cost , salvage , life , per )",
		"d": "Financial function used to calculate the depreciation of an asset for a specified accounting period using the sum of the years' digits method"
	},
	"TBILLEQ": {
		"a": "( settlement , maturity , discount )",
		"d": "Financial function used to calculate the bond-equivalent yield of a Treasury bill"
	},
	"TBILLPRICE": {
		"a": "( settlement , maturity , discount )",
		"d": "Financial function used to calculate the price per $100 par value for a Treasury bill"
	},
	"TBILLYIELD": {
		"a": "( settlement , maturity , pr )",
		"d": "Financial function used to calculate the yield of a Treasury bill"
	},
	"VDB": {
		"a": "( cost , salvage , life , start-period , end-period [ , [ [ factor ] [ , [ no-switch-flag ] ] ] ] ] )",
		"d": "Financial function used to calculate the depreciation of an asset for a specified or partial accounting period using the variable declining balance method"
	},
	"XIRR": {
		"a": "( values , dates [ , [ guess ] ] )",
		"d": "Financial function used to calculate the internal rate of return for a series of irregular cash flows"
	},
	"XNPV": {
		"a": "( rate , values , dates  )",
		"d": "Financial function used to calculate the net present value for an investment based on a specified interest rate and a schedule of irregular payments"
	},
	"YIELD": {
		"a": "( settlement , maturity , rate , pr , redemption , frequency [ , [ basis ] ] )",
		"d": "Financial function used to calculate the yield of a security that pays periodic interest"
	},
	"YIELDDISC": {
		"a": "( settlement , maturity , pr , redemption , [ , [ basis ] ] )",
		"d": "Financial function used to calculate the annual yield of a discounted security"
	},
	"YIELDMAT": {
		"a": "( settlement , maturity , issue , rate , pr [ , [ basis ] ] )",
		"d": "Financial function used to calculate the annual yield of a security that pays interest at maturity"
	},
	"ABS": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the absolute value of a number"
	},
	"ACOS": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the arccosine of a number"
	},
	"ACOSH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the inverse hyperbolic cosine of a number"
	},
	"ACOT": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the principal value of the arccotangent, or inverse cotangent, of a number"
	},
	"ACOTH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the inverse hyperbolic cotangent of a number"
	},
	"AGGREGATE": {
		"a": "( function_num , options , ref1 [ , ref2 ] , … )",
		"d": "Math and trigonometry function used to return an aggregate in a list or database; the function can apply different aggregate functions to a list or database with the option to ignore hidden rows and error values"
	},
	"ARABIC": {
		"a": "( x )",
		"d": "Math and trigonometry function used to convert a Roman numeral to an Arabic numeral"
	},
	"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": "( x )",
		"d": "Math and trigonometry function used to return the arcsine of a number"
	},
	"ASINH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the inverse hyperbolic sine of a number"
	},
	"ATAN": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the arctangent of a number"
	},
	"ATAN2": {
		"a": "( x, y )",
		"d": "Math and trigonometry function used to return the arctangent of x and y coordinates"
	},
	"ATANH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the inverse hyperbolic tangent of a number"
	},
	"BASE": {
		"a": "( number , base [ , min-length ] )",
		"d": "Converts a number into a text representation with the given base"
	},
	"CEILING": {
		"a": "( x, significance )",
		"d": "Math and trigonometry function used to round the number up to the nearest multiple of significance"
	},
	"CEILING.MATH": {
		"a": "( x [ , [ significance ] [ , [ mode ] ] )",
		"d": "Math and trigonometry function used to rounds a number up to the nearest integer or to the nearest multiple of significance"
	},
	"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": "( number , number-chosen )",
		"d": "Math and trigonometry function used to return the number of combinations for a specified number of items"
	},
	"COMBINA": {
		"a": "( number , number-chosen )",
		"d": "Math and trigonometry function used to return the number of combinations (with repetitions) for a given number of items"
	},
	"COS": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the cosine of an angle"
	},
	"COSH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the hyperbolic cosine of a number"
	},
	"COT": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the cotangent of an angle specified in radians"
	},
	"COTH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the hyperbolic cotangent of a hyperbolic angle"
	},
	"CSC": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the cosecant of an angle"
	},
	"CSCH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the hyperbolic cosecant of an angle"
	},
	"DECIMAL": {
		"a": "( text , base )",
		"d": "Converts a text representation of a number in a given base into a decimal number"
	},
	"DEGREES": {
		"a": "( angle )",
		"d": "Math and trigonometry function used to convert radians into degrees"
	},
	"ECMA.CEILING": {
		"a": "( x, significance )",
		"d": "Math and trigonometry function used to round the number up to the nearest multiple of significance"
	},
	"EVEN": {
		"a": "( x )",
		"d": "Math and trigonometry function used to round the number up to the nearest even integer"
	},
	"EXP": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the e constant raised to the desired power. The e constant is equal to 2,71828182845904"
	},
	"FACT": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the factorial of a number"
	},
	"FACTDOUBLE": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the double factorial of a number"
	},
	"FLOOR": {
		"a": "( x, significance )",
		"d": "Math and trigonometry function used to round the number down to the nearest multiple of significance"
	},
	"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": "( x [, [significance] [, [mode]] )",
		"d": "Math and trigonometry function used to round a number down to the nearest integer or to the nearest multiple of significance"
	},
	"GCD": {
		"a": "( argument-list )",
		"d": "Math and trigonometry function used to return the greatest common divisor of two or more numbers"
	},
	"INT": {
		"a": "( x )",
		"d": "Math and trigonometry function used to analyze and return the integer part of the specified number"
	},
	"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": "( argument-list )",
		"d": "Math and trigonometry function used to return the lowest common multiple of one or more numbers"
	},
	"LN": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the natural logarithm of a number"
	},
	"LOG": {
		"a": "( x [ , base ] )",
		"d": "Math and trigonometry function used to return the logarithm of a number to a specified base"
	},
	"LOG10": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the logarithm of a number to a base of 10"
	},
	"MDETERM": {
		"a": "( array )",
		"d": "Math and trigonometry function used to return the matrix determinant of an array"
	},
	"MINVERSE": {
		"a": "( array )",
		"d": "Math and trigonometry function used to return the inverse matrix for a given matrix and display the first value of the returned array of numbers"
	},
	"MMULT": {
		"a": "( array1, array2 )",
		"d": "Math and trigonometry function used to return the matrix product of two arrays and display the first value of the returned array of numbers"
	},
	"MOD": {
		"a": "( x, y )",
		"d": "Math and trigonometry function used to return the remainder after the division of a number by the specified divisor"
	},
	"MROUND": {
		"a": "( x, multiple )",
		"d": "Math and trigonometry function used to round the number to the desired multiple"
	},
	"MULTINOMIAL": {
		"a": "( argument-list )",
		"d": "Math and trigonometry function used to return the ratio of the factorial of a sum of numbers to the product of factorials"
	},
	"ODD": {
		"a": "( x )",
		"d": "Math and trigonometry function used to round the number up to the nearest odd integer"
	},
	"PI": {
		"a": "()",
		"d": "math and trigonometry functions. The function returns the mathematical constant pi, equal to 3.14159265358979. It does not require any argument"
	},
	"POWER": {
		"a": "( x, y )",
		"d": "Math and trigonometry function used to return the result of a number raised to the desired power"
	},
	"PRODUCT": {
		"a": "( argument-list )",
		"d": "Math and trigonometry function used to multiply all the numbers in the selected range of cells and return the product"
	},
	"QUOTIENT": {
		"a": "( dividend , divisor )",
		"d": "Math and trigonometry function used to return the integer portion of a division"
	},
	"RADIANS": {
		"a": "( angle )",
		"d": "Math and trigonometry function used to convert degrees into radians"
	},
	"RAND": {
		"a": "()",
		"d": "Math and trigonometry functionused to return a random number greater than or equal to 0 and less than 1. It does not require any argument"
	},
	"RANDBETWEEN": {
		"a": "( lower-bound , upper-bound )",
		"d": "Math and trigonometry function used to return a random number greater than or equal to lower-bound and less than or equal to upper-bound"
	},
	"ROMAN": {
		"a": "( number, form )",
		"d": "Math and trigonometry function used to convert a number to a roman numeral"
	},
	"ROUND": {
		"a": "( x , number-digits )",
		"d": "Math and trigonometry function used to round the number to the desired number of digits"
	},
	"ROUNDDOWN": {
		"a": "( x , number-digits )",
		"d": "Math and trigonometry function used to round the number down to the desired number of digits"
	},
	"ROUNDUP": {
		"a": "( x , number-digits )",
		"d": "Math and trigonometry function used to round the number up to the desired number of digits"
	},
	"SEC": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the secant of an angle"
	},
	"SECH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the hyperbolic secant of an angle"
	},
	"SERIESSUM": {
		"a": "( input-value , initial-power , step , coefficients )",
		"d": "Math and trigonometry function used to return the sum of a power series"
	},
	"SIGN": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the sign of a number. If the number is positive, the function returns 1. If the number is negative, the function returns -1. If the number is 0, the function returns 0"
	},
	"SIN": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the sine of an angle"
	},
	"SINH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the hyperbolic sine of a number"
	},
	"SQRT": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the square root of a number"
	},
	"SQRTPI": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the square root of the pi constant (3.14159265358979) multiplied by the specified number"
	},
	"SUBTOTAL": {
		"a": "( function-number , argument-list )",
		"d": "Math and trigonometry function used to return a subtotal in a list or database"
	},
	"SUM": {
		"a": "( argument-list )",
		"d": "Math and trigonometry function used to add all the numbers in the selected range of cells and return the result"
	},
	"SUMIF": {
		"a": "( cell-range, selection-criteria [ , sum-range ] )",
		"d": "Math and trigonometry function used to add all the numbers in the selected range of cells based on the specified criterion and return the result"
	},
	"SUMIFS": {
		"a": "( sum-range, criteria-range1, criteria1, [ criteria-range2, criteria2 ], ... )",
		"d": "Math and trigonometry function used to add all the numbers in the selected range of cells based on multiple criteria and return the result"
	},
	"SUMPRODUCT": {
		"a": "( argument-list )",
		"d": "Math and trigonometry function used to multiply the values in the selected ranges of cells or arrays and return the sum of the products"
	},
	"SUMSQ": {
		"a": "( argument-list )",
		"d": "Math and trigonometry function used to add the squares of numbers and return the result"
	},
	"SUMX2MY2": {
		"a": "( array-1 , array-2 )",
		"d": "Math and trigonometry function used to sum the difference of squares between two arrays"
	},
	"SUMX2PY2": {
		"a": "( array-1 , array-2 )",
		"d": "Math and trigonometry function used to sum the squares of numbers in the selected arrays and return the sum of the results"
	},
	"SUMXMY2": {
		"a": "( array-1 , array-2 )",
		"d": "Math and trigonometry function used to return the sum of the squares of the differences between corresponding items in the arrays"
	},
	"TAN": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the tangent of an angle"
	},
	"TANH": {
		"a": "( x )",
		"d": "Math and trigonometry function used to return the hyperbolic tangent of a number"
	},
	"TRUNC": {
		"a": "( x [ , number-digits ] )",
		"d": "Math and trigonometry function used to return a number truncated to a specified number of digits"
	},
	"ADDRESS": {
		"a": "( row-number , col-number [ , [ ref-type ] [ , [ A1-ref-style-flag ] [ , sheet-name ] ] ] )",
		"d": "Lookup and reference function used to return a text representation of a cell address"
	},
	"CHOOSE": {
		"a": "( index , argument-list )",
		"d": "Lookup and reference function used to return a value from a list of values based on a specified index (position)"
	},
	"COLUMN": {
		"a": "( [ reference ] )",
		"d": "Lookup and reference function used to return the column number of a cell"
	},
	"COLUMNS": {
		"a": "( array )",
		"d": "Lookup and reference function used to return the number of columns in a cell reference"
	},
	"FORMULATEXT": {
		"a": "( reference )",
		"d": "Lookup and reference function used to return a formula as a string"
	},
	"HLOOKUP": {
		"a": "( lookup-value  ,  table-array  ,  row-index-num  [  ,  [  range-lookup-flag  ] ] )",
		"d": "Lookup and reference function used to perform the horizontal search for a value in the top row of a table or an array and return the value in the same column based on a specified row index number"
	},
	"HYPERLINK": {
		"a": "( link_location  ,  [  ,  [  friendly_name  ] ] )",
		"d": "Lookup and reference function used to create a shortcut that jumps to another location in the current workbook, or opens a document stored on a network server, an intranet, or the Internet"
	},
	"INDEX": {
		"a": "( array , [ row-number ] [ , [ column-number ] ] )",
		"d": "Lookup and reference function used to return a value within a range of cells on the base of a specified row and column number. The INDEX function has two forms"
	},
	"INDIRECT": {
		"a": "( ref-text [ , [ A1-ref-style-flag ] ] )",
		"d": "Lookup and reference function used to return the reference to a cell based on its string representation"
	},
	"LOOKUP": {
		"a": "(  lookup-value  ,  lookup-vector  ,  result-vector  )",
		"d": "Lookup and reference function used to return a value from a selected range (row or column containing the data in ascending order)"
	},
	"MATCH": {
		"a": "(  lookup-value  ,  lookup-array [ , [ match-type ]] )",
		"d": "Lookup and reference function used to return a relative position of a specified item in a range of cells"
	},
	"OFFSET": {
		"a": "( reference , rows , cols [ , [ height ] [ , [ width ] ] ] )",
		"d": "Lookup and reference function used to return a reference to a cell displaced from the specified cell (or the upper-left cell in the range of cells) to a certain number of rows and columns"
	},
	"ROW": {
		"a": "( [ reference ] )",
		"d": "Lookup and reference function used to return the row number of a cell reference"
	},
	"ROWS": {
		"a": "( array )",
		"d": "Lookup and reference function used to return the number of rows in a cell references"
	},
	"TRANSPOSE": {
		"a": "( array )",
		"d": "Lookup and reference function used to return the first element of an array"
	},
	"VLOOKUP": {
		"a": "( lookup-value  ,  table-array  ,  col-index-num  [  ,  [  range-lookup-flag  ] ] )",
		"d": "Lookup and reference function used to perform the vertical search for a value in the left-most column of a table or an array and return the value in the same row based on a specified column index number"
	},
	"ERROR.TYPE": {
		"a": "(value)",
		"d": "Information function used to return the numeric representation of one of the existing errors"
	},
	"ISBLANK": {
		"a": "(value)",
		"d": "Information function used to check if the cell is empty or not. If the cell does not contain any value, the function returns TRUE, otherwise the function returns FALSE"
	},
	"ISERR": {
		"a": "(value)",
		"d": "Information function used to check for an error value. If the cell contains an error value (except #N/A), the function returns TRUE, otherwise the function returns FALSE"
	},
	"ISERROR": {
		"a": "(value)",
		"d": "Information function used to check for an error value. If the cell contains one of the error values: #N/A, #VALUE!, #REF!, #DIV/0!, #NUM!, #NAME? or #NULL, the function returns TRUE, otherwise the function returns FALSE"
	},
	"ISEVEN": {
		"a": "(number)",
		"d": "Information function used to check for an even value. If the cell contains an even value, the function returns TRUE. If the value is odd, it returns FALSE"
	},
	"ISFORMULA": {
		"a": "( value )",
		"d": "Information function used to check whether there is a reference to a cell that contains a formula, and returns TRUE or FALSE"
	},
	"ISLOGICAL": {
		"a": "(value)",
		"d": "Information function used to check for a logical value (TRUE or FALSE). If the cell contains a logical value, the function returns TRUE, otherwise the function returns FALSE"
	},
	"ISNA": {
		"a": "(value)",
		"d": "Information function used to check for a #N/A error. If the cell contains a #N/A error value, the function returns TRUE, otherwise the function returns FALSE"
	},
	"ISNONTEXT": {
		"a": "(value)",
		"d": "Information function used to check for a value that is not a text. If the cell does not contain a text value, the function returns TRUE, otherwise the function returns FALSE"
	},
	"ISNUMBER": {
		"a": "(value)",
		"d": "Information function used to check for a numeric value. If the cell contains a numeric value, the function returns TRUE, otherwise the function returns FALSE"
	},
	"ISODD": {
		"a": "(number)",
		"d": "Information function used to check for an odd value. If the cell contains an odd value, the function returns TRUE. If the value is even, it returns FALSE"
	},
	"ISREF": {
		"a": "(value)",
		"d": "Information function used to verify if the value is a valid cell reference"
	},
	"ISTEXT": {
		"a": "(value)",
		"d": "Information function used to check for a text value. If the cell contains a text value, the function returns TRUE, otherwise the function returns FALSE"
	},
	"N": {
		"a": "(value)",
		"d": "Information function used to convert a value to a number"
	},
	"NA": {
		"a": "()",
		"d": "Information function used to return the #N/A error value. This function does not require an argument"
	},
	"SHEET": {
		"a": "( value )",
		"d": "Information function used to return the sheet number of the reference sheet"
	},
	"SHEETS": {
		"a": "( reference )",
		"d": "Information function used to return the number of sheets in a reference"
	},
	"TYPE": {
		"a": "( value )",
		"d": "Information function used to determine the type of the resulting or displayed value"
	},
	"AND": {
		"a": "( logical1 , logical2, ... )",
		"d": "Logical function used to check if the logical value you enter is TRUE or FALSE. The function returns TRUE if all the arguments are TRUE"
	},
	"FALSE": {
		"a": "()",
		"d": "logical functions. The function returns FALSE and does not require any argument"
	},
	"IF": {
		"a": "( logical_test , value_if_true [ , value_if_false ] )",
		"d": "Logical function used to check the logical expression and return one value if it is TRUE, or another if it is FALSE"
	},
	"IFS": {
		"a": "( logical_test1 , value_if_true1 , [ logical_test2 , value_if_true2 ] , … )",
		"d": "Logical function used to check whether one or more conditions are met and returns a value that corresponds to the first TRUE condition"
	},
	"IFERROR": {
		"a": " (value , value_if_error )",
		"d": "Logical function used to check if there is an error in the formula in the first argument. The function returns the result of the formula if there is no error, or the value_if_error if there is one"
	},
	"IFNA": {
		"a": "( value , value_if_na )",
		"d": "Logical function used to check if there is an error in the formula in the first argument. The function returns the value you specify if the formula returns the #N/A error value; otherwise returns the result of the formula"
	},
	"NOT": {
		"a": "( logical )",
		"d": "Logical function used to check if the logical value you enter is TRUE or FALSE. The function returns TRUE if the argument is FALSE and FALSE if the argument is TRUE"
	},
	"OR": {
		"a": "( logical1, logical2, ...)",
		"d": "Logical function used to check if the logical value you enter is TRUE or FALSE. The function returns FALSE if all the arguments are FALSE"
	},
	"SWITCH": {
		"a": "( expression , value1 , result1 [ , [ default or value2 ] [ , [ result2 ] ], … [ default or value3 , result3 ] ] )",
		"d": "Logical function used to evaluate one value (called the expression) against a list of values, and returns the result corresponding to the first matching value; if there is no match, an optional default value may be returned"
	},
	"TRUE": {
		"a": "()",
		"d": "Logical function used to return TRUE and does not require any argument"
	},
	"XOR": {
		"a": "( logical1 [ , logical2 ] , ... )",
		"d": "Logical function used to returns a logical Exclusive Or of all arguments"
	}
}