/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the Collabora Office project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
#pragma once

#include <unotools/resmgr.hxx>

#define NC_(Context, String) TranslateId(Context, u8##String)

/* Resource file for the function wizard / autopilot.
 *
 *  For every function there is a StringArray with a resource id (offset by
 *  RID_SC_FUNC_DESCRIPTIONS_START) with the OpCode of the function
 *
 *  In this stringarray, the description of the function is given as the first
 *  entry, followed by two entries for each parameter, first the type or name
 *  of the parameter, second a description of the parameter.
 */

// -=*# Resource for function DCOUNT #*=-
const TranslateId ocDB_COUNT_ARY[] =
{
    NC_("ocDB_COUNT", "Counts the cells of a data range whose contents match the search criteria."),
    NC_("ocDB_COUNT", "Database"),
    NC_("ocDB_COUNT", "The range of cells containing data."),
    NC_("ocDB_COUNT", "Database field"),
    NC_("ocDB_COUNT", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_COUNT", "Search criteria"),
    NC_("ocDB_COUNT", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DCOUNTA #*=-
const TranslateId ocDB_COUNT_2_ARY[] =
{
    NC_("ocDB_COUNT_2", "Counts all non-blank cells of a data range where the content corresponds to the search criteria."),
    NC_("ocDB_COUNT_2", "Database"),
    NC_("ocDB_COUNT_2", "The range of cells containing data."),
    NC_("ocDB_COUNT_2", "Database field"),
    NC_("ocDB_COUNT_2", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_COUNT_2", "Search criteria"),
    NC_("ocDB_COUNT_2", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DAVERAGE #*=-
const TranslateId ocDB_AVERAGE_ARY[] =
{
    NC_("ocDB_AVERAGE", "Returns the average value of all the cells of a data range whose contents match the search criteria."),
    NC_("ocDB_AVERAGE", "Database"),
    NC_("ocDB_AVERAGE", "The range of cells containing data."),
    NC_("ocDB_AVERAGE", "Database field"),
    NC_("ocDB_AVERAGE", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_AVERAGE", "Search criteria"),
    NC_("ocDB_AVERAGE", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DGET #*=-
const TranslateId ocDB_GET_ARY[] =
{
    NC_("ocDB_GET", "Defines the contents of the cell of a data range which matches the search criteria."),
    NC_("ocDB_GET", "Database"),
    NC_("ocDB_GET", "The range of cells containing data."),
    NC_("ocDB_GET", "Database field"),
    NC_("ocDB_GET", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_GET", "Search criteria"),
    NC_("ocDB_GET", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DMAX #*=-
const TranslateId ocDB_MAX_ARY[] =
{
    NC_("ocDB_MAX", "Returns the maximum value from all of the cells of a data range which correspond to the search criteria."),
    NC_("ocDB_MAX", "Database"),
    NC_("ocDB_MAX", "The range of cells containing data."),
    NC_("ocDB_MAX", "Database field"),
    NC_("ocDB_MAX", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_MAX", "Search criteria"),
    NC_("ocDB_MAX", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DMIN #*=-
const TranslateId ocDB_MIN_ARY[] =
{
    NC_("ocDB_MIN", "Returns the minimum of all cells of a data range where the contents correspond to the search criteria."),
    NC_("ocDB_MIN", "Database"),
    NC_("ocDB_MIN", "The range of cells containing data."),
    NC_("ocDB_MIN", "Database field"),
    NC_("ocDB_MIN", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_MIN", "Search criteria"),
    NC_("ocDB_MIN", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DPRODUCT #*=-
const TranslateId ocDB_PRODUCT_ARY[] =
{
    NC_("ocDB_PRODUCT", "Multiplies all cells of a data range where the contents match the search criteria."),
    NC_("ocDB_PRODUCT", "Database"),
    NC_("ocDB_PRODUCT", "The range of cells containing data."),
    NC_("ocDB_PRODUCT", "Database field"),
    NC_("ocDB_PRODUCT", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_PRODUCT", "Search criteria"),
    NC_("ocDB_PRODUCT", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DSTDEV #*=-
const TranslateId ocDB_STD_DEV_ARY[] =
{
    NC_("ocDB_STD_DEV", "Calculates the standard deviation of all cells in a data range whose contents match the search criteria."),
    NC_("ocDB_STD_DEV", "Database"),
    NC_("ocDB_STD_DEV", "The range of cells containing data."),
    NC_("ocDB_STD_DEV", "Database field"),
    NC_("ocDB_STD_DEV", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_STD_DEV", "Search criteria"),
    NC_("ocDB_STD_DEV", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DSTDEVP #*=-
const TranslateId ocDB_STD_DEV_P_ARY[] =
{
    NC_("ocDB_STD_DEV_P", "Returns the standard deviation with regards to the population of all cells of a data range matching the search criteria."),
    NC_("ocDB_STD_DEV_P", "Database"),
    NC_("ocDB_STD_DEV_P", "The range of cells containing data."),
    NC_("ocDB_STD_DEV_P", "Database field"),
    NC_("ocDB_STD_DEV_P", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_STD_DEV_P", "Search criteria"),
    NC_("ocDB_STD_DEV_P", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DSUM #*=-
const TranslateId ocDB_SUM_ARY[] =
{
    NC_("ocDB_SUM", "Adds all the cells of a data range where the contents match the search criteria."),
    NC_("ocDB_SUM", "Database"),
    NC_("ocDB_SUM", "The range of cells containing data."),
    NC_("ocDB_SUM", "Database field"),
    NC_("ocDB_SUM", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_SUM", "Search criteria"),
    NC_("ocDB_SUM", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DVAR #*=-
const TranslateId ocDB_VAR_ARY[] =
{
    NC_("ocDB_VAR", "Determines the variance of all the cells in a data range where the contents match the search criteria."),
    NC_("ocDB_VAR", "Database"),
    NC_("ocDB_VAR", "The range of cells containing data."),
    NC_("ocDB_VAR", "Database field"),
    NC_("ocDB_VAR", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_VAR", "Search criteria"),
    NC_("ocDB_VAR", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DVARP #*=-
const TranslateId ocDB_VAR_P_ARY[] =
{
    NC_("ocDB_VAR_P", "Determines variance of a population based on all cells in a data range where contents match the search criteria."),
    NC_("ocDB_VAR_P", "Database"),
    NC_("ocDB_VAR_P", "The range of cells containing data."),
    NC_("ocDB_VAR_P", "Database field"),
    NC_("ocDB_VAR_P", "Indicates which database field (column) is to be used for the search criteria."),
    NC_("ocDB_VAR_P", "Search criteria"),
    NC_("ocDB_VAR_P", "Defines the cell range containing the search criteria.")
};

// -=*# Resource for function DATE #*=-
const TranslateId ocGET_DATE_ARY[] =
{
    NC_("ocGET_DATE", "Provides an internal number for the date given."),
    NC_("ocGET_DATE", "Year"),
    NC_("ocGET_DATE", "An integer between 1583 and 9956 or 0 and 99 (19xx or 20xx depending on the defined option)."),
    NC_("ocGET_DATE", "Month"),
    NC_("ocGET_DATE", "An integer between 1 and 12 representing the month."),
    NC_("ocGET_DATE", "Day"),
    NC_("ocGET_DATE", "An integer between 1 and 31 representing the day of the month.")
};

// -=*# Resource for function DATE_VALUE #*=-
const TranslateId ocGET_DATE_VALUE_ARY[] =
{
    NC_("ocGET_DATE_VALUE", "Returns an internal number for a text having a possible date format."),
    NC_("ocGET_DATE_VALUE", "Text"),
    NC_("ocGET_DATE_VALUE", "A text enclosed in quotation marks which returns a date in a %PRODUCTNAME date format.")
};

// -=*# Resource for function DAY #*=-
const TranslateId ocGET_DAY_ARY[] =
{
    NC_("ocGET_DAY", "Returns the sequential date of the month as an integer (1-31) in relation to the date value."),
    NC_("ocGET_DAY", "Number"),
    NC_("ocGET_DAY", "The internal number for the date.")
};

// -=*# Resource for function DAYS360 #*=-
const TranslateId ocGET_DIFF_DATE_360_ARY[] =
{
    NC_("ocGET_DIFF_DATE_360", "Calculates the number of days between two dates based on a 360-day year."),
    NC_("ocGET_DIFF_DATE_360", "Date 1"),
    NC_("ocGET_DIFF_DATE_360", "The start date for calculating the difference in days."),
    NC_("ocGET_DIFF_DATE_360", "Date 2"),
    NC_("ocGET_DIFF_DATE_360", "The end date for calculating the difference in days."),
    NC_("ocGET_DIFF_DATE_360", "Type"),
    NC_("ocGET_DIFF_DATE_360", "Method used to form differences: Type = 0 denotes US method (NASD), Type = 1 denotes the European method.")
};

// -=*# Resource for function NETWORKDAYS #*=-
const TranslateId ocNETWORKDAYS_ARY[] =
{
    NC_("ocNETWORKDAYS", "Returns the number of workdays between two dates using arguments to indicate weekenddays and holidays."),
    NC_("ocNETWORKDAYS", "Start date"),
    NC_("ocNETWORKDAYS", "Start date for calculation."),
    NC_("ocNETWORKDAYS", "End date"),
    NC_("ocNETWORKDAYS", "End date for calculation."),
    NC_("ocNETWORKDAYS", "List of dates"),
    NC_("ocNETWORKDAYS", "Optional set of one or more dates to be considered as holiday."),
    NC_("ocNETWORKDAYS", "Array"),
    NC_("ocNETWORKDAYS", "Optional list of numbers to indicate working (0) and weekend (non-zero) days. When omitted, weekend is Saturday and Sunday.")
};

// -=*# Resource for function NETWORKDAYS.INTL #*=-
const TranslateId ocNETWORKDAYS_MS_ARY[] =
{
    NC_("ocNETWORKDAYS_MS", "Returns the number of workdays between two dates using arguments to indicate weekend days and holidays."),
    NC_("ocNETWORKDAYS_MS", "Start date"),
    NC_("ocNETWORKDAYS_MS", "Start date for calculation."),
    NC_("ocNETWORKDAYS_MS", "End date"),
    NC_("ocNETWORKDAYS_MS", "End date for calculation."),
    NC_("ocNETWORKDAYS_MS", "Number or string"),
    NC_("ocNETWORKDAYS_MS", "Optional number or string to indicate when weekends occur. When omitted, weekend is Saturday and Sunday."),
    NC_("ocNETWORKDAYS_MS", "Array"),
    NC_("ocNETWORKDAYS_MS", "Optional set of one or more dates to be considered as holiday.")
};

// -=*# Resource for function WORKDAY.INTL #*=-
const TranslateId ocWORKDAY_MS_ARY[] =
{
    NC_("ocWORKDAY_MS", "Returns the serial number of the date before or after a number of workdays using arguments to indicate weekend days and holidays."),
    NC_("ocWORKDAY_MS", "Start date"),
    NC_("ocWORKDAY_MS", "Start date for calculation."),
    NC_("ocWORKDAY_MS", "Days"),
    NC_("ocWORKDAY_MS", "The number of workdays before or after start date."),
    NC_("ocWORKDAY_MS", "Number or string"),
    NC_("ocWORKDAY_MS", "Optional number or string to indicate when weekends occur. When omitted, weekend is Saturday and Sunday."),
    NC_("ocWORKDAY_MS", "Array"),
    NC_("ocWORKDAY_MS", "Optional set of one or more dates to be considered as holiday.")
};

// -=*# Resource for function HOUR #*=-
const TranslateId ocGET_HOUR_ARY[] =
{
    NC_("ocGET_HOUR", "Determines the sequential number of the hour of the day (0-23) for the time value."),
    NC_("ocGET_HOUR", "Number"),
    NC_("ocGET_HOUR", "Internal time value")
};

// -=*# Resource for function MINUTE #*=-
const TranslateId ocGET_MIN_ARY[] =
{
    NC_("ocGET_MIN", "Determines the sequential number for the minute of the hour (0-59) for the time value."),
    NC_("ocGET_MIN", "Number"),
    NC_("ocGET_MIN", "Internal time value.")
};

// -=*# Resource for function MONTH #*=-
const TranslateId ocGET_MONTH_ARY[] =
{
    NC_("ocGET_MONTH", "Determines the sequential number of a month of the year (1-12) for the date value."),
    NC_("ocGET_MONTH", "Number"),
    NC_("ocGET_MONTH", "The internal number of the date.")
};

// -=*# Resource for function NOW #*=-
const TranslateId ocGET_ACT_TIME_ARY[] =
{
    NC_("ocGET_ACT_TIME", "Determines the current time of the computer.")
};

// -=*# Resource for function SECOND #*=-
const TranslateId ocGET_SEC_ARY[] =
{
    NC_("ocGET_SEC", "Determines the sequential number of the second of a minute (0-59) for the time value."),
    NC_("ocGET_SEC", "Number"),
    NC_("ocGET_SEC", "The internal time value.")
};

// -=*# Resource for function TIME #*=-
const TranslateId ocGET_TIME_ARY[] =
{
    NC_("ocGET_TIME", "Determines a time value from the details for hour, minute and second."),
    NC_("ocGET_TIME", "Hour"),
    NC_("ocGET_TIME", "The integer for the hour."),
    NC_("ocGET_TIME", "Minute"),
    NC_("ocGET_TIME", "The integer for the minute."),
    NC_("ocGET_TIME", "Second"),
    NC_("ocGET_TIME", "The integer for the second.")
};

// -=*# Resource for function TIMEVALUE #*=-
const TranslateId ocGET_TIME_VALUE_ARY[] =
{
    NC_("ocGET_TIME_VALUE", "Returns a sequential number for a text shown in a possible time entry format."),
    NC_("ocGET_TIME_VALUE", "Text"),
    NC_("ocGET_TIME_VALUE", "A text enclosed in quotation marks which returns a time in a %PRODUCTNAME time format.")
};

// -=*# Resource for function TODAY #*=-
const TranslateId ocGET_ACT_DATE_ARY[] =
{
    NC_("ocGET_ACT_DATE", "Determines the current date of the computer.")
};

// -=*# Resource for function WEEKDAY #*=-
const TranslateId ocGET_DAY_OF_WEEK_ARY[] =
{
    NC_("ocGET_DAY_OF_WEEK", "Returns the day of the week for the date value as an integer."),
    NC_("ocGET_DAY_OF_WEEK", "Number"),
    NC_("ocGET_DAY_OF_WEEK", "The internal number for the date."),
    NC_("ocGET_DAY_OF_WEEK", "Type"),
    NC_("ocGET_DAY_OF_WEEK", "Fixes the beginning of the week and the type of calculation to be used.")
};

// -=*# Resource for function YEAR #*=-
const TranslateId ocGET_YEAR_ARY[] =
{
    NC_("ocGET_YEAR", "Returns the year of a date value as an integer."),
    NC_("ocGET_YEAR", "Number"),
    NC_("ocGET_YEAR", "Internal number of the date.")
};

// -=*# Resource for function DAYS #*=-
const TranslateId ocGET_DIFF_DATE_ARY[] =
{
    NC_("ocGET_DIFF_DATE", "Calculates the number of days between two dates."),
    NC_("ocGET_DIFF_DATE", "Date 2"),
    NC_("ocGET_DIFF_DATE", "The end date for calculating the difference in days."),
    NC_("ocGET_DIFF_DATE", "Date 1"),
    NC_("ocGET_DIFF_DATE", "The start date for calculating the difference in days.")
};

// -=*# Resource for function DATEDIF #*=-
const TranslateId ocGET_DATEDIF_ARY[] =
{
    NC_("ocGET_DATEDIF", "Returns the number of whole days, months or years between 'start date' and 'end date'."),
    NC_("ocGET_DATEDIF", "Start date"),
    NC_("ocGET_DATEDIF", "The start date."),
    NC_("ocGET_DATEDIF", "End date"),
    NC_("ocGET_DATEDIF", "The end date."),
    NC_("ocGET_DATEDIF", "Interval"),
    NC_("ocGET_DATEDIF", "Interval to be calculated. Can be \"d\", \"m\", \"y\", \"ym\", \"md\" or \"yd\".")
};

// -=*# Resource for function WEEKNUM #*=-
const TranslateId ocWEEK_ARY[] =
{
    NC_("ocWEEK", "Calculates the calendar week corresponding to the given date."),
    NC_("ocWEEK", "Number"),
    NC_("ocWEEK", "The internal number of the date."),
    NC_("ocWEEK", "Mode"),
    NC_("ocWEEK", "Indicates the first day of the week and when week 1 starts.")
};

// -=*# Resource for function ISOWEEKNUM #*=-
const TranslateId ocISOWEEKNUM_ARY[] =
{
    NC_("ocISOWEEKNUM", "Calculates the ISO 8601 calendar week for the given date."),
    NC_("ocISOWEEKNUM", "Number"),
    NC_("ocISOWEEKNUM", "The internal number of the date.")
};

const TranslateId ocWEEKNUM_OOO_ARY[] =
{
    NC_("ocWEEKNUM_OOO", "Calculates the calendar week corresponding to the given date.\nThis function only provides interoperability with %PRODUCTNAME 5.0 and earlier and OpenOffice.org."),
    NC_("ocWEEKNUM_OOO", "Number"),
    NC_("ocWEEKNUM_OOO", "The internal number of the date."),
    NC_("ocWEEKNUM_OOO", "Mode"),
    NC_("ocWEEKNUM_OOO", "Indicates the first day of the week (1 = Sunday, other values = Monday).")
};

// -=*# Resource for function EASTERSUNDAY #*=-
const TranslateId ocEASTERSUNDAY_ARY[] =
{
    NC_("ocEASTERSUNDAY", "Calculates the date of Easter Sunday in a given year."),
    NC_("ocEASTERSUNDAY", "Year"),
    NC_("ocEASTERSUNDAY", "An integer between 1583 and 9956, or 0 and 99 (19xx or 20xx depending on the option set).")
};

// -=*# Resource for function PV #*=-
const TranslateId ocPV_ARY[] =
{
    NC_("ocPV", "Present value. Calculates the present value of an investment."),
    NC_("ocPV", "Rate"),
    NC_("ocPV", "The rate of interest for the period given."),
    NC_("ocPV", "NPER"),
    NC_("ocPV", "The payment period. The total number of periods in which the annuity is paid."),
    NC_("ocPV", "PMT"),
    NC_("ocPV", "Regular payments. The constant amount of annuity that is paid in each period."),
    NC_("ocPV", "FV"),
    NC_("ocPV", "Future value. The value (final value) to be attained after the last payment."),
    NC_("ocPV", "Type"),
    NC_("ocPV", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function FV #*=-
const TranslateId ocFV_ARY[] =
{
    NC_("ocFV", "Future value. Returns the future value of an investment based on regular payments and a constant interest rate."),
    NC_("ocFV", "Rate"),
    NC_("ocFV", "The rate of interest per period."),
    NC_("ocFV", "NPER"),
    NC_("ocFV", "Payment period. The total number of periods in which the annuity (pension) is paid."),
    NC_("ocFV", "PMT"),
    NC_("ocFV", "Regular payments. The constant annuity to be paid in each period."),
    NC_("ocFV", "PV"),
    NC_("ocFV", "Present value. The current value of a series of payments"),
    NC_("ocFV", "Type"),
    NC_("ocFV", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function NPER #*=-
const TranslateId ocNPER_ARY[] =
{
    NC_("ocNPER", "Payment period. Calculates the number of payment periods for an investment based on regular payments and a constant interest rate."),
    NC_("ocNPER", "Rate"),
    NC_("ocNPER", "The rate of interest per period."),
    NC_("ocNPER", "PMT"),
    NC_("ocNPER", "Regular payments. The constant annuity to be paid in each period."),
    NC_("ocNPER", "PV"),
    NC_("ocNPER", "Present value. The current value of a series of payments"),
    NC_("ocNPER", "FV"),
    NC_("ocNPER", "Future value. The value (end value) to be attained after the final payment."),
    NC_("ocNPER", "Type"),
    NC_("ocNPER", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function PMT #*=-
const TranslateId ocPMT_ARY[] =
{
    NC_("ocPMT", "Regular payments. Returns the periodic payment of an annuity, based on regular payments and a fixed periodic interest rate."),
    NC_("ocPMT", "Rate"),
    NC_("ocPMT", "The rate of interest per period."),
    NC_("ocPMT", "NPER"),
    NC_("ocPMT", "Payment period. The total number of periods in which the annuity (pension) is paid."),
    NC_("ocPMT", "PV"),
    NC_("ocPMT", "Present value. The current value of a series of payments"),
    NC_("ocPMT", "FV"),
    NC_("ocPMT", "Future value. The value (end value) to be attained after the final payment."),
    NC_("ocPMT", "Type"),
    NC_("ocPMT", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function RATE #*=-
const TranslateId ocRATE_ARY[] =
{
    NC_("ocRATE", "Calculates the constant interest rate of an investment with regular payments."),
    NC_("ocRATE", "NPER"),
    NC_("ocRATE", "Payment period. The total number of periods in which the annuity (pension) is paid."),
    NC_("ocRATE", "PMT"),
    NC_("ocRATE", "Regular payments. The constant annuity to be paid in each period."),
    NC_("ocRATE", "PV"),
    NC_("ocRATE", "Present value. The current value of a series of payments"),
    NC_("ocRATE", "FV"),
    NC_("ocRATE", "Future value. The value (end value) to be attained after the final payment."),
    NC_("ocRATE", "Type"),
    NC_("ocRATE", "Type = 1 denotes due at the beginning of the period, = 0 at the end."),
    NC_("ocRATE", "Guess"),
    NC_("ocRATE", "Guess. The estimate of the interest rate for the iterative calculating method.")
};

// -=*# Resource for function IPMT #*=-
const TranslateId ocIPMT_ARY[] =
{
    NC_("ocIPMT", "Compounded interest. Calculates the interest payment on the principal for an investment with regular payments and a constant interest rate for a given period."),
    NC_("ocIPMT", "Rate"),
    NC_("ocIPMT", "The rate of interest per period."),
    NC_("ocIPMT", "Period"),
    NC_("ocIPMT", "Periods. The periods for which the compounded interest is to be calculated. P = 1 denotes for the first period, P = NPER for the last one."),
    NC_("ocIPMT", "NPER"),
    NC_("ocIPMT", "Payment period. The total number of periods in which the annuity (pension) is paid."),
    NC_("ocIPMT", "PV"),
    NC_("ocIPMT", "Present value. The current value of a series of payments"),
    NC_("ocIPMT", "FV"),
    NC_("ocIPMT", "Future value. The value (end value) to be attained after the final payment."),
    NC_("ocIPMT", "Type"),
    NC_("ocIPMT", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function PPMT #*=-
const TranslateId ocPPMT_ARY[] =
{
    NC_("ocPPMT", "Repayment. Calculates the repayment amount for a period for an investment whereby the payments are at regular intervals and the interest rate constant."),
    NC_("ocPPMT", "Rate"),
    NC_("ocPPMT", "The interest rate per period."),
    NC_("ocPPMT", "Period"),
    NC_("ocPPMT", "Period. The period for which the repayments are to be calculated. Per = 1 denotes for the first period, P = NPER for the last"),
    NC_("ocPPMT", "NPER"),
    NC_("ocPPMT", "The payment period. The total number of periods in which the annuity (pension) is paid."),
    NC_("ocPPMT", "PV"),
    NC_("ocPPMT", "The present value. The present value or the amount the annuity is currently worth."),
    NC_("ocPPMT", "FV"),
    NC_("ocPPMT", "Future value. The value (end value) attained after the last payment has been made."),
    NC_("ocPPMT", "Type"),
    NC_("ocPPMT", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function CUMPRINC #*=-
const TranslateId ocCUM_PRINC_ARY[] =
{
    NC_("ocCUM_PRINC", "Cumulative capital. Calculates the total amount of the repayment share in a period for an investment with constant interest rate."),
    NC_("ocCUM_PRINC", "Rate"),
    NC_("ocCUM_PRINC", "The rate of interest per period."),
    NC_("ocCUM_PRINC", "NPER"),
    NC_("ocCUM_PRINC", "Payment period. The total number of periods in which the annuity (pension) is paid."),
    NC_("ocCUM_PRINC", "PV"),
    NC_("ocCUM_PRINC", "The present value. The present value or the amount the annuity is currently worth."),
    NC_("ocCUM_PRINC", "S"),
    NC_("ocCUM_PRINC", "The start period. The first period to be taken into account. S = 1 denotes the very first period."),
    NC_("ocCUM_PRINC", "E"),
    NC_("ocCUM_PRINC", "End period. The last period to be taken into account."),
    NC_("ocCUM_PRINC", "Type"),
    NC_("ocCUM_PRINC", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function CUMIPMT #*=-
const TranslateId ocCUM_IPMT_ARY[] =
{
    NC_("ocCUM_IPMT", "Cumulative compounded interest. Calculates the total amount of the interest share in a period for an investment with a constant interest rate."),
    NC_("ocCUM_IPMT", "Rate"),
    NC_("ocCUM_IPMT", "The rate of interest per period."),
    NC_("ocCUM_IPMT", "NPER"),
    NC_("ocCUM_IPMT", "Payment period. The total number of periods in which the annuity (pension) is paid."),
    NC_("ocCUM_IPMT", "PV"),
    NC_("ocCUM_IPMT", "The present value. The present value or the amount the annuity is currently worth."),
    NC_("ocCUM_IPMT", "S"),
    NC_("ocCUM_IPMT", "The start period. The first period to be taken into account. S = 1 denotes the very first period."),
    NC_("ocCUM_IPMT", "E"),
    NC_("ocCUM_IPMT", "The end period. The last period to be taken into account."),
    NC_("ocCUM_IPMT", "Type"),
    NC_("ocCUM_IPMT", "Type = 1 denotes due at the beginning of the period, = 0 at the end.")
};

// -=*# Resource for function SYD #*=-
const TranslateId ocSYD_ARY[] =
{
    NC_("ocSYD", "Calculates the arithmetically declining value of an asset (depreciation) for a specified period."),
    NC_("ocSYD", "Cost"),
    NC_("ocSYD", "Acquisition costs. The initial cost of the asset."),
    NC_("ocSYD", "Salvage"),
    NC_("ocSYD", "Salvage: The remaining value of the asset at the end of its life."),
    NC_("ocSYD", "Life"),
    NC_("ocSYD", "Useful life. The number of periods in the useful life of the asset."),
    NC_("ocSYD", "Period"),
    NC_("ocSYD", "Period. The depreciation period which must have the same time unit as average useful life.")
};

// -=*# Resource for function SLN #*=-
const TranslateId ocSLN_ARY[] =
{
    NC_("ocSLN", "Calculates the linear depreciation per period."),
    NC_("ocSLN", "Cost"),
    NC_("ocSLN", "Acquisition cost. The initial cost of an asset."),
    NC_("ocSLN", "Salvage"),
    NC_("ocSLN", "Salvage: The remaining value of the asset at the end of its life."),
    NC_("ocSLN", "Life"),
    NC_("ocSLN", "Useful life. The number of periods in the useful life of the asset.")
};

// -=*# Resource for function DDB #*=-
const TranslateId ocDDB_ARY[] =
{
    NC_("ocDDB", "Calculates the depreciation of an asset for a specific period using the double-declining balance method or declining balance factor."),
    NC_("ocDDB", "Cost"),
    NC_("ocDDB", "Acquisition costs. The initial cost of the asset."),
    NC_("ocDDB", "Salvage"),
    NC_("ocDDB", "Salvage: The remaining value of the asset at the end of its life."),
    NC_("ocDDB", "Life"),
    NC_("ocDDB", "Useful life. The number of periods in the useful life of the asset."),
    NC_("ocDDB", "Period"),
    NC_("ocDDB", "Period. The depreciation period in the same time unit as the average useful life entry."),
    NC_("ocDDB", "Factor"),
    NC_("ocDDB", "Factor. The factor for balance decline. F = 2 means a double declining balance factor")
};

// -=*# Resource for function DB #*=-
const TranslateId ocDB_ARY[] =
{
    NC_("ocDB", "Returns the real depreciation of an asset for a specified period using the fixed-declining balance method."),
    NC_("ocDB", "Cost"),
    NC_("ocDB", "Acquisition costs: The initial cost of the asset."),
    NC_("ocDB", "Salvage"),
    NC_("ocDB", "Salvage: The remaining value of the asset at the end of its life."),
    NC_("ocDB", "Life"),
    NC_("ocDB", "Useful life. The number of periods in the useful life of the asset."),
    NC_("ocDB", "Period"),
    NC_("ocDB", "Periods: The period for which the depreciation is calculated. The time unit used for period must be the same as that for the useful life."),
    NC_("ocDB", "Month"),
    NC_("ocDB", "Months: The number of months in the first year of depreciation.")
};

// -=*# Resource for function VDB #*=-
const TranslateId ocVBD_ARY[] =
{
    NC_("ocVBD", "Variable declining balance. Returns the declining balance depreciation for a particular period."),
    NC_("ocVBD", "Cost"),
    NC_("ocVBD", "Cost. The initial cost of the asset."),
    NC_("ocVBD", "Salvage"),
    NC_("ocVBD", "Salvage. The salvage value of an asset at the end of its useful life."),
    NC_("ocVBD", "Life"),
    NC_("ocVBD", "Useful life. The number of periods in the useful life of the asset."),
    NC_("ocVBD", "Start"),
    NC_("ocVBD", "Start. The first period for depreciation in the same time unit as the useful life."),
    NC_("ocVBD", "End"),
    NC_("ocVBD", "End. The last period of the depreciation using the same time unit as for the useful life."),
    NC_("ocVBD", "Factor"),
    NC_("ocVBD", "Factor. The factor for the reduction of the depreciation. Factor = 2 denotes double rate depreciation."),
    NC_("ocVBD", "NoSwitch"),
    NC_("ocVBD", "NoSwitch = 0 denotes switch to linear depreciation, NoSwitch = 1 do not switch.")
};

// -=*# Resource for function EFFECT #*=-
const TranslateId ocEFFECT_ARY[] =
{
    NC_("ocEFFECT", "Calculates the annual net interest rate for a nominal interest rate."),
    NC_("ocEFFECT", "NOM"),
    NC_("ocEFFECT", "Nominal interest"),
    NC_("ocEFFECT", "P"),
    NC_("ocEFFECT", "Periods. The number of interest payments per year.")
};

// -=*# Resource for function NOMINAL #*=-
const TranslateId ocNOMINAL_ARY[] =
{
    NC_("ocNOMINAL", "Calculates the yearly nominal interest rate as an effective interest rate."),
    NC_("ocNOMINAL", "Effective rate"),
    NC_("ocNOMINAL", "The effective interest rate"),
    NC_("ocNOMINAL", "NPER"),
    NC_("ocNOMINAL", "Periods. The number of interest payment per year.")
};

// -=*# Resource for function NPV #*=-
const TranslateId ocNPV_ARY[] =
{
    NC_("ocNPV", "Net present value. Calculates the net present value of an investment based on a series of periodic payments and a discount rate."),
    NC_("ocNPV", "Rate"),
    NC_("ocNPV", "The rate of discount for one period."),
    NC_("ocNPV", "Value "),
    NC_("ocNPV", "Value 1, value 2,... are arguments representing payments and income.")
};

// -=*# Resource for function IRR #*=-
const TranslateId ocIRR_ARY[] =
{
    NC_("ocIRR", "Returns the actuarial rate of interest of an investment excluding costs or profits."),
    NC_("ocIRR", "Values"),
    NC_("ocIRR", "An array or reference to cells whose contents correspond to the payments."),
    NC_("ocIRR", "Guess"),
    NC_("ocIRR", "Guess. An estimated value of the rate of return to be used for the iteration calculation.")
};

// -=*# Resource for function MIRR #*=-
const TranslateId ocMIRR_ARY[] =
{
    NC_("ocMIRR", "Returns the modified internal rate of return for a series of investments."),
    NC_("ocMIRR", "Values"),
    NC_("ocMIRR", "An array or reference to cells whose contents correspond to the payments."),
    NC_("ocMIRR", "Investment"),
    NC_("ocMIRR", "Interest rate for investments (the negative values in the array)."),
    NC_("ocMIRR", "Reinvest rate"),
    NC_("ocMIRR", "Interest rate for reinvestments (the positive values in the array).")
};

// -=*# Resource for function ISPMT #*=-
const TranslateId ocISPMT_ARY[] =
{
    NC_("ocISPMT", "Returns the amount of interest for constant amortization rates."),
    NC_("ocISPMT", "Rate"),
    NC_("ocISPMT", "Interest rate for a single amortization rate."),
    NC_("ocISPMT", "Period"),
    NC_("ocISPMT", "Number of amortization periods for the calculation of the interest."),
    NC_("ocISPMT", "Total periods"),
    NC_("ocISPMT", "Sum total of amortization periods."),
    NC_("ocISPMT", "Investment"),
    NC_("ocISPMT", "Amount of the investment.")
};

// -=*# Resource for function PDURATION #*=-
const TranslateId ocPDURATION_ARY[] =
{
    NC_("ocPDURATION", "Duration. Calculates the number of periods required by an investment to attain the desired value."),
    NC_("ocPDURATION", "Rate"),
    NC_("ocPDURATION", "The constant rate of interest."),
    NC_("ocPDURATION", "PV"),
    NC_("ocPDURATION", "The present value. The current value of the investment."),
    NC_("ocPDURATION", "FV"),
    NC_("ocPDURATION", "The future value of the investment.")
};

// -=*# Resource for function RRI #*=-
const TranslateId ocRRI_ARY[] =
{
    NC_("ocRRI", "Interest. Calculates the interest rate which represents the rate of return from an investment."),
    NC_("ocRRI", "Periods"),
    NC_("ocRRI", "The number of periods used in the calculation."),
    NC_("ocRRI", "PV"),
    NC_("ocRRI", "Present value. The current value of the investment."),
    NC_("ocRRI", "FV"),
    NC_("ocRRI", "The future value of the investment.")
};

// -=*# Resource for function ISREF #*=-
const TranslateId ocIS_REF_ARY[] =
{
    NC_("ocIS_REF", "Returns TRUE if value is a reference."),
    NC_("ocIS_REF", "Value"),
    NC_("ocIS_REF", "The value to be tested.")
};

// -=*# Resource for function ISERR #*=-
const TranslateId ocIS_ERR_ARY[] =
{
    NC_("ocIS_ERR", "Returns TRUE if the value is an error value not equal to #N/A."),
    NC_("ocIS_ERR", "Value"),
    NC_("ocIS_ERR", "The value to be tested.")
};

// -=*# Resource for function ISERROR #*=-
const TranslateId ocIS_ERROR_ARY[] =
{
    NC_("ocIS_ERROR", "Returns TRUE if the value is an error value."),
    NC_("ocIS_ERROR", "Value"),
    NC_("ocIS_ERROR", "The value to be tested.")
};

// -=*# Resource for function ISBLANK #*=-
const TranslateId ocIS_EMPTY_ARY[] =
{
    NC_("ocIS_EMPTY", "Returns TRUE if value refers to an empty cell."),
    NC_("ocIS_EMPTY", "Value"),
    NC_("ocIS_EMPTY", "The value to be tested.")
};

// -=*# Resource for function ISLOGICAL #*=-
const TranslateId ocIS_LOGICAL_ARY[] =
{
    NC_("ocIS_LOGICAL", "Returns TRUE if the value carries a logical number format."),
    NC_("ocIS_LOGICAL", "Value"),
    NC_("ocIS_LOGICAL", "The value to be tested.")
};

// -=*# Resource for function ISNA #*=-
const TranslateId ocIS_NV_ARY[] =
{
    NC_("ocIS_NV", "Returns TRUE if value equals #N/A."),
    NC_("ocIS_NV", "Value"),
    NC_("ocIS_NV", "The value to be tested.")
};

// -=*# Resource for function ISNONTEXT #*=-
const TranslateId ocIS_NON_STRING_ARY[] =
{
    NC_("ocIS_NON_STRING", "Returns TRUE if the value is not text."),
    NC_("ocIS_NON_STRING", "Value"),
    NC_("ocIS_NON_STRING", "The value to be tested.")
};

// -=*# Resource for function ISTEXT #*=-
const TranslateId ocIS_STRING_ARY[] =
{
    NC_("ocIS_STRING", "Returns TRUE if value is text."),
    NC_("ocIS_STRING", "Value"),
    NC_("ocIS_STRING", "The value to be tested.")
};

// -=*# Resource for function ISNUMBER #*=-
const TranslateId ocIS_VALUE_ARY[] =
{
    NC_("ocIS_VALUE", "Returns TRUE if value is a number."),
    NC_("ocIS_VALUE", "Value"),
    NC_("ocIS_VALUE", "The value to be tested.")
};

// -=*# Resource for function ISFORMULA #*=-
const TranslateId ocIS_FORMULA_ARY[] =
{
    NC_("ocIS_FORMULA", "Returns TRUE if the cell is a formula cell."),
    NC_("ocIS_FORMULA", "Reference"),
    NC_("ocIS_FORMULA", "The cell to be tested.")
};

// -=*# Resource for function FORMULA #*=-
const TranslateId ocFORMULA_ARY[] =
{
    NC_("ocFORMULA", "Returns the formula of a formula cell."),
    NC_("ocFORMULA", "Reference"),
    NC_("ocFORMULA", "The formula cell.")
};

// -=*# Resource for function N #*=-
const TranslateId ocN_ARY[] =
{
    NC_("ocN", "Converts a value to a number."),
    NC_("ocN", "Value"),
    NC_("ocN", "The value to be interpreted as a number.")
};

// -=*# Resource for function NA #*=-
const TranslateId ocNO_VALUE_ARY[] =
{
    NC_("ocNO_VALUE", "Not available. Returns the error value #N/A.")
};

// -=*# Resource for function TYPE #*=-
const TranslateId ocTYPE_ARY[] =
{
    NC_("ocTYPE", "Returns the data type of a value (1 = number, 2 = text, 4 = Boolean value, 8 = formula, 16 = error value, 64 = array)."),
    NC_("ocTYPE", "Value"),
    NC_("ocTYPE", "The value for which the data type is to be determined.")
};

// -=*# Resource for function CELL #*=-
const TranslateId ocCELL_ARY[] =
{
    NC_("ocCELL", "Determines information about address, formatting or contents of a cell."),
    NC_("ocCELL", "Info type"),
    NC_("ocCELL", "String that specifies the type of information."),
    NC_("ocCELL", "Reference"),
    NC_("ocCELL", "The position of the cell you want to examine.")
};

// -=*# Resource for function CURRENT #*=-
const TranslateId ocCURRENT_ARY[] =
{
    NC_("ocCURRENT", "Calculates the current value of the formula at the present location.")
};

// -=*# Resource for function FALSE #*=-
const TranslateId ocFALSE_ARY[] =
{
    NC_("ocFALSE", "Defines the logical value as FALSE.")
};

// -=*# Resource for function NOT #*=-
const TranslateId ocNOT_ARY[] =
{
    NC_("ocNOT", "Reverses the value of the argument."),
    NC_("ocNOT", "Logical value"),
    NC_("ocNOT", "An expression that can be either TRUE or FALSE.")
};

// -=*# Resource for function TRUE #*=-
const TranslateId ocTRUE_ARY[] =
{
    NC_("ocTRUE", "Returns the logical value TRUE.")
};

// -=*# Resource for function IF #*=-
const TranslateId ocIF_ARY[] =
{
    NC_("ocIF", "Specifies a logical test to be performed."),
    NC_("ocIF", "Test"),
    NC_("ocIF", "Any value or expression which can be either TRUE or FALSE."),
    NC_("ocIF", "Then value"),
    NC_("ocIF", "The result of the function if the logical test returns a TRUE."),
    NC_("ocIF", "Otherwise value"),
    NC_("ocIF", "The result of the function if the logical test returns FALSE.")
};

// -=*# Resource for function IFERROR #*=-
const TranslateId ocIF_ERROR_ARY[] =
{
    NC_("ocIF_ERROR", "Returns value if not an error value, else alternative."),
    NC_("ocIF_ERROR", "Value"),
    NC_("ocIF_ERROR", "The value to be calculated."),
    NC_("ocIF_ERROR", "Alternative value"),
    NC_("ocIF_ERROR", "The alternative to be returned, should value be an error value.")
};

// -=*# Resource for function IFNA #*=-
const TranslateId ocIF_NA_ARY[] =
{
    NC_("ocIF_NA", "Returns value if not a #N/A error, else alternative."),
    NC_("ocIF_NA", "Value"),
    NC_("ocIF_NA", "The value to be calculated."),
    NC_("ocIF_NA", "Alternative value"),
    NC_("ocIF_NA", "The alternative to be returned, should value be a #N/A error.")
};

// -=*# Resource for function OR #*=-
const TranslateId ocOR_ARY[] =
{
    NC_("ocOR", "Returns TRUE if an argument is TRUE."),
    NC_("ocOR", "Logical value "),
    NC_("ocOR", "Logical value 1, logical value 2,... are conditions to be tested and which return either TRUE or FALSE.")
};

// -=*# Resource for function XOR #*=-
const TranslateId ocXOR_ARY[] =
{
    NC_("ocXOR", "Returns TRUE if an odd number of arguments evaluates to TRUE."),
    NC_("ocXOR", "Logical value "),
    NC_("ocXOR", "Logical value 1, logical value 2, ... are conditions to be tested and which return either TRUE or FALSE.")
};

// -=*# Resource for function AND #*=-
const TranslateId ocAND_ARY[] =
{
    NC_("ocAND", "Returns TRUE if all arguments are TRUE."),
    NC_("ocAND", "Logical value "),
    NC_("ocAND", "Logical value 1, logical value 2;...are conditions to be tested and each returns either TRUE or FALSE.")
};

// -=*# Resource for function ABS #*=-
const TranslateId ocABS_ARY[] =
{
    NC_("ocABS", "Absolute value of a number."),
    NC_("ocABS", "Number"),
    NC_("ocABS", "The number whose absolute value is to be returned.")
};

// -=*# Resource for function POWER #*=-
const TranslateId ocPOWER_ARY[] =
{
    NC_("ocPOWER", "Returns a^b, base a raised to the power of exponent b."),
    NC_("ocPOWER", "Base"),
    NC_("ocPOWER", "The base a of the power a^b."),
    NC_("ocPOWER", "Exponent"),
    NC_("ocPOWER", "The exponent b of the power a^b.")
};

// -=*# Resource for function COUNTBLANK #*=-
const TranslateId ocCOUNT_EMPTY_CELLS_ARY[] =
{
    NC_("ocCOUNT_EMPTY_CELLS", "Counts the blank cells in a specified range."),
    NC_("ocCOUNT_EMPTY_CELLS", "Range"),
    NC_("ocCOUNT_EMPTY_CELLS", "The range in which empty cells are to be counted.")
};

// -=*# Resource for function PI #*=-
const TranslateId ocPI_ARY[] =
{
    NC_("ocPI", "Returns the value of the number Pi.")
};

// -=*# Resource for function SUM #*=-
const TranslateId ocSUM_ARY[] =
{
    NC_("ocSUM", "Returns the sum of all arguments."),
    NC_("ocSUM", "Number "),
    NC_("ocSUM", "Number 1, number 2, ... are arguments whose total is to be calculated.")
};

// -=*# Resource for function SUMSQ #*=-
const TranslateId ocSUM_SQ_ARY[] =
{
    NC_("ocSUM_SQ", "Returns the sum of the squares of the arguments."),
    NC_("ocSUM_SQ", "Number "),
    NC_("ocSUM_SQ", "Number 1, number 2,... are arguments for which the sum of the squares is to be calculated.")
};

// -=*# Resource for function PRODUCT #*=-
const TranslateId ocPRODUCT_ARY[] =
{
    NC_("ocPRODUCT", "Multiplies the arguments."),
    NC_("ocPRODUCT", "Number "),
    NC_("ocPRODUCT", "Number 1, number 2, ... are arguments to be multiplied and a result returned.")
};

// -=*# Resource for function SUMIF #*=-
const TranslateId ocSUM_IF_ARY[] =
{
    NC_("ocSUM_IF", "Totals the arguments that meet the condition."),
    NC_("ocSUM_IF", "Range"),
    NC_("ocSUM_IF", "The range to be evaluated by the criteria given."),
    NC_("ocSUM_IF", "Criteria"),
    NC_("ocSUM_IF", "The criteria to be applied to the range."),
    NC_("ocSUM_IF", "Sum range"),
    NC_("ocSUM_IF", "The range from which the values are to be totalled.")
};

// -=*# Resource for function AVERAGEIF #*=-
const TranslateId ocAVERAGE_IF_ARY[] =
{
    NC_("ocAVERAGE_IF", "Averages the arguments that meet the conditions."),
    NC_("ocAVERAGE_IF", "Range"),
    NC_("ocAVERAGE_IF", "The range to be evaluated by the criteria given."),
    NC_("ocAVERAGE_IF", "Criteria"),
    NC_("ocAVERAGE_IF", "The criteria to be applied to the range."),
    NC_("ocAVERAGE_IF", "Average range"),
    NC_("ocAVERAGE_IF", "The range from which the values are to be averaged.")
};

const TranslateId ocSUM_IFS_ARY[] =
{
    NC_("ocSUM_IFS", "Totals the values of cells in a range that meet multiple criteria in multiple ranges."),
    NC_("ocSUM_IFS", "Sum range"),
    NC_("ocSUM_IFS", "The range from which the values are to be totalled."),
    NC_("ocSUM_IFS", "Range "),
    NC_("ocSUM_IFS", "Range 1, range 2,... are the ranges to be evaluated by the criteria given."),
    NC_("ocSUM_IFS", "Criteria "),
    NC_("ocSUM_IFS", "Criteria 1, criteria 2,... are the criteria to be applied to the ranges given.")
};

// -=*# Resource for function AVERAGEIFS #*=-
const TranslateId ocAVERAGE_IFS_ARY[] =
{
    NC_("ocAVERAGE_IFS", "Averages the value of the cells that meet multiple criteria in multiple ranges."),
    NC_("ocAVERAGE_IFS", "Average range"),
    NC_("ocAVERAGE_IFS", "The range from which the values are to be averaged."),
    NC_("ocAVERAGE_IFS", "Range "),
    NC_("ocAVERAGE_IFS", "Range 1, range 2,... are the ranges to be evaluated by the criteria given."),
    NC_("ocAVERAGE_IFS", "Criteria "),
    NC_("ocAVERAGE_IFS", "Criteria 1, criteria 2,... are the criteria to be applied to the ranges given.")
};

// -=*# Resource for function COUNTIFS #*=-
const TranslateId ocCOUNT_IFS_ARY[] =
{
    NC_("ocCOUNT_IFS", "Counts the cells that meet multiple criteria in multiple ranges."),
    NC_("ocCOUNT_IFS", "Range "),
    NC_("ocCOUNT_IFS", "Range 1, range 2,... are the ranges to be evaluated by the criteria given."),
    NC_("ocCOUNT_IFS", "Criteria "),
    NC_("ocCOUNT_IFS", "Criteria 1, criteria 2,... are the criteria to be applied to the ranges given.")
};

// -=*# Resource for function COUNTIF #*=-
const TranslateId ocCOUNT_IF_ARY[] =
{
    NC_("ocCOUNT_IF", "Counts the arguments which meet the set conditions."),
    NC_("ocCOUNT_IF", "Range"),
    NC_("ocCOUNT_IF", "The range of cells to be evaluated by the criteria given."),
    NC_("ocCOUNT_IF", "Criteria"),
    NC_("ocCOUNT_IF", "The criteria to be applied to the range.")
};

// -=*# Resource for function SQRT #*=-
const TranslateId ocSQRT_ARY[] =
{
    NC_("ocSQRT", "Returns the square root of a number."),
    NC_("ocSQRT", "Number"),
    NC_("ocSQRT", "A positive value for which the square root is to be calculated.")
};

// -=*# Resource for function RAND #*=-
const TranslateId ocRANDOM_ARY[] =
{
    NC_("ocRANDOM", "Returns a random number between 0 and 1.")
};

// -=*# Resource for function ISEVEN #*=-
const TranslateId ocIS_EVEN_ARY[] =
{
    NC_("ocIS_EVEN", "Returns TRUE if the value truncated to integer is even."),
    NC_("ocIS_EVEN", "Value"),
    NC_("ocIS_EVEN", "The value to be tested.")
};

// -=*# Resource for function ISODD #*=-
const TranslateId ocIS_ODD_ARY[] =
{
    NC_("ocIS_ODD", "Returns TRUE if the value truncated to integer is odd."),
    NC_("ocIS_ODD", "Value"),
    NC_("ocIS_ODD", "The value to be tested.")
};

// -=*# Resource for function COMBIN #*=-
const TranslateId ocCOMBIN_ARY[] =
{
    NC_("ocCOMBIN", "Calculates the number of combinations for elements without repetition."),
    NC_("ocCOMBIN", "Number 1"),
    NC_("ocCOMBIN", "The total number of elements."),
    NC_("ocCOMBIN", "Number 2"),
    NC_("ocCOMBIN", "The number of elements selected.")
};

// -=*# Resource for function COMBINA #*=-
const TranslateId ocCOMBIN_A_ARY[] =
{
    NC_("ocCOMBIN_A", "Calculates the number of combinations of elements including repetition."),
    NC_("ocCOMBIN_A", "Number 1"),
    NC_("ocCOMBIN_A", "The total number of elements."),
    NC_("ocCOMBIN_A", "Number 2"),
    NC_("ocCOMBIN_A", "The number of elements selected.")
};

// -=*# Resource for function ARCCOS #*=-
const TranslateId ocARC_COS_ARY[] =
{
    NC_("ocARC_COS", "Returns the arccosine of a number."),
    NC_("ocARC_COS", "Number"),
    NC_("ocARC_COS", "A value between -1 and 1 for which the arccosine is to be returned.")
};

// -=*# Resource for function ARCSIN #*=-
const TranslateId ocARC_SIN_ARY[] =
{
    NC_("ocARC_SIN", "Returns the arcsine of a number."),
    NC_("ocARC_SIN", "Number"),
    NC_("ocARC_SIN", "A value between -1 and 1 for which the arcsine is to be returned.")
};

// -=*# Resource for function ARCCOSHYP #*=-
const TranslateId ocARC_COS_HYP_ARY[] =
{
    NC_("ocARC_COS_HYP", "Returns the inverse hyperbolic cosine of a number."),
    NC_("ocARC_COS_HYP", "Number"),
    NC_("ocARC_COS_HYP", "A value greater than or equal to 1 for which the inverse hyperbolic cosine is to be returned.")
};

// -=*# Resource for function ARCSINHYP #*=-
const TranslateId ocARC_SIN_HYP_ARY[] =
{
    NC_("ocARC_SIN_HYP", "Returns the inverse hyperbolic sine of a number."),
    NC_("ocARC_SIN_HYP", "Number"),
    NC_("ocARC_SIN_HYP", "The value for which the inverse hyperbolic sine is to be returned.")
};

// -=*# Resource for function ARCCOT #*=-
const TranslateId ocARC_COT_ARY[] =
{
    NC_("ocARC_COT", "Returns the inverse cotangent of a number."),
    NC_("ocARC_COT", "Number"),
    NC_("ocARC_COT", "The value for which the inverse cotangent is to be returned.")
};

// -=*# Resource for function ARCTAN #*=-
const TranslateId ocARC_TAN_ARY[] =
{
    NC_("ocARC_TAN", "Returns the arctangent of a number."),
    NC_("ocARC_TAN", "Number"),
    NC_("ocARC_TAN", "The value for which the arctangent is to be returned.")
};

// -=*# Resource for function ARCCOTHYP #*=-
const TranslateId ocARC_COT_HYP_ARY[] =
{
    NC_("ocARC_COT_HYP", "Returns the inverse hyperbolic cotangent of a number."),
    NC_("ocARC_COT_HYP", "Number"),
    NC_("ocARC_COT_HYP", "A value smaller than -1 or greater than 1 for which the inverse hyperbolic cotangent is to be returned.")
};

// -=*# Resource for function ARCTANHYP #*=-
const TranslateId ocARC_TAN_HYP_ARY[] =
{
    NC_("ocARC_TAN_HYP", "Returns the inverse hyperbolic tangent of a number."),
    NC_("ocARC_TAN_HYP", "Number"),
    NC_("ocARC_TAN_HYP", "A value between -1 and 1 for which the inverse hyperbolic tangent is to be returned.")
};

// -=*# Resource for function COS #*=-
const TranslateId ocCOS_ARY[] =
{
    NC_("ocCOS", "Returns the cosine of a number."),
    NC_("ocCOS", "Number"),
    NC_("ocCOS", "The angle in the radians for which the cosine is to be returned.")
};

// -=*# Resource for function SIN #*=-
const TranslateId ocSIN_ARY[] =
{
    NC_("ocSIN", "Returns the sine of a number."),
    NC_("ocSIN", "Number"),
    NC_("ocSIN", "The angle in radians for which the sine is to be calculated.")
};

// -=*# Resource for function COT #*=-
const TranslateId ocCOT_ARY[] =
{
    NC_("ocCOT", "Returns the cotangent of a number."),
    NC_("ocCOT", "Number"),
    NC_("ocCOT", "The angle in radians whose cotangent value is to be returned.")
};

// -=*# Resource for function TAN #*=-
const TranslateId ocTAN_ARY[] =
{
    NC_("ocTAN", "Returns the tangent of a number."),
    NC_("ocTAN", "Number"),
    NC_("ocTAN", "The angle in radians for which the tangent is to be calculated.")
};

// -=*# Resource for function COSHYP #*=-
const TranslateId ocCOS_HYP_ARY[] =
{
    NC_("ocCOS_HYP", "Returns the hyperbolic cosine of a number."),
    NC_("ocCOS_HYP", "Number"),
    NC_("ocCOS_HYP", "The value for which the hyperbolic cosine is to be returned.")
};

// -=*# Resource for function SINHYP #*=-
const TranslateId ocSIN_HYP_ARY[] =
{
    NC_("ocSIN_HYP", "Returns the hyperbolic sine of a number."),
    NC_("ocSIN_HYP", "Number"),
    NC_("ocSIN_HYP", "The value for which the hyperbolic sine is to be calculated.")
};

// -=*# Resource for function COTHYP #*=-
const TranslateId ocCOT_HYP_ARY[] =
{
    NC_("ocCOT_HYP", "Returns the hyperbolic cotangent of a number."),
    NC_("ocCOT_HYP", "Number"),
    NC_("ocCOT_HYP", "A value not equal to 0 for which the hyperbolic cotangent is to be returned.")
};

// -=*# Resource for function TANHYP #*=-
const TranslateId ocTAN_HYP_ARY[] =
{
    NC_("ocTAN_HYP", "Returns the hyperbolic tangent of a number."),
    NC_("ocTAN_HYP", "Number"),
    NC_("ocTAN_HYP", "The value for which the hyperbolic tangent is to be calculated.")
};

// -=*# Resource for function ARCTAN2 #*=-
const TranslateId ocARC_TAN_2_ARY[] =
{
    NC_("ocARC_TAN_2", "Returns the arctangent for the specified coordinates."),
    NC_("ocARC_TAN_2", "Number X"),
    NC_("ocARC_TAN_2", "The value for the X coordinate."),
    NC_("ocARC_TAN_2", "Number Y"),
    NC_("ocARC_TAN_2", "The value for the Y coordinate.")
};

// -=*# Resource for function CSC #*=-
const TranslateId ocCOSECANT_ARY[] =
{
    NC_("ocCOSECANT", "Return the cosecant of an angle. CSC(x)=1/SIN(x)"),
    NC_("ocCOSECANT", "Angle"),
    NC_("ocCOSECANT", "The angle in radians for which the cosecant is to be calculated.")
};

// -=*# Resource for function SEC #*=-
const TranslateId ocSECANT_ARY[] =
{
    NC_("ocSECANT", "Return the secant of an angle. SEC(x)=1/COS(x)"),
    NC_("ocSECANT", "Angle"),
    NC_("ocSECANT", "The angle in radians for which the secant is to be calculated.")
};

// -=*# Resource for function CSCH #*=-
const TranslateId ocCOSECANT_HYP_ARY[] =
{
    NC_("ocCOSECANT_HYP", "Return the hyperbolic cosecant of a hyperbolic angle. CSCH(x)=1/SINH(x)"),
    NC_("ocCOSECANT_HYP", "Angle"),
    NC_("ocCOSECANT_HYP", "The hyperbolic angle in radians for which the hyperbolic cosecant is to be calculated.")
};

// -=*# Resource for function SECH #*=-
const TranslateId ocSECANT_HYP_ARY[] =
{
    NC_("ocSECANT_HYP", "Return the hyperbolic secant of a hyperbolic angle. SECH(x)=1/COSH(x)"),
    NC_("ocSECANT_HYP", "Angle"),
    NC_("ocSECANT_HYP", "The hyperbolic angle in radians for which the hyperbolic secant is to be calculated.")
};

// -=*# Resource for function DEG #*=-
const TranslateId ocDEG_ARY[] =
{
    NC_("ocDEG", "Converts a radian to degrees"),
    NC_("ocDEG", "Number"),
    NC_("ocDEG", "The angle in a radian")
};

// -=*# Resource for function RAD #*=-
const TranslateId ocRAD_ARY[] =
{
    NC_("ocRAD", "Converts degrees to radians"),
    NC_("ocRAD", "Number"),
    NC_("ocRAD", "The angle in degrees.")
};

// -=*# Resource for function EXP #*=-
const TranslateId ocEXP_ARY[] =
{
    NC_("ocEXP", "Calculates the exponent for basis e."),
    NC_("ocEXP", "Number"),
    NC_("ocEXP", "The exponent applied to base e.")
};

// -=*# Resource for function LOG #*=-
const TranslateId ocLOG_ARY[] =
{
    NC_("ocLOG", "Calculates the logarithm to any specified base."),
    NC_("ocLOG", "Number"),
    NC_("ocLOG", "A value greater than 0 for which the logarithm is to be calculated."),
    NC_("ocLOG", "Base"),
    NC_("ocLOG", "The base of the logarithm. If omitted, the base is regarded as 10.")
};

// -=*# Resource for function LN #*=-
const TranslateId ocLN_ARY[] =
{
    NC_("ocLN", "Calculates the natural logarithm of a number."),
    NC_("ocLN", "Number"),
    NC_("ocLN", "A value greater than 0 for which the natural logarithm is to be calculated.")
};

// -=*# Resource for function LOG10 #*=-
const TranslateId ocLOG10_ARY[] =
{
    NC_("ocLOG10", "Calculates the base-10 logarithm of a number."),
    NC_("ocLOG10", "Number"),
    NC_("ocLOG10", "A value greater than 0 for which the logarithm is to be calculated.")
};

// -=*# Resource for function FACT #*=-
const TranslateId ocFACT_ARY[] =
{
    NC_("ocFACT", "Calculates the factorial of a number."),
    NC_("ocFACT", "Number"),
    NC_("ocFACT", "The number for which the factorial is to be calculated.")
};

// -=*# Resource for function MOD #*=-
const TranslateId ocMOD_ARY[] =
{
    NC_("ocMOD", "Calculates the remainder of a division."),
    NC_("ocMOD", "Dividend"),
    NC_("ocMOD", "The number to be divided."),
    NC_("ocMOD", "Divisor"),
    NC_("ocMOD", "The number by which the dividend is divided.")
};

// -=*# Resource for function SIGN #*=-
const TranslateId ocPLUS_MINUS_ARY[] =
{
    NC_("ocPLUS_MINUS", "Returns the algebraic sign of a number."),
    NC_("ocPLUS_MINUS", "Number"),
    NC_("ocPLUS_MINUS", "The number for which the algebraic sign is to be determined.")
};

// -=*# Resource for function SUBTOTAL #*=-
const TranslateId ocSUB_TOTAL_ARY[] =
{
    NC_("ocSUB_TOTAL", "Calculates subtotals in a spreadsheet."),
    NC_("ocSUB_TOTAL", "Function"),
    NC_("ocSUB_TOTAL", "Function index. Is an index of the possible functions Total, Max, ..."),
    NC_("ocSUB_TOTAL", "Range"),
    NC_("ocSUB_TOTAL", "The cells of the range which are to be taken into account.")
};

// -=*# Resource for function AGGREGATE #*=-
const TranslateId ocAGGREGATE_ARY[] =
{
    NC_("ocAGGREGATE", "Calculates an aggregate in a spreadsheet."),
    NC_("ocAGGREGATE", "Function"),
    NC_("ocAGGREGATE", "Function index. Is an index of the possible functions Total, Max, ..."),
    NC_("ocAGGREGATE", "Options"),
    NC_("ocAGGREGATE", "Option index. Is an index of the possible ignore options."),
    NC_("ocAGGREGATE", "Reference 1 or array"),
    NC_("ocAGGREGATE", "The cell(s) of the range which are to be taken into account."),
    NC_("ocAGGREGATE", "Reference 2..n or k "),
    NC_("ocAGGREGATE", "The cells of the range which are to be taken into account or mandatory 2nd argument for certain functions.")
};

// -=*# Resource for function INT #*=-
const TranslateId ocINT_ARY[] =
{
    NC_("ocINT", "Rounds a number down to the nearest integer."),
    NC_("ocINT", "Number"),
    NC_("ocINT", "The number to be rounded down.")
};

// -=*# Resource for function TRUNC #*=-
const TranslateId ocTRUNC_ARY[] =
{
    NC_("ocTRUNC", "Truncates the decimal places of a number."),
    NC_("ocTRUNC", "Number"),
    NC_("ocTRUNC", "The number to be truncated."),
    NC_("ocTRUNC", "Count"),
    NC_("ocTRUNC", "The number of places after the decimal point that are not to be truncated.")
};

// -=*# Resource for function ROUND #*=-
const TranslateId ocROUND_ARY[] =
{
    NC_("ocROUND", "Rounds a number to a predefined accuracy."),
    NC_("ocROUND", "Number"),
    NC_("ocROUND", "The number to be rounded."),
    NC_("ocROUND", "Count"),
    NC_("ocROUND", "The number of places to which a number is to be rounded.")
};

// -=*# Resource for function ROUNDUP #*=-
const TranslateId ocROUND_UP_ARY[] =
{
    NC_("ocROUND_UP", "Rounds a number up to the predefined accuracy."),
    NC_("ocROUND_UP", "Number"),
    NC_("ocROUND_UP", "The number to be rounded up."),
    NC_("ocROUND_UP", "Count"),
    NC_("ocROUND_UP", "The number of places to which a number is to be rounded.")
};

// -=*# Resource for function ROUNDDOWN #*=-
const TranslateId ocROUND_DOWN_ARY[] =
{
    NC_("ocROUND_DOWN", "Rounds a number down to a predefined accuracy."),
    NC_("ocROUND_DOWN", "Number"),
    NC_("ocROUND_DOWN", "The number to be rounded down."),
    NC_("ocROUND_DOWN", "Count"),
    NC_("ocROUND_DOWN", "The number of places down to which a number is to be rounded.")
};

// -=*# Resource for function EVEN #*=-
const TranslateId ocEVEN_ARY[] =
{
    NC_("ocEVEN", "Rounds a positive number up and negative number down to the nearest even integer."),
    NC_("ocEVEN", "Number"),
    NC_("ocEVEN", "The number to be rounded up.")
};

// -=*# Resource for function ODD #*=-
const TranslateId ocODD_ARY[] =
{
    NC_("ocODD", "Rounds a positive number up and negative number down to the nearest odd integer."),
    NC_("ocODD", "Number"),
    NC_("ocODD", "The number to be rounded up.")
};

// -=*# Resource for function CEILING.XCL #*=-
const TranslateId ocCEIL_MS_ARY[] =
{
    NC_("ocCEIL_MS", "Rounds a number away from zero to the nearest multiple of significance.\nThis function exists for interoperability with Microsoft Excel 2007 or older versions."),
    NC_("ocCEIL_MS", "Number"),
    NC_("ocCEIL_MS", "The number to be rounded up."),
    NC_("ocCEIL_MS", "Significance"),
    NC_("ocCEIL_MS", "The number to whose multiple the value is rounded.")
};

// -=*# Resource for function CEILING.PRECISE #*=-
const TranslateId ocCEIL_PRECISE_ARY[] =
{
    NC_("ocCEIL_PRECISE", "Rounds a number up to the nearest multiple of significance, regardless of sign of significance."),
    NC_("ocCEIL_PRECISE", "Number"),
    NC_("ocCEIL_PRECISE", "The number to be rounded up."),
    NC_("ocCEIL_PRECISE", "Significance"),
    NC_("ocCEIL_PRECISE", "The number to whose multiple the value is rounded.")
};

// -=*# Resource for function ISO.CEILING #*=-
const TranslateId ocCEIL_ISO_ARY[] =
{
    NC_("ocCEIL_ISO", "Rounds a number up to the nearest multiple of significance, regardless of sign of significance."),
    NC_("ocCEIL_ISO", "Number"),
    NC_("ocCEIL_ISO", "The number to be rounded up."),
    NC_("ocCEIL_ISO", "Significance"),
    NC_("ocCEIL_ISO", "The number to whose multiple the value is rounded.")
};

// -=*# Resource for function CEILING #*=-
const TranslateId ocCEIL_ARY[] =
{
    NC_("ocCEIL", "Rounds a number up to the nearest multiple of significance."),
    NC_("ocCEIL", "Number"),
    NC_("ocCEIL", "The number to be rounded up."),
    NC_("ocCEIL", "Significance"),
    NC_("ocCEIL", "If given the number to whose multiple the value is rounded, else -1 or 1 depending on sign of Number."),
    NC_("ocCEIL", "Mode"),
    NC_("ocCEIL", "If given and not equal to zero then rounded up according to amount when a negative number and significance.")
};

// -=*# Resource for function CEILING.MATH #*=-
const TranslateId ocCEIL_MATH_ARY[] =
{
    NC_("ocCEIL_MATH", "Rounds a number up to the nearest multiple of significance."),
    NC_("ocCEIL_MATH", "Number"),
    NC_("ocCEIL_MATH", "The number to be rounded up."),
    NC_("ocCEIL_MATH", "Significance"),
    NC_("ocCEIL_MATH", "If given the number to whose multiple the value is rounded, else 1."),
    NC_("ocCEIL_MATH", "Mode"),
    NC_("ocCEIL_MATH", "For negative numbers; if given and not equal to zero then rounds away from zero, else rounds towards zero.")
};

// -=*# Resource for function FLOOR #*=-
const TranslateId ocFLOOR_ARY[] =
{
    NC_("ocFLOOR", "Rounds number down to the nearest multiple of significance."),
    NC_("ocFLOOR", "Number"),
    NC_("ocFLOOR", "The number to be rounded down."),
    NC_("ocFLOOR", "Significance"),
    NC_("ocFLOOR", "The number to whose multiple the value is to be rounded down."),
    NC_("ocFLOOR", "Mode"),
    NC_("ocFLOOR", "If given and not equal to zero then rounded towards zero with negative number and significance.")
};

// -=*# Resource for function FLOOR.XCL #*=-
const TranslateId ocFLOOR_MS_ARY[] =
{
    NC_("ocFLOOR_MS", "Rounds number towards zero to the nearest multiple of absolute value of significance.\nThis function exists for interoperability with Microsoft Excel 2007 or older versions."),
    NC_("ocFLOOR_MS", "Number"),
    NC_("ocFLOOR_MS", "The number to be rounded down."),
    NC_("ocFLOOR_MS", "Significance"),
    NC_("ocFLOOR_MS", "The number to whose multiple the value is to be rounded down.")
};

// -=*# Resource for function FLOOR.MATH #*=-
const TranslateId ocFLOOR_MATH_ARY[] =
{
    NC_("ocFLOOR_MATH", "Rounds number down to the nearest multiple of significance, regardless of sign of significance."),
    NC_("ocFLOOR_MATH", "Number"),
    NC_("ocFLOOR_MATH", "The number to be rounded down."),
    NC_("ocFLOOR_MATH", "Significance"),
    NC_("ocFLOOR_MATH", "The number to whose multiple the value is to be rounded down."),
    NC_("ocFLOOR_MATH", "Mode"),
    NC_("ocFLOOR_MATH", "For negative numbers; if given and not equal to or less than zero rounds towards zero.")
};

// -=*# Resource for function FLOOR.PRECISE #*=-
const TranslateId ocFLOOR_PRECISE_ARY[] =
{
    NC_("ocFLOOR_PRECISE", "Rounds number down (towards -∞) to the nearest multiple of significance."),
    NC_("ocFLOOR_PRECISE", "Number"),
    NC_("ocFLOOR_PRECISE", "The number to be rounded down."),
    NC_("ocFLOOR_PRECISE", "Significance"),
    NC_("ocFLOOR_PRECISE", "The number to whose multiple the value is to be rounded down. Sign has no meaning.")
};

// -=*# Resource for function GCD #*=-
const TranslateId ocGCD_ARY[] =
{
    NC_("ocGCD", "Greatest Common Divisor"),
    NC_("ocGCD", "Integer "),
    NC_("ocGCD", "Integer 1; integer 2,... are integers for which the greatest common divisor is to be calculated.")
};

// -=*# Resource for function LCM #*=-
const TranslateId ocLCM_ARY[] =
{
    NC_("ocLCM", "Lowest common multiple"),
    NC_("ocLCM", "Integer "),
    NC_("ocLCM", "Integer 1; integer 2,... are integers whose smallest common multiple is to be calculated.")
};

// -=*# Resource for function TRANSPOSE #*=-
const TranslateId ocMAT_TRANS_ARY[] =
{
    NC_("ocMAT_TRANS", "Array transposition. Exchanges the rows and columns of an array."),
    NC_("ocMAT_TRANS", "Array"),
    NC_("ocMAT_TRANS", "The array in which the rows and columns have been transposed.")
};

// -=*# Resource for function MMULT #*=-
const TranslateId ocMAT_MULT_ARY[] =
{
    NC_("ocMAT_MULT", "Array multiplication. Returns the product of two arrays."),
    NC_("ocMAT_MULT", "Array 1"),
    NC_("ocMAT_MULT", "The first array for the array product."),
    NC_("ocMAT_MULT", "Array 2"),
    NC_("ocMAT_MULT", "The second array having the same number of rows as the first array has columns.")
};

// -=*# Resource for function MDETERM #*=-
const TranslateId ocMAT_DET_ARY[] =
{
    NC_("ocMAT_DET", "Returns the array determinant."),
    NC_("ocMAT_DET", "Array"),
    NC_("ocMAT_DET", "The array for which the determinant is to be determined.")
};

// -=*# Resource for function MINVERSE #*=-
const TranslateId ocMAT_INV_ARY[] =
{
    NC_("ocMAT_INV", "Returns the inverse of an array."),
    NC_("ocMAT_INV", "Array"),
    NC_("ocMAT_INV", "The array to be inverted.")
};

// -=*# Resource for function MSVD #*=-
const TranslateId ocMSVD_ARY[] =
{
    NC_("ocMSVD", "Returns one part of the singular value decomposition of an array."),
    NC_("ocMSVD", "Array"),
    NC_("ocMSVD", "The array to be decomposed."),
    NC_("ocMSVD", "Part"),
    NC_("ocMSVD", "Which part to return: 1 for the left vectors, 2 or omitted for the singular values as a single column, 3 for the right vectors, 4 for the singular values on the diagonal of a square array. A left vector whose singular value is zero is returned as zeros.")
};

// -=*# Resource for function MUNIT #*=-
const TranslateId ocMATRIX_UNIT_ARY[] =
{
    NC_("ocMATRIX_UNIT", "Returns the unitary square array of a certain size."),
    NC_("ocMATRIX_UNIT", "Dimensions"),
    NC_("ocMATRIX_UNIT", "The size of the unitary array.")
};

// -=*# Resources for function BYCOL #*=-
const TranslateId ocBYCOL_ARY[] =
{
    NC_("ocBYCOL", "Applies a function to each column of an array. Returns an single-row array of the same width."),
    NC_("ocBYCOL", "Array"),
    NC_("ocBYCOL", "An array to calculate."),
    NC_("ocBYCOL", "Function"),
    NC_("ocBYCOL", "A function (LAMBDA or otherwise) that will be called on each column of the array.")
};

// -=*# Resources for function BYROW #*=-
const TranslateId ocBYROW_ARY[] =
{
    NC_("ocBYCOL", "Applies a function to each row of an array. Returns an single-column array of the same height."),
    NC_("ocBYCOL", "Array"),
    NC_("ocBYCOL", "An array to calculate."),
    NC_("ocBYCOL", "Function"),
    NC_("ocBYCOL", "A function (LAMBDA or otherwise) that will be called on each row of the array.")
};

// -=*# Resource for function MAKEARRAY #*=-
const TranslateId ocMAKEARRAY_ARY[] =
{
    NC_("ocMAKEARRAY", "Array generation. Creates an array of certain dimensions, with generated contents."),
    NC_("ocMAKEARRAY", "Rows"),
    NC_("ocMAKEARRAY", "The number of rows the new array should have."),
    NC_("ocMAKEARRAY", "Columns"),
    NC_("ocMAKEARRAY", "The number of columns the new array should have."),
    NC_("ocMAKEARRAY", "Generator"),
    NC_("ocMAKEARRAY", "A LAMBDA function that is called with (row, column) values to generate each element of the array.")
};

// -=*# Resources for function MAP #*=-
const TranslateId ocMAP_ARY[] =
{
    NC_("ocMAP", "Applies a function to each cell of one or more arrays."),
    NC_("ocMAP", "Array 1"),
    NC_("ocMAP", "The array that provides the first arguments to the function."),
    NC_("ocMAP", "Function or Array "),
    NC_("ocMAP", "A function (usually built with LAMBDA) that receives the data provided in the array(s). More than one array may be provided; their corresponding cells are all passed to the function. The function must accept that many parameters.")
};

// -=*# Resources for function REDUCE #*=-
const TranslateId ocREDUCE_ARY[] =
{
    NC_("ocREDUCE", "placeholder text"),
};

// -=*# Resources for function SCAN #*=-
const TranslateId ocSCAN_ARY[] =
{
    NC_("ocSCAN", "placeholder text"),
};

// -=*# Resource for function SUMPRODUCT #*=-
const TranslateId ocSUM_PRODUCT_ARY[] =
{
    NC_("ocSUM_PRODUCT", "(Inner products) Returns the sum of the products of array arguments."),
    NC_("ocSUM_PRODUCT", "Array "),
    NC_("ocSUM_PRODUCT", "Array 1, array 2, ... are arrays whose arguments are to be multiplied.")
};

// -=*# Resource for function SUMX2MY2 #*=-
const TranslateId ocSUM_X2MY2_ARY[] =
{
    NC_("ocSUM_X2MY2", "Returns the sum of the difference of squares of two arrays."),
    NC_("ocSUM_X2MY2", "Array X"),
    NC_("ocSUM_X2MY2", "First array where the square of the arguments are totalled."),
    NC_("ocSUM_X2MY2", "Array Y"),
    NC_("ocSUM_X2MY2", "Second array where the square of the arguments is to be subtracted.")
};

// -=*# Resource for function SUMX2PY2 #*=-
const TranslateId ocSUM_X2DY2_ARY[] =
{
    NC_("ocSUM_X2DY2", "Returns the total of the square sum of two arrays."),
    NC_("ocSUM_X2DY2", "Array X"),
    NC_("ocSUM_X2DY2", "First array where the square of the arguments are totalled."),
    NC_("ocSUM_X2DY2", "Array Y"),
    NC_("ocSUM_X2DY2", "Second array where the square of the arguments is to be totalled.")
};

// -=*# Resource for function SUMXMY2 #*=-
const TranslateId ocSUM_XMY2_ARY[] =
{
    NC_("ocSUM_XMY2", "Returns the sum of squares of differences of two arrays."),
    NC_("ocSUM_XMY2", "Array X"),
    NC_("ocSUM_XMY2", "First array for forming argument differences."),
    NC_("ocSUM_XMY2", "Array Y"),
    NC_("ocSUM_XMY2", "Second array for forming the argument differences.")
};

// -=*# Resource for function FREQUENCY #*=-
const TranslateId ocFREQUENCY_ARY[] =
{
    NC_("ocFREQUENCY", "Returns a frequency distribution as a vertical array."),
    NC_("ocFREQUENCY", "Data"),
    NC_("ocFREQUENCY", "The array of the data."),
    NC_("ocFREQUENCY", "Classes"),
    NC_("ocFREQUENCY", "The array for forming classes.")
};

// -=*# Resource for function LINEST #*=-
const TranslateId ocLINEST_ARY[] =
{
    NC_("ocLINEST", "Calculates parameters of the linear regression as an array."),
    NC_("ocLINEST", "Data Y"),
    NC_("ocLINEST", "The Y data array."),
    NC_("ocLINEST", "Data X"),
    NC_("ocLINEST", "The X data array."),
    NC_("ocLINEST", "Linear type"),
    NC_("ocLINEST", "If type = 0 the linears will be calculated through the zero point, or else moved linears."),
    NC_("ocLINEST", "Stats"),
    NC_("ocLINEST", "If parameter = 0 then only the regression coefficient will be calculated, otherwise other values as well.")
};

// -=*# Resource for function LOGEST #*=-
const TranslateId ocLOGEST_ARY[] =
{
    NC_("ocLOGEST", "Calculates the parameters of the exponential regression curve as an array."),
    NC_("ocLOGEST", "Data Y"),
    NC_("ocLOGEST", "The Y data array."),
    NC_("ocLOGEST", "Data X"),
    NC_("ocLOGEST", "The X data array."),
    NC_("ocLOGEST", "Function type"),
    NC_("ocLOGEST", "If type = 0 then the functions will be calculated in the form of y=m^x, or also functions y=b*m^x."),
    NC_("ocLOGEST", "Stats"),
    NC_("ocLOGEST", "If parameter = 0 then only the regression coefficient will be calculated, otherwise other values as well.")
};

// -=*# Resource for function TREND #*=-
const TranslateId ocTREND_ARY[] =
{
    NC_("ocTREND", "Calculates points along a regression line."),
    NC_("ocTREND", "Data Y"),
    NC_("ocTREND", "The Y data array."),
    NC_("ocTREND", "Data X"),
    NC_("ocTREND", "The X data array as the basis for the regression."),
    NC_("ocTREND", "New data X"),
    NC_("ocTREND", "The array of X data for recalculating the values."),
    NC_("ocTREND", "Linear type"),
    NC_("ocTREND", "If type = 0 the linears will be calculated through the zero point, or else moved linears.")
};

// -=*# Resource for function GROWTH #*=-
const TranslateId ocGROWTH_ARY[] =
{
    NC_("ocGROWTH", "Calculates points on the exponential regression function."),
    NC_("ocGROWTH", "Data Y"),
    NC_("ocGROWTH", "The Y data array."),
    NC_("ocGROWTH", "Data X"),
    NC_("ocGROWTH", "The X data array as the basis for the regression."),
    NC_("ocGROWTH", "New data X"),
    NC_("ocGROWTH", "The array of X data for recalculating the values."),
    NC_("ocGROWTH", "Function type"),
    NC_("ocGROWTH", "If type = 0 then the functions will be calculated in the form of y=m^x, or also functions y=b*m^x.")
};

// -=*# Resource for function COUNT #*=-
const TranslateId ocCOUNT_ARY[] =
{
    NC_("ocCOUNT", "Counts how many numbers are in the list of arguments."),
    NC_("ocCOUNT", "Value "),
    NC_("ocCOUNT", "Value 1, value 2, ... are arguments containing different data types but where only numbers are counted.")
};

// -=*# Resource for function COUNTA #*=-
const TranslateId ocCOUNT_2_ARY[] =
{
    NC_("ocCOUNT_2", "Counts how many values are in the list of arguments."),
    NC_("ocCOUNT_2", "Value "),
    NC_("ocCOUNT_2", "Value 1, value 2, ... are arguments representing the values to be counted.")
};

// -=*# Resource for function MAX #*=-
const TranslateId ocMAX_ARY[] =
{
    NC_("ocMAX", "Returns the maximum value in a list of arguments."),
    NC_("ocMAX", "Number "),
    NC_("ocMAX", "Number 1, number 2, ... are numerical arguments for which the largest number is to be determined.")
};

// -=*# Resource for function MAXA #*=-
const TranslateId ocMAX_A_ARY[] =
{
    NC_("ocMAX_A", "Returns the maximum value in a list of arguments. Text is evaluated as Zero."),
    NC_("ocMAX_A", "Value "),
    NC_("ocMAX_A", "Value 1, value 2,    are arguments whose largest value is to be determined.")
};

// -=*# Resource for function MIN #*=-
const TranslateId ocMIN_ARY[] =
{
    NC_("ocMIN", "Returns the minimum value in a list of arguments."),
    NC_("ocMIN", "Number "),
    NC_("ocMIN", "Number 1, number 2, ... are numerical arguments for which the smallest number is to be determined.")
};

// -=*# Resource for function MINA #*=-
const TranslateId ocMIN_A_ARY[] =
{
    NC_("ocMIN_A", "Returns the smallest value in a list of arguments. Text is evaluated as zero."),
    NC_("ocMIN_A", "Value "),
    NC_("ocMIN_A", "Value 1; value 2;... are arguments whose smallest number is to be determined.")
};

// -=*# Resource for function VAR #*=-
const TranslateId ocVAR_ARY[] =
{
    NC_("ocVAR", "Calculates the variance based on a sample."),
    NC_("ocVAR", "Number "),
    NC_("ocVAR", "Number 1, number 2, ... are numerical arguments which portray a sample of a population.")
};

// -=*# Resource for function VAR.S #*=-
const TranslateId ocVAR_S_ARY[] =
{
    NC_("ocVAR_S", "Calculates the variance based on a sample."),
    NC_("ocVAR_S", "Number "),
    NC_("ocVAR_S", "Number 1, number 2, ... are numerical arguments which portray a sample of a population.")
};

// -=*# Resource for function VARA #*=-
const TranslateId ocVAR_A_ARY[] =
{
    NC_("ocVAR_A", "Returns the variance based on a sample. Text is evaluated as zero."),
    NC_("ocVAR_A", "Value "),
    NC_("ocVAR_A", "Value 1; value 2; ... are arguments representing a sample taken from the population.")
};

// -=*# Resource for function VARP #*=-
const TranslateId ocVAR_P_ARY[] =
{
    NC_("ocVAR_P", "Calculates variance based on the entire population."),
    NC_("ocVAR_P", "Number "),
    NC_("ocVAR_P", "Number 1, number 2, ... are numerical arguments which represent a population.")
};

// -=*# Resource for function VAR.P #*=-
const TranslateId ocVAR_P_MS_ARY[] =
{
    NC_("ocVAR_P_MS", "Calculates variance based on the entire population."),
    NC_("ocVAR_P_MS", "Number "),
    NC_("ocVAR_P_MS", "Number 1, number 2, ... are numerical arguments which represent a population.")
};

// -=*# Resource for function VARPA #*=-
const TranslateId ocVAR_P_A_ARY[] =
{
    NC_("ocVAR_P_A", "Returns the variance based on the entire population. Text is evaluated as zero."),
    NC_("ocVAR_P_A", "Value "),
    NC_("ocVAR_P_A", "Value 1; value 2;... are arguments representing a population.")
};

// -=*# Resource for function STDEV #*=-
const TranslateId ocST_DEV_ARY[] =
{
    NC_("ocST_DEV", "Calculates the standard deviation based on a sample."),
    NC_("ocST_DEV", "Number "),
    NC_("ocST_DEV", "Number 1, number 2, ... are numerical arguments which portray a sample of a population.")
};

// -=*# Resource for function STDEV.S #*=-
const TranslateId ocST_DEV_S_ARY[] =
{
    NC_("ocST_DEV_S", "Calculates the standard deviation based on a sample."),
    NC_("ocST_DEV_S", "Number "),
    NC_("ocST_DEV_S", "Number 1, number 2, ... are numerical arguments which portray a sample of a population.")
};

// -=*# Resource for function STDEVA #*=-
const TranslateId ocST_DEV_A_ARY[] =
{
    NC_("ocST_DEV_A", "Returns the standard deviation based on a sample. Text is evaluated as zero."),
    NC_("ocST_DEV_A", "Value "),
    NC_("ocST_DEV_A", "Value 1; value 2; ... are arguments representing a sample taken from the population.")
};

// -=*# Resource for function STDEVP #*=-
const TranslateId ocST_DEV_P_ARY[] =
{
    NC_("ocST_DEV_P", "Calculates the standard deviation based on the entire population."),
    NC_("ocST_DEV_P", "Number "),
    NC_("ocST_DEV_P", "Number 1, number 2, ... are numerical arguments which portray a population.")
};

// -=*# Resource for function STDEV.P #*=-
const TranslateId ocST_DEV_P_MS_ARY[] =
{
    NC_("ocST_DEV_P_MS", "Calculates the standard deviation based on the entire population."),
    NC_("ocST_DEV_P_MS", "Number "),
    NC_("ocST_DEV_P_MS", "Number 1, number 2, ... are numerical arguments which portray a population.")
};

// -=*# Resource for function STDEVPA #*=-
const TranslateId ocST_DEV_P_A_ARY[] =
{
    NC_("ocST_DEV_P_A", "Returns the standard deviation based on the entire population. Text is evaluated as zero."),
    NC_("ocST_DEV_P_A", "Value "),
    NC_("ocST_DEV_P_A", "Value 1; value 2;... are arguments corresponding to a population.")
};

// -=*# Resource for function AVERAGE #*=-
const TranslateId ocAVERAGE_ARY[] =
{
    NC_("ocAVERAGE", "Returns the average of a sample."),
    NC_("ocAVERAGE", "Number "),
    NC_("ocAVERAGE", "Number 1, number 2;...are numeric arguments representing a population sample.")
};

// -=*# Resource for function AVERAGEA #*=-
const TranslateId ocAVERAGE_A_ARY[] =
{
    NC_("ocAVERAGE_A", "Returns the average value for a sample. Text is evaluated as zero."),
    NC_("ocAVERAGE_A", "Value "),
    NC_("ocAVERAGE_A", "Value 1; value 2; ... are arguments representing a sample taken from the population.")
};

// -=*# Resource for function DEVSQ #*=-
const TranslateId ocDEV_SQ_ARY[] =
{
    NC_("ocDEV_SQ", "Returns the sum of squares of deviations from the sample mean value"),
    NC_("ocDEV_SQ", "Number "),
    NC_("ocDEV_SQ", "Number 1, number 2, ... are numerical arguments which portray a sample.")
};

// -=*# Resource for function AVEDEV #*=-
const TranslateId ocAVE_DEV_ARY[] =
{
    NC_("ocAVE_DEV", "Returns the average of the absolute deviations of a sample from the mean."),
    NC_("ocAVE_DEV", "Number "),
    NC_("ocAVE_DEV", "Number 1, number 2;...are numerical arguments representing a sample.")
};

// -=*# Resource for function SKEW #*=-
const TranslateId ocSKEW_ARY[] =
{
    NC_("ocSKEW", "Returns the skewness of a distribution."),
    NC_("ocSKEW", "Number "),
    NC_("ocSKEW", "Number 1, number 2, ... are numerical arguments portraying a sample of the distribution.")
};

// -=*# Resource for function SKEWP #*=-
const TranslateId ocSKEWP_ARY[] =
{
    NC_("ocSKEWP", "Returns the skewness of a distribution using the population of a random variable."),
    NC_("ocSKEWP", "Number "),
    NC_("ocSKEWP", "Number 1, number 2, ... are numerical arguments portraying the population.")
};

// -=*# Resource for function KURT #*=-
const TranslateId ocKURT_ARY[] =
{
    NC_("ocKURT", "Returns the kurtosis of a distribution."),
    NC_("ocKURT", "Number "),
    NC_("ocKURT", "Number 1, number 2, ... are numerical arguments, representing a sample of the distribution.")
};

// -=*# Resource for function GEOMEAN #*=-
const TranslateId ocGEO_MEAN_ARY[] =
{
    NC_("ocGEO_MEAN", "Returns the geometric mean of a sample."),
    NC_("ocGEO_MEAN", "Number "),
    NC_("ocGEO_MEAN", "Number 1, number 2, ... are numerical arguments which portray a sample.")
};

// -=*# Resource for function HARMEAN #*=-
const TranslateId ocHAR_MEAN_ARY[] =
{
    NC_("ocHAR_MEAN", "Returns the harmonic mean of a sample."),
    NC_("ocHAR_MEAN", "Number "),
    NC_("ocHAR_MEAN", "Number 1, number 2, ... are numerical arguments which portray a sample.")
};

// -=*# Resource for function MODE #*=-
const TranslateId ocMODAL_VALUE_ARY[] =
{
    NC_("ocMODAL_VALUE", "Returns the most common value in a sample."),
    NC_("ocMODAL_VALUE", "Number "),
    NC_("ocMODAL_VALUE", "Number 1, number 2, ... are numerical arguments which portray a sample.")
};

// -=*# Resource for function MODE.SNGL #*=-
const TranslateId ocMODAL_VALUE_MS_ARY[] =
{
    NC_("ocMODAL_VALUE_MS", "Returns the most common value in a sample."),
    NC_("ocMODAL_VALUE_MS", "Number "),
    NC_("ocMODAL_VALUE_MS", "Number 1, number 2, ... are numerical arguments which portray a sample.")
};

// -=*# Resource for function MODE.MULT #*=-
const TranslateId ocMODAL_VALUE_MULTI_ARY[] =
{
    NC_("ocMODAL_VALUE_MULTI", "Returns the most common value in a sample."),
    NC_("ocMODAL_VALUE_MULTI", "Number "),
    NC_("ocMODAL_VALUE_MULTI", "Number 1, number 2, ... are 1 to 254 numerical arguments which portray a sample.")
};

// -=*# Resource for function MEDIAN #*=-
const TranslateId ocMEDIAN_ARY[] =
{
    NC_("ocMEDIAN", "Returns the median of a given sample."),
    NC_("ocMEDIAN", "Number "),
    NC_("ocMEDIAN", "Number 1, number 2, ... are numerical arguments which portray a sample.")
};

// -=*# Resource for function PERCENTILE #*=-
const TranslateId ocPERCENTILE_ARY[] =
{
    NC_("ocPERCENTILE", "Returns the alpha percentile of a sample."),
    NC_("ocPERCENTILE", "Data"),
    NC_("ocPERCENTILE", "The array of the data in the sample."),
    NC_("ocPERCENTILE", "Alpha"),
    NC_("ocPERCENTILE", "The percentile value between 0 and 1, inclusive.")
};

// -=*# Resource for function PERCENTILE.EXC #*=-
const TranslateId ocPERCENTILE_EXC_ARY[] =
{
    NC_("ocPERCENTILE_EXC", "Returns the alpha percentile of a sample."),
    NC_("ocPERCENTILE_EXC", "Data"),
    NC_("ocPERCENTILE_EXC", "The array of the data in the sample."),
    NC_("ocPERCENTILE_EXC", "Alpha"),
    NC_("ocPERCENTILE_EXC", "The percentile value, range 0...1, exclusive.")
};

// -=*# Resource for function PERCENTILE.INC #*=-
const TranslateId ocPERCENTILE_INC_ARY[] =
{
    NC_("ocPERCENTILE_INC", "Returns the alpha percentile of a sample."),
    NC_("ocPERCENTILE_INC", "Data"),
    NC_("ocPERCENTILE_INC", "The array of the data in the sample."),
    NC_("ocPERCENTILE_INC", "Alpha"),
    NC_("ocPERCENTILE_INC", "The percentile value, range 0...1, inclusive.")
};

// -=*# Resource for function QUARTILE #*=-
const TranslateId ocQUARTILE_ARY[] =
{
    NC_("ocQUARTILE", "Returns the quartile of a sample."),
    NC_("ocQUARTILE", "Data"),
    NC_("ocQUARTILE", "The array of the data in the sample."),
    NC_("ocQUARTILE", "Type"),
    NC_("ocQUARTILE", "The type of the quartile (0 = MIN, 1 = 25%, 2 = 50%, 3 = 75%, 4 = MAX).")
};

// -=*# Resource for function QUARTILE.EXC #*=-
const TranslateId ocQUARTILE_EXC_ARY[] =
{
    NC_("ocQUARTILE_EXC", "Returns the quartile of a sample."),
    NC_("ocQUARTILE_EXC", "Data"),
    NC_("ocQUARTILE_EXC", "The array of the data in the sample."),
    NC_("ocQUARTILE_EXC", "Type"),
    NC_("ocQUARTILE_EXC", "The type of the quartile (1 = 25%, 2 = 50%, 3 = 75%).")
};

// -=*# Resource for function QUARTILE.INC #*=-
const TranslateId ocQUARTILE_INC_ARY[] =
{
    NC_("ocQUARTILE_INC", "Returns the quartile of a sample."),
    NC_("ocQUARTILE_INC", "Data"),
    NC_("ocQUARTILE_INC", "The array of the data in the sample."),
    NC_("ocQUARTILE_INC", "Type"),
    NC_("ocQUARTILE_INC", "The type of the quartile (0 = MIN, 1 = 25%, 2 = 50%, 3 = 75%, 4 = MAX).")
};

// -=*# Resource for function LARGE #*=-
const TranslateId ocLARGE_ARY[] =
{
    NC_("ocLARGE", "Returns the k-th largest value of a sample."),
    NC_("ocLARGE", "Data"),
    NC_("ocLARGE", "The array of the data in the sample."),
    NC_("ocLARGE", "Rank c"),
    NC_("ocLARGE", "The ranking of the value.")
};

// -=*# Resource for function SMALL #*=-
const TranslateId ocSMALL_ARY[] =
{
    NC_("ocSMALL", "Returns the k-th smallest value of a sample."),
    NC_("ocSMALL", "Data"),
    NC_("ocSMALL", "The array of the data in the sample."),
    NC_("ocSMALL", "Rank c"),
    NC_("ocSMALL", "The ranking of the value.")
};

// -=*# Resource for function PERCENTRANK #*=-
const TranslateId ocPERCENT_RANK_ARY[] =
{
    NC_("ocPERCENT_RANK", "Returns the percentage rank of a value in a sample."),
    NC_("ocPERCENT_RANK", "Data"),
    NC_("ocPERCENT_RANK", "The array of the data in the sample."),
    NC_("ocPERCENT_RANK", "Value"),
    NC_("ocPERCENT_RANK", "The value for which percentage ranking is to be determined."),
    NC_("ocPERCENT_RANK", "Significance"),
    NC_("ocPERCENT_RANK", "The number of significant digits for the returned percentage: if omitted, a value of 3 is used.")
};

// -=*# Resource for function PERCENTRANK.EXC #*=-
const TranslateId ocPERCENT_RANK_EXC_ARY[] =
{
    NC_("ocPERCENT_RANK_EXC", "Returns the percentage rank (0..1, exclusive) of a value in a sample."),
    NC_("ocPERCENT_RANK_EXC", "Data"),
    NC_("ocPERCENT_RANK_EXC", "The array of the data in the sample."),
    NC_("ocPERCENT_RANK_EXC", "Value"),
    NC_("ocPERCENT_RANK_EXC", "The value for which percentage ranking is to be determined."),
    NC_("ocPERCENT_RANK_EXC", "Significance"),
    NC_("ocPERCENT_RANK_EXC", "The number of significant digits for the returned percentage: if omitted, a value of 3 is used.")
};

// -=*# Resource for function PERCENTRANK.INC #*=-
const TranslateId ocPERCENT_RANK_INC_ARY[] =
{
    NC_("ocPERCENT_RANK_INC", "Returns the percentage rank (0..1, inclusive) of a value in a sample."),
    NC_("ocPERCENT_RANK_INC", "Data"),
    NC_("ocPERCENT_RANK_INC", "The array of the data in the sample."),
    NC_("ocPERCENT_RANK_INC", "Value"),
    NC_("ocPERCENT_RANK_INC", "The value for which percentage ranking is to be determined."),
    NC_("ocPERCENT_RANK_INC", "Significance"),
    NC_("ocPERCENT_RANK_INC", "The number of significant digits for the returned percentage: if omitted, a value of 3 is used.")
};

// -=*# Resource for function RANK #*=-
const TranslateId ocRANK_ARY[] =
{
    NC_("ocRANK", "Returns the ranking of a value in a sample."),
    NC_("ocRANK", "Value"),
    NC_("ocRANK", "The value for which the rank is to be determined."),
    NC_("ocRANK", "Data"),
    NC_("ocRANK", "The array of the data in the sample."),
    NC_("ocRANK", "Type"),
    NC_("ocRANK", "Sequence order: 0 or omitted means descending, any other value than 0 means ascending.")
};

// -=*# Resource for function RANK.EQ #*=-
const TranslateId ocRANK_EQ_ARY[] =
{
    NC_("ocRANK_EQ", "Returns the ranking of a value in a sample; if more than one value has the same rank, the top rank of that set of values is returned."),
    NC_("ocRANK_EQ", "Value"),
    NC_("ocRANK_EQ", "The value for which the rank is to be determined."),
    NC_("ocRANK_EQ", "Data"),
    NC_("ocRANK_EQ", "The array of the data in the sample."),
    NC_("ocRANK_EQ", "Type"),
    NC_("ocRANK_EQ", "Sequence order: 0 or omitted means descending, any other value than 0 means ascending.")
};

// -=*# Resource for function RANK.AVG #*=-
const TranslateId ocRANK_AVG_ARY[] =
{
    NC_("ocRANK_AVG", "Returns the ranking of a value in a sample; if more than one value has the same rank, the average rank is returned."),
    NC_("ocRANK_AVG", "Value"),
    NC_("ocRANK_AVG", "The value for which the rank is to be determined."),
    NC_("ocRANK_AVG", "Data"),
    NC_("ocRANK_AVG", "The array of the data in the sample."),
    NC_("ocRANK_AVG", "Type"),
    NC_("ocRANK_AVG", "Sequence order: 0 or omitted means descending, any other value than 0 means ascending.")
};

// -=*# Resource for function TRIMMEAN #*=-
const TranslateId ocTRIM_MEAN_ARY[] =
{
    NC_("ocTRIM_MEAN", "Returns the mean of a sample without including the marginal values."),
    NC_("ocTRIM_MEAN", "Data"),
    NC_("ocTRIM_MEAN", "The array of the data in the sample."),
    NC_("ocTRIM_MEAN", "Alpha"),
    NC_("ocTRIM_MEAN", "The percentage of marginal data that is not to be taken into account.")
};

// -=*# Resource for function PROB #*=-
const TranslateId ocPROB_ARY[] =
{
    NC_("ocPROB", "Returns the discrete probability of an interval."),
    NC_("ocPROB", "Data"),
    NC_("ocPROB", "The sample data array."),
    NC_("ocPROB", "Probability"),
    NC_("ocPROB", "The array of the associated probabilities."),
    NC_("ocPROB", "Start"),
    NC_("ocPROB", "The start of the value interval whose probabilities is to be totalled."),
    NC_("ocPROB", "End"),
    NC_("ocPROB", "The end of the value interval where the probabilities are to be totalled.")
};

// -=*# Resource for function B #*=-
const TranslateId ocB_ARY[] =
{
    NC_("ocB", "Returns the probability of a trial result using binomial distribution."),
    NC_("ocB", "Trials"),
    NC_("ocB", "The number of trials."),
    NC_("ocB", "SP"),
    NC_("ocB", "The individual probability of a trial result."),
    NC_("ocB", "T 1"),
    NC_("ocB", "Lower limit for the number of trials."),
    NC_("ocB", "T 2"),
    NC_("ocB", "Upper limit for the number of trials.")
};

// -=*# Resource for function PHI #*=-
const TranslateId ocPHI_ARY[] =
{
    NC_("ocPHI", "Values of the distribution function for a standard normal distribution."),
    NC_("ocPHI", "Number"),
    NC_("ocPHI", "The value for which the standard normal distribution is to be calculated.")
};

// -=*# Resource for function GAUSS #*=-
const TranslateId ocGAUSS_ARY[] =
{
    NC_("ocGAUSS", "Returns the integral values of the standard normal cumulative distribution."),
    NC_("ocGAUSS", "Number"),
    NC_("ocGAUSS", "The value for which the integral value of the standard normal distribution is to be calculated.")
};

// -=*# Resource for function FISHER #*=-
const TranslateId ocFISHER_ARY[] =
{
    NC_("ocFISHER", "Returns the Fisher transformation."),
    NC_("ocFISHER", "Number"),
    NC_("ocFISHER", "The value to be transformed (-1 < VALUE < 1).")
};

// -=*# Resource for function FISHERINV #*=-
const TranslateId ocFISHER_INV_ARY[] =
{
    NC_("ocFISHER_INV", "Returns the inverse of the Fisher transformation."),
    NC_("ocFISHER_INV", "Number"),
    NC_("ocFISHER_INV", "The value that is to be transformed back.")
};

// -=*# Resource for function BINOMDIST #*=-
const TranslateId ocBINOM_DIST_ARY[] =
{
    NC_("ocBINOM_DIST", "Values of the binomial distribution."),
    NC_("ocBINOM_DIST", "X"),
    NC_("ocBINOM_DIST", "The number of successes in a series of trials."),
    NC_("ocBINOM_DIST", "Trials"),
    NC_("ocBINOM_DIST", "The total number of trials."),
    NC_("ocBINOM_DIST", "SP"),
    NC_("ocBINOM_DIST", "The success probability of a trial."),
    NC_("ocBINOM_DIST", "C"),
    NC_("ocBINOM_DIST", "Cumulated. C=0 calculates the individual probability, C=1 the cumulated probability.")
};

// -=*# Resource for function BINOM.DIST #*=-
const TranslateId ocBINOM_DIST_MS_ARY[] =
{
    NC_("ocBINOM_DIST_MS", "Values of the binomial distribution."),
    NC_("ocBINOM_DIST_MS", "X"),
    NC_("ocBINOM_DIST_MS", "The number of successes in a series of trials."),
    NC_("ocBINOM_DIST_MS", "Trials"),
    NC_("ocBINOM_DIST_MS", "The total number of trials."),
    NC_("ocBINOM_DIST_MS", "SP"),
    NC_("ocBINOM_DIST_MS", "The success probability of a trial."),
    NC_("ocBINOM_DIST_MS", "C"),
    NC_("ocBINOM_DIST_MS", "Cumulated. C=0 calculates the individual probability, C=1 the cumulated probability.")
};

// -=*# Resource for function NEGBINOMDIST #*=-
const TranslateId ocNEG_BINOM_VERT_ARY[] =
{
    NC_("ocNEG_BINOM_VERT", "Values of the negative binomial distribution."),
    NC_("ocNEG_BINOM_VERT", "X"),
    NC_("ocNEG_BINOM_VERT", "The number of failures in the trial range."),
    NC_("ocNEG_BINOM_VERT", "R"),
    NC_("ocNEG_BINOM_VERT", "The number of successes in the trial sequence."),
    NC_("ocNEG_BINOM_VERT", "SP"),
    NC_("ocNEG_BINOM_VERT", "The success probability of a trial.")
};

// -=*# Resource for function NEGBINOM.DIST #*=-
const TranslateId ocNEG_BINOM_DIST_MS_ARY[] =
{
    NC_("ocNEG_BINOM_DIST_MS", "Values of the negative binomial distribution."),
    NC_("ocNEG_BINOM_DIST_MS", "X"),
    NC_("ocNEG_BINOM_DIST_MS", "The number of failures in the trial range."),
    NC_("ocNEG_BINOM_DIST_MS", "R"),
    NC_("ocNEG_BINOM_DIST_MS", "The number of successes in the trial sequence."),
    NC_("ocNEG_BINOM_DIST_MS", "SP"),
    NC_("ocNEG_BINOM_DIST_MS", "The success probability of a trial."),
    NC_("ocNEG_BINOM_DIST_MS", "Cumulative"),
    NC_("ocNEG_BINOM_DIST_MS", "0 or FALSE calculates the probability density function. Any other value or TRUE calculates the cumulative distribution function.")
};

// -=*# Resource for function CRITBINOM #*=-
const TranslateId ocCRIT_BINOM_ARY[] =
{
    NC_("ocCRIT_BINOM", "Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value."),
    NC_("ocCRIT_BINOM", "Trials"),
    NC_("ocCRIT_BINOM", "The total number of trials."),
    NC_("ocCRIT_BINOM", "SP"),
    NC_("ocCRIT_BINOM", "The success probability of a trial."),
    NC_("ocCRIT_BINOM", "Alpha"),
    NC_("ocCRIT_BINOM", "The border probability that is attained or exceeded.")
};

// -=*# Resource for function BINOM.INV #*=-
const TranslateId ocBINOM_INV_ARY[] =
{
    NC_("ocBINOM_INV", "Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value."),
    NC_("ocBINOM_INV", "Trials"),
    NC_("ocBINOM_INV", "The total number of trials."),
    NC_("ocBINOM_INV", "SP"),
    NC_("ocBINOM_INV", "The success probability of a trial."),
    NC_("ocBINOM_INV", "Alpha"),
    NC_("ocBINOM_INV", "The border probability that is attained or exceeded.")
};

// -=*# Resource for function POISSON #*=-
const TranslateId ocPOISSON_DIST_ARY[] =
{
    NC_("ocPOISSON_DIST", "Returns the Poisson distribution."),
    NC_("ocPOISSON_DIST", "Number"),
    NC_("ocPOISSON_DIST", "The value for which the Poisson distribution is to be calculated."),
    NC_("ocPOISSON_DIST", "Mean"),
    NC_("ocPOISSON_DIST", "Mean. The mean value of the Poisson distribution."),
    NC_("ocPOISSON_DIST", "Cumulative"),
    NC_("ocPOISSON_DIST", "0 or FALSE calculates the probability density function. Any other value or TRUE or omitted calculates the cumulative distribution function.")
};

// -=*# Resource for function POISSON.DIST #*=-
const TranslateId ocPOISSON_DIST_MS_ARY[] =
{
    NC_("ocPOISSON_DIST_MS", "Returns the Poisson distribution."),
    NC_("ocPOISSON_DIST_MS", "Number"),
    NC_("ocPOISSON_DIST_MS", "The value for which the Poisson distribution is to be calculated."),
    NC_("ocPOISSON_DIST_MS", "Mean"),
    NC_("ocPOISSON_DIST_MS", "Mean. The mean value of the Poisson distribution."),
    NC_("ocPOISSON_DIST_MS", "Cumulative"),
    NC_("ocPOISSON_DIST_MS", "0 or FALSE calculates the probability density function. Any other value or TRUE or omitted calculates the cumulative distribution function.")
};

// -=*# Resource for function NORMDIST #*=-
const TranslateId ocNORM_DIST_ARY[] =
{
    NC_("ocNORM_DIST", "Values of the normal distribution."),
    NC_("ocNORM_DIST", "Number"),
    NC_("ocNORM_DIST", "The value for which the normal distribution is to be calculated."),
    NC_("ocNORM_DIST", "Mean"),
    NC_("ocNORM_DIST", "The mean value. The mean value of the normal distribution."),
    NC_("ocNORM_DIST", "STDEV"),
    NC_("ocNORM_DIST", "Standard deviation. The standard deviation of the normal distribution."),
    NC_("ocNORM_DIST", "C"),
    NC_("ocNORM_DIST", "0 or FALSE calculates the probability density function. Any other value or TRUE or omitted calculates the cumulative distribution function.")
};

// -=*# Resource for function NORM.DIST #*=-
const TranslateId ocNORM_DIST_MS_ARY[] =
{
    NC_("ocNORM_DIST_MS", "Values of the normal distribution."),
    NC_("ocNORM_DIST_MS", "Number"),
    NC_("ocNORM_DIST_MS", "The value for which the normal distribution is to be calculated."),
    NC_("ocNORM_DIST_MS", "Mean"),
    NC_("ocNORM_DIST_MS", "The mean value. The mean value of the normal distribution."),
    NC_("ocNORM_DIST_MS", "STDEV"),
    NC_("ocNORM_DIST_MS", "Standard deviation. The standard deviation of the normal distribution."),
    NC_("ocNORM_DIST_MS", "C"),
    NC_("ocNORM_DIST_MS", "0 or FALSE calculates the probability density function. Any other value or TRUE calculates the cumulative distribution function.")
};

// -=*# Resource for function NORMINV #*=-
const TranslateId ocNORM_INV_ARY[] =
{
    NC_("ocNORM_INV", "Values of the inverse normal distribution."),
    NC_("ocNORM_INV", "Number"),
    NC_("ocNORM_INV", "The probability value for which the inverse normal distribution is to be calculated."),
    NC_("ocNORM_INV", "Mean"),
    NC_("ocNORM_INV", "The mean value. The mean value of the normal distribution."),
    NC_("ocNORM_INV", "STDEV"),
    NC_("ocNORM_INV", "Standard deviation. The standard deviation of the normal distribution.")
};

// -=*# Resource for function NORM.INV #*=-
const TranslateId ocNORM_INV_MS_ARY[] =
{
    NC_("ocNORM_INV_MS", "Values of the inverse normal distribution."),
    NC_("ocNORM_INV_MS", "Number"),
    NC_("ocNORM_INV_MS", "The probability value for which the inverse normal distribution is to be calculated."),
    NC_("ocNORM_INV_MS", "Mean"),
    NC_("ocNORM_INV_MS", "The mean value. The mean value of the normal distribution."),
    NC_("ocNORM_INV_MS", "STDEV"),
    NC_("ocNORM_INV_MS", "Standard deviation. The standard deviation of the normal distribution.")
};

// -=*# Resource for function NORMSDIST #*=-
const TranslateId ocSTD_NORM_DIST_ARY[] =
{
    NC_("ocSTD_NORM_DIST", "The values of the standard normal cumulative distribution."),
    NC_("ocSTD_NORM_DIST", "Number"),
    NC_("ocSTD_NORM_DIST", "The value for which the standard normal distribution is to be calculated.")
};

// -=*# Resource for function NORM.S.DIST #*=-
const TranslateId ocSTD_NORM_DIST_MS_ARY[] =
{
    NC_("ocSTD_NORM_DIST_MS", "The values of the standard normal distribution."),
    NC_("ocSTD_NORM_DIST_MS", "Number"),
    NC_("ocSTD_NORM_DIST_MS", "The value for which the standard normal distribution is to be calculated."),
    NC_("ocSTD_NORM_DIST_MS", "Cumulative"),
    NC_("ocSTD_NORM_DIST_MS", "0 or FALSE calculates the probability density function. Any other value or TRUE calculates the cumulative distribution function.")
};

// -=*# Resource for function NORMSINV #*=-
const TranslateId ocS_NORM_INV_ARY[] =
{
    NC_("ocS_NORM_INV", "Values of the inverse standard normal distribution."),
    NC_("ocS_NORM_INV", "Number"),
    NC_("ocS_NORM_INV", "The probability value for which the inverse standard normal distribution is to be calculated.")
};

// -=*# Resource for function NORM.S.INV #*=-
const TranslateId ocS_NORM_INV_MS_ARY[] =
{
    NC_("ocS_NORM_INV_MS", "Values of the inverse standard normal distribution."),
    NC_("ocS_NORM_INV_MS", "Number"),
    NC_("ocS_NORM_INV_MS", "The probability value for which the inverse standard normal distribution is to be calculated.")
};

// -=*# Resource for function LOGNORMDIST #*=-
const TranslateId ocLOG_NORM_DIST_ARY[] =
{
    NC_("ocLOG_NORM_DIST", "Values of the log normal distribution."),
    NC_("ocLOG_NORM_DIST", "Number"),
    NC_("ocLOG_NORM_DIST", "The value for which the log normal distribution is to be calculated."),
    NC_("ocLOG_NORM_DIST", "Mean"),
    NC_("ocLOG_NORM_DIST", "The mean value of the log normal distribution. It is set to 0 if omitted."),
    NC_("ocLOG_NORM_DIST", "STDEV"),
    NC_("ocLOG_NORM_DIST", "The standard deviation of the log normal distribution. It is set to 1 if omitted."),
    NC_("ocLOG_NORM_DIST", "Cumulative"),
    NC_("ocLOG_NORM_DIST", "0 or FALSE calculates the probability density function. Any other value or TRUE or omitted calculates the cumulative distribution function.")
};

// -=*# Resource for function LOGNORM.DIST #*=-
const TranslateId ocLOG_NORM_DIST_MS_ARY[] =
{
    NC_("ocLOG_NORM_DIST_MS", "Values of the log normal distribution."),
    NC_("ocLOG_NORM_DIST_MS", "Number"),
    NC_("ocLOG_NORM_DIST_MS", "The value for which the log normal distribution is to be calculated."),
    NC_("ocLOG_NORM_DIST_MS", "Mean"),
    NC_("ocLOG_NORM_DIST_MS", "The mean value of the log normal distribution."),
    NC_("ocLOG_NORM_DIST_MS", "STDEV"),
    NC_("ocLOG_NORM_DIST_MS", "The standard deviation of the log normal distribution."),
    NC_("ocLOG_NORM_DIST_MS", "Cumulative"),
    NC_("ocLOG_NORM_DIST_MS", "0 or FALSE calculates the probability density function. Any other value or TRUE calculates the cumulative distribution function.")
};

// -=*# Resource for function LOGINV #*=-
const TranslateId ocLOG_INV_ARY[] =
{
    NC_("ocLOG_INV", "Values of the inverse of the lognormal distribution."),
    NC_("ocLOG_INV", "Number"),
    NC_("ocLOG_INV", "The probability value for which the inverse log normal distribution is to be calculated."),
    NC_("ocLOG_INV", "Mean"),
    NC_("ocLOG_INV", "Mean value. The mean value of the log normal distribution."),
    NC_("ocLOG_INV", "STDEV"),
    NC_("ocLOG_INV", "Standard deviation. The standard deviation of the log normal distribution.")
};

// -=*# Resource for function LOGNORM.INV #*=-
const TranslateId ocLOG_INV_MS_ARY[] =
{
    NC_("ocLOG_INV_MS", "Values of the inverse of the lognormal distribution."),
    NC_("ocLOG_INV_MS", "Number"),
    NC_("ocLOG_INV_MS", "The probability value for which the inverse log normal distribution is to be calculated."),
    NC_("ocLOG_INV_MS", "Mean"),
    NC_("ocLOG_INV_MS", "Mean value. The mean value of the log normal distribution."),
    NC_("ocLOG_INV_MS", "STDEV"),
    NC_("ocLOG_INV_MS", "Standard deviation. The standard deviation of the log normal distribution.")
};

// -=*# Resource for function EXPONDIST #*=-
const TranslateId ocEXP_DIST_ARY[] =
{
    NC_("ocEXP_DIST", "Values of the exponential distribution."),
    NC_("ocEXP_DIST", "Number"),
    NC_("ocEXP_DIST", "The value to which the exponential distribution is to be calculated."),
    NC_("ocEXP_DIST", "Lambda"),
    NC_("ocEXP_DIST", "The parameters of the exponential distribution."),
    NC_("ocEXP_DIST", "C"),
    NC_("ocEXP_DIST", "Cumulated. C=0 calculates the density function, C=1 the distribution.")
};

// -=*# Resource for function EXPON.DIST #*=-
const TranslateId ocEXP_DIST_MS_ARY[] =
{
    NC_("ocEXP_DIST_MS", "Values of the exponential distribution."),
    NC_("ocEXP_DIST_MS", "Number"),
    NC_("ocEXP_DIST_MS", "The value to which the exponential distribution is to be calculated."),
    NC_("ocEXP_DIST_MS", "Lambda"),
    NC_("ocEXP_DIST_MS", "The parameters of the exponential distribution."),
    NC_("ocEXP_DIST_MS", "C"),
    NC_("ocEXP_DIST_MS", "Cumulated. C=0 calculates the density function, C=1 the distribution.")
};

// -=*# Resource for function GAMMADIST #*=-
const TranslateId ocGAMMA_DIST_ARY[] =
{
    NC_("ocGAMMA_DIST", "Returns the value of the probability density function or the cumulative distribution function for the Gamma distribution."),
    NC_("ocGAMMA_DIST", "Number"),
    NC_("ocGAMMA_DIST", "The value for which the gamma distribution is to be calculated."),
    NC_("ocGAMMA_DIST", "Alpha"),
    NC_("ocGAMMA_DIST", "The Alpha parameter of the Gamma distribution."),
    NC_("ocGAMMA_DIST", "Beta"),
    NC_("ocGAMMA_DIST", "The Beta parameter of the Gamma distribution."),
    NC_("ocGAMMA_DIST", "Cumulative"),
    NC_("ocGAMMA_DIST", "0 or FALSE calculates the probability density function. Any other value or TRUE or omitted calculates the cumulative distribution function.")
};

// -=*# Resource for function GAMMA.DIST #*=-
const TranslateId ocGAMMA_DIST_MS_ARY[] =
{
    NC_("ocGAMMA_DIST_MS", "Returns the value of the probability density function or the cumulative distribution function for the Gamma distribution."),
    NC_("ocGAMMA_DIST_MS", "Number"),
    NC_("ocGAMMA_DIST_MS", "The value for which the gamma distribution is to be calculated."),
    NC_("ocGAMMA_DIST_MS", "Alpha"),
    NC_("ocGAMMA_DIST_MS", "The Alpha parameter of the Gamma distribution."),
    NC_("ocGAMMA_DIST_MS", "Beta"),
    NC_("ocGAMMA_DIST_MS", "The Beta parameter of the Gamma distribution."),
    NC_("ocGAMMA_DIST_MS", "Cumulative"),
    NC_("ocGAMMA_DIST_MS", "0 or FALSE calculates the probability density function. Any other value or TRUE calculates the cumulative distribution function.")
};

// -=*# Resource for function GAMMAINV #*=-
const TranslateId ocGAMMA_INV_ARY[] =
{
    NC_("ocGAMMA_INV", "Values of the inverse gamma distribution."),
    NC_("ocGAMMA_INV", "Number"),
    NC_("ocGAMMA_INV", "The probability value for which the inverse gamma distribution is to be calculated."),
    NC_("ocGAMMA_INV", "Alpha"),
    NC_("ocGAMMA_INV", "The Alpha (shape) parameter of the Gamma distribution."),
    NC_("ocGAMMA_INV", "Beta"),
    NC_("ocGAMMA_INV", "The Beta (scale) parameter of the Gamma distribution.")
};

// -=*# Resource for function GAMMA.INV #*=-
const TranslateId ocGAMMA_INV_MS_ARY[] =
{
    NC_("ocGAMMA_INV_MS", "Values of the inverse gamma distribution."),
    NC_("ocGAMMA_INV_MS", "Number"),
    NC_("ocGAMMA_INV_MS", "The probability value for which the inverse gamma distribution is to be calculated."),
    NC_("ocGAMMA_INV_MS", "Alpha"),
    NC_("ocGAMMA_INV_MS", "The Alpha (shape) parameter of the Gamma distribution."),
    NC_("ocGAMMA_INV_MS", "Beta"),
    NC_("ocGAMMA_INV_MS", "The Beta (scale) parameter of the Gamma distribution.")
};

// -=*# Resource for function GAMMALN #*=-
const TranslateId ocGAMMA_LN_ARY[] =
{
    NC_("ocGAMMA_LN", "Returns the natural logarithm of the gamma function."),
    NC_("ocGAMMA_LN", "Number"),
    NC_("ocGAMMA_LN", "The value for which the natural logarithm of the gamma function is to be calculated.")
};

// -=*# Resource for function GAMMALN.PRECISE #*=-
const TranslateId ocGAMMA_LN_MS_ARY[] =
{
    NC_("ocGAMMA_LN_MS", "Returns the natural logarithm of the gamma function."),
    NC_("ocGAMMA_LN_MS", "Number"),
    NC_("ocGAMMA_LN_MS", "The value for which the natural logarithm of the gamma function is to be calculated.")
};


// -=*# Resource for function GAMMA #*=-
const TranslateId ocGAMMA_ARY[] =
{
    NC_("ocGAMMA", "Returns the value of the Gamma function."),
    NC_("ocGAMMA", "Number"),
    NC_("ocGAMMA", "The value for which the Gamma function is to be calculated.")
};


// -=*# Resource for function BETADIST #*=-
const TranslateId ocBETA_DIST_ARY[] =
{
    NC_("ocBETA_DIST", "Values of the beta distribution."),
    NC_("ocBETA_DIST", "Number"),
    NC_("ocBETA_DIST", "The value for which the beta distribution is to be calculated."),
    NC_("ocBETA_DIST", "Alpha"),
    NC_("ocBETA_DIST", "The Alpha parameter of the Beta distribution."),
    NC_("ocBETA_DIST", "Beta"),
    NC_("ocBETA_DIST", "The Beta parameter of the Beta distribution."),
    NC_("ocBETA_DIST", "Start"),
    NC_("ocBETA_DIST", "The starting value for the value interval of the distribution."),
    NC_("ocBETA_DIST", "End"),
    NC_("ocBETA_DIST", "The final value for the value interval of the distribution."),
    NC_("ocBETA_DIST", "Cumulative"),
    NC_("ocBETA_DIST", "0 or FALSE for probability density function, any other value or TRUE or omitted for cumulative distribution function.")
};

// -=*# Resource for function BETAINV #*=-
const TranslateId ocBETA_INV_ARY[] =
{
    NC_("ocBETA_INV", "Values of the inverse beta distribution."),
    NC_("ocBETA_INV", "Number"),
    NC_("ocBETA_INV", "The probability value for which the inverse beta distribution is to be calculated."),
    NC_("ocBETA_INV", "Alpha"),
    NC_("ocBETA_INV", "The Alpha parameter of the Beta distribution."),
    NC_("ocBETA_INV", "Beta"),
    NC_("ocBETA_INV", "The Beta parameter of the Beta distribution."),
    NC_("ocBETA_INV", "Start"),
    NC_("ocBETA_INV", "The starting value for the value interval of the distribution."),
    NC_("ocBETA_INV", "End"),
    NC_("ocBETA_INV", "The final value for the value interval of the distribution.")
};

// -=*# Resource for function BETA.DIST #*=-
const TranslateId ocBETA_DIST_MS_ARY[] =
{
    NC_("ocBETA_DIST_MS", "Values of the beta distribution."),
    NC_("ocBETA_DIST_MS", "Number"),
    NC_("ocBETA_DIST_MS", "The value for which the beta distribution is to be calculated."),
    NC_("ocBETA_DIST_MS", "Alpha"),
    NC_("ocBETA_DIST_MS", "The Alpha parameter of the Beta distribution."),
    NC_("ocBETA_DIST_MS", "Beta"),
    NC_("ocBETA_DIST_MS", "The Beta parameter of the Beta distribution."),
    NC_("ocBETA_DIST_MS", "Cumulative"),
    NC_("ocBETA_DIST_MS", "0 or FALSE for probability density function, any other value or TRUE or omitted for cumulative distribution function."),
    NC_("ocBETA_DIST_MS", "Start"),
    NC_("ocBETA_DIST_MS", "The starting value for the value interval of the distribution."),
    NC_("ocBETA_DIST_MS", "End"),
    NC_("ocBETA_DIST_MS", "The final value for the value interval of the distribution.")
};

// -=*# Resource for function BETA.INV #*=-
const TranslateId ocBETA_INV_MS_ARY[] =
{
    NC_("ocBETA_INV_MS", "Values of the inverse beta distribution."),
    NC_("ocBETA_INV_MS", "Number"),
    NC_("ocBETA_INV_MS", "The probability value for which the inverse beta distribution is to be calculated."),
    NC_("ocBETA_INV_MS", "Alpha"),
    NC_("ocBETA_INV_MS", "The Alpha parameter of the Beta distribution."),
    NC_("ocBETA_INV_MS", "Beta"),
    NC_("ocBETA_INV_MS", "The Beta parameter of the Beta distribution."),
    NC_("ocBETA_INV_MS", "Start"),
    NC_("ocBETA_INV_MS", "The starting value for the value interval of the distribution."),
    NC_("ocBETA_INV_MS", "End"),
    NC_("ocBETA_INV_MS", "The final value for the value interval of the distribution.")
};

// -=*# Resource for function WEIBULL #*=-
const TranslateId ocWEIBULL_ARY[] =
{
    NC_("ocWEIBULL", "Returns the values of the Weibull distribution."),
    NC_("ocWEIBULL", "Number"),
    NC_("ocWEIBULL", "The value for which the Weibull distribution is to be calculated."),
    NC_("ocWEIBULL", "Alpha"),
    NC_("ocWEIBULL", "The Alpha parameter of the Weibull distribution."),
    NC_("ocWEIBULL", "Beta"),
    NC_("ocWEIBULL", "The Beta parameter of the Weibull distribution."),
    NC_("ocWEIBULL", "C"),
    NC_("ocWEIBULL", "Cumulated. C=0 calculates the density function, C=1 the distribution.")
};

// -=*# Resource for function WEIBULL.DIST #*=-
const TranslateId ocWEIBULL_MS_ARY[] =
{
    NC_("ocWEIBULL_MS", "Returns the values of the Weibull distribution."),
    NC_("ocWEIBULL_MS", "Number"),
    NC_("ocWEIBULL_MS", "The value for which the Weibull distribution is to be calculated."),
    NC_("ocWEIBULL_MS", "Alpha"),
    NC_("ocWEIBULL_MS", "The Alpha parameter of the Weibull distribution."),
    NC_("ocWEIBULL_MS", "Beta"),
    NC_("ocWEIBULL_MS", "The Beta parameter of the Weibull distribution."),
    NC_("ocWEIBULL_MS", "C"),
    NC_("ocWEIBULL_MS", "Cumulated. C=0 calculates the density function, C=1 the distribution.")
};

// -=*# Resource for function HYPGEOMDIST #*=-
const TranslateId ocHYP_GEOM_DIST_ARY[] =
{
    NC_("ocHYP_GEOM_DIST", "Values of the hypergeometric distribution."),
    NC_("ocHYP_GEOM_DIST", "X"),
    NC_("ocHYP_GEOM_DIST", "The number of successes in the sample."),
    NC_("ocHYP_GEOM_DIST", "N sample"),
    NC_("ocHYP_GEOM_DIST", "The size of the sample."),
    NC_("ocHYP_GEOM_DIST", "Successes"),
    NC_("ocHYP_GEOM_DIST", "The number of successes in the population."),
    NC_("ocHYP_GEOM_DIST", "N population"),
    NC_("ocHYP_GEOM_DIST", "The population size."),
    NC_("ocHYP_GEOM_DIST", "Cumulative"),
    NC_("ocHYP_GEOM_DIST", "Cumulated. TRUE calculates the cumulative distribution function, FALSE the probability mass function.")
};

// -=*# Resource for function HYPGEOM.DIST #*=-
const TranslateId ocHYP_GEOM_DIST_MS_ARY[] =
{
    NC_("ocHYP_GEOM_DIST_MS", "Values of the hypergeometric distribution."),
    NC_("ocHYP_GEOM_DIST_MS", "X"),
    NC_("ocHYP_GEOM_DIST_MS", "The number of successes in the sample."),
    NC_("ocHYP_GEOM_DIST_MS", "N sample"),
    NC_("ocHYP_GEOM_DIST_MS", "The size of the sample."),
    NC_("ocHYP_GEOM_DIST_MS", "Successes"),
    NC_("ocHYP_GEOM_DIST_MS", "The number of successes in the population."),
    NC_("ocHYP_GEOM_DIST_MS", "N population"),
    NC_("ocHYP_GEOM_DIST_MS", "The population size."),
    NC_("ocHYP_GEOM_DIST_MS", "Cumulative"),
    NC_("ocHYP_GEOM_DIST_MS", "Cumulated. TRUE calculates the cumulative distribution function, FALSE the probability mass function.")
};

// -=*# Resource for function TDIST #*=-
const TranslateId ocT_DIST_ARY[] =
{
    NC_("ocT_DIST", "Returns the t-distribution."),
    NC_("ocT_DIST", "Number"),
    NC_("ocT_DIST", "The value for which the T distribution is to be calculated."),
    NC_("ocT_DIST", "Degrees freedom"),
    NC_("ocT_DIST", "The degrees of freedom of the T distribution."),
    NC_("ocT_DIST", "Mode"),
    NC_("ocT_DIST", "Mode = 1 calculates the one-tailed test, 2 = two-tailed distribution.")
};

// -=*# Resource for function T.DIST.2T #*=-
const TranslateId ocT_DIST_2T_ARY[] =
{
    NC_("ocT_DIST_2T", "Returns the two-tailed t-distribution."),
    NC_("ocT_DIST_2T", "Number"),
    NC_("ocT_DIST_2T", "The value for which the T distribution is to be calculated."),
    NC_("ocT_DIST_2T", "Degrees freedom"),
    NC_("ocT_DIST_2T", "The degrees of freedom of the T distribution.")
};

// -=*# Resource for function T.DIST #*=-
const TranslateId ocT_DIST_MS_ARY[] =
{
    NC_("ocT_DIST_MS", "Returns the t-distribution."),
    NC_("ocT_DIST_MS", "Number"),
    NC_("ocT_DIST_MS", "The value for which the T distribution is to be calculated."),
    NC_("ocT_DIST_MS", "Degrees freedom"),
    NC_("ocT_DIST_MS", "The degrees of freedom of the T distribution."),
    NC_("ocT_DIST_MS", "Cumulative"),
    NC_("ocT_DIST_MS", "True calculates the cumulative distribution function, false the probability density function.")
};

// -=*# Resource for function T.DIST.RT #*=-
const TranslateId ocT_DIST_RT_ARY[] =
{
    NC_("ocT_DIST_RT", "Returns the right-tailed t-distribution."),
    NC_("ocT_DIST_RT", "Number"),
    NC_("ocT_DIST_RT", "The value for which the T distribution is to be calculated."),
    NC_("ocT_DIST_RT", "Degrees freedom"),
    NC_("ocT_DIST_RT", "The degrees of freedom of the T distribution.")
};

// -=*# Resource for function TINV #*=-
const TranslateId ocT_INV_ARY[] =
{
    NC_("ocT_INV", "Values of the inverse t-distribution."),
    NC_("ocT_INV", "Number"),
    NC_("ocT_INV", "The probability value for which the inverse T distribution is to be calculated."),
    NC_("ocT_INV", "Degrees freedom"),
    NC_("ocT_INV", "The degrees of freedom of the T distribution.")
};

// -=*# Resource for function T.INV #*=-
const TranslateId ocT_INV_MS_ARY[] =
{
    NC_("ocT_INV_MS", "Values of the left-tailed inverse t-distribution."),
    NC_("ocT_INV_MS", "Number"),
    NC_("ocT_INV_MS", "The probability value for which the inverse T distribution is to be calculated."),
    NC_("ocT_INV_MS", "Degrees freedom"),
    NC_("ocT_INV_MS", "The degrees of freedom of the T distribution.")
};

// -=*# Resource for function T.INV.2T #*=-
const TranslateId ocT_INV_2T_ARY[] =
{
    NC_("ocT_INV_2T", "Values of the two-tailed inverse t-distribution."),
    NC_("ocT_INV_2T", "Number"),
    NC_("ocT_INV_2T", "The probability value for which the inverse T distribution is to be calculated."),
    NC_("ocT_INV_2T", "Degrees freedom"),
    NC_("ocT_INV_2T", "The degrees of freedom of the T distribution.")
};

// -=*# Resource for function FDIST #*=-
const TranslateId ocF_DIST_ARY[] =
{
    NC_("ocF_DIST", "Values of the F probability distribution."),
    NC_("ocF_DIST", "Number"),
    NC_("ocF_DIST", "The value for which the F distribution is to be calculated."),
    NC_("ocF_DIST", "Degrees freedom 1"),
    NC_("ocF_DIST", "The degrees of freedom in the numerator of the F distribution."),
    NC_("ocF_DIST", "Degrees freedom 2"),
    NC_("ocF_DIST", "The degrees of freedom in the denominator of the F distribution.")
};

// -=*# Resource for function F.DIST #*=-
const TranslateId ocF_DIST_LT_ARY[] =
{
    NC_("ocF_DIST_LT", "Values of the left tail F probability distribution."),
    NC_("ocF_DIST_LT", "Number"),
    NC_("ocF_DIST_LT", "The value for which the F distribution is to be calculated."),
    NC_("ocF_DIST_LT", "Degrees freedom 1"),
    NC_("ocF_DIST_LT", "The degrees of freedom in the numerator of the F distribution."),
    NC_("ocF_DIST_LT", "Degrees freedom 2"),
    NC_("ocF_DIST_LT", "The degrees of freedom in the denominator of the F distribution."),
    NC_("ocF_DIST_LT", "Cumulative"),
    NC_("ocF_DIST_LT", "Cumulative distribution function (TRUE) or probability density function (FALSE).")
};

// -=*# Resource for function F.DIST.RT #*=-
const TranslateId ocF_DIST_RT_ARY[] =
{
    NC_("ocF_DIST_RT", "Values of the right tail F probability distribution."),
    NC_("ocF_DIST_RT", "Number"),
    NC_("ocF_DIST_RT", "The value for which the F distribution is to be calculated."),
    NC_("ocF_DIST_RT", "Degrees freedom 1"),
    NC_("ocF_DIST_RT", "The degrees of freedom in the numerator of the F distribution."),
    NC_("ocF_DIST_RT", "Degrees freedom 2"),
    NC_("ocF_DIST_RT", "The degrees of freedom in the denominator of the F distribution.")
};

// -=*# Resource for function FINV #*=-
const TranslateId ocF_INV_ARY[] =
{
    NC_("ocF_INV", "Values of the inverse F distribution."),
    NC_("ocF_INV", "Number"),
    NC_("ocF_INV", "The probability value for which the inverse F distribution is to be calculated."),
    NC_("ocF_INV", "Degrees freedom 1"),
    NC_("ocF_INV", "The degrees of freedom in the numerator of the F distribution."),
    NC_("ocF_INV", "Degrees freedom 2"),
    NC_("ocF_INV", "The degrees of freedom in the denominator of the F distribution.")
};

// -=*# Resource for function F.INV #*=-
const TranslateId ocF_INV_LT_ARY[] =
{
    NC_("ocF_INV_LT", "Values of the inverse left tail F distribution."),
    NC_("ocF_INV_LT", "Number"),
    NC_("ocF_INV_LT", "The probability value for which the inverse F distribution is to be calculated."),
    NC_("ocF_INV_LT", "Degrees freedom 1"),
    NC_("ocF_INV_LT", "The degrees of freedom in the numerator of the F distribution."),
    NC_("ocF_INV_LT", "Degrees freedom 2"),
    NC_("ocF_INV_LT", "The degrees of freedom in the denominator of the F distribution.")
};

// -=*# Resource for function F.INV.RT #*=-
const TranslateId ocF_INV_RT_ARY[] =
{
    NC_("ocF_INV_RT", "Values of the inverse right tail F distribution."),
    NC_("ocF_INV_RT", "Number"),
    NC_("ocF_INV_RT", "The probability value for which the inverse F distribution is to be calculated."),
    NC_("ocF_INV_RT", "Degrees freedom 1"),
    NC_("ocF_INV_RT", "The degrees of freedom in the numerator of the F distribution."),
    NC_("ocF_INV_RT", "Degrees freedom 2"),
    NC_("ocF_INV_RT", "The degrees of freedom in the denominator of the F distribution.")
};

// -=*# Resource for function CHIDIST #*=-
const TranslateId ocCHI_DIST_ARY[] =
{
    NC_("ocCHI_DIST", "Returns the right-tail probability of the chi-square distribution."),
    NC_("ocCHI_DIST", "Number"),
    NC_("ocCHI_DIST", "The value for which the chi square distribution is to be calculated."),
    NC_("ocCHI_DIST", "Degrees freedom"),
    NC_("ocCHI_DIST", "The degrees of freedom of the chi square distribution.")
};

// -=*# Resource for function CHISQ.DIST.RT #*=-
const TranslateId ocCHI_DIST_MS_ARY[] =
{
    NC_("ocCHI_DIST_MS", "Returns the right-tail probability of the chi-square distribution."),
    NC_("ocCHI_DIST_MS", "Number"),
    NC_("ocCHI_DIST_MS", "The value for which the chi square distribution is to be calculated."),
    NC_("ocCHI_DIST_MS", "Degrees freedom"),
    NC_("ocCHI_DIST_MS", "The degrees of freedom of the chi square distribution.")
};


// -=*# Resource for function CHISQDIST #*=-
const TranslateId ocCHISQ_DIST_ARY[] =
{
    NC_("ocCHISQ_DIST", "Returns left-tail probability of the cumulative distribution function or values of the probability density function of the chi-square distribution."),
    NC_("ocCHISQ_DIST", "Number"),
    NC_("ocCHISQ_DIST", "The value for which the probability density function or cumulative distribution function is to be calculated."),
    NC_("ocCHISQ_DIST", "Degrees of Freedom"),
    NC_("ocCHISQ_DIST", "The degrees of freedom of the chi-square distribution."),
    NC_("ocCHISQ_DIST", "Cumulative"),
    NC_("ocCHISQ_DIST", "0 or FALSE calculates the probability density function. Any other value or TRUE or omitted calculates the cumulative distribution function.")
};


// -=*# Resource for function CHISQ.DIST #*=-
const TranslateId ocCHISQ_DIST_MS_ARY[] =
{
    NC_("ocCHISQ_DIST_MS", "Returns left-tail probability of the cumulative distribution function or values of the probability density function of the chi-square distribution."),
    NC_("ocCHISQ_DIST_MS", "Number"),
    NC_("ocCHISQ_DIST_MS", "The value for which the probability density function or cumulative distribution function is to be calculated."),
    NC_("ocCHISQ_DIST_MS", "Degrees of Freedom"),
    NC_("ocCHISQ_DIST_MS", "The degrees of freedom of the chi-square distribution."),
    NC_("ocCHISQ_DIST_MS", "Cumulative"),
    NC_("ocCHISQ_DIST_MS", "0 or FALSE calculates the probability density function. Any other value or TRUE calculates the cumulative distribution function.")
};


// -=*# Resource for function CHIINV #*=-
const TranslateId ocCHI_INV_ARY[] =
{
    NC_("ocCHI_INV", "Values of the inverse of CHIDIST(x; DegreesOfFreedom)."),
    NC_("ocCHI_INV", "Number"),
    NC_("ocCHI_INV", "The probability value for which the inverse chi square distribution is to be calculated."),
    NC_("ocCHI_INV", "Degrees freedom"),
    NC_("ocCHI_INV", "The degrees of freedom of the chi square distribution.")
};


// -=*# Resource for function CHISQ.INV.RT #*=-
const TranslateId ocCHI_INV_MS_ARY[] =
{
    NC_("ocCHI_INV_MS", "Values of the inverse of CHIDIST(x; DegreesOfFreedom)."),
    NC_("ocCHI_INV_MS", "Number"),
    NC_("ocCHI_INV_MS", "The probability value for which the inverse chi square distribution is to be calculated."),
    NC_("ocCHI_INV_MS", "Degrees freedom"),
    NC_("ocCHI_INV_MS", "The degrees of freedom of the chi square distribution.")
};


// -=*# Resource for function CHISQINV #*=-
const TranslateId ocCHISQ_INV_ARY[] =
{
    NC_("ocCHISQ_INV", "Values of the inverse of CHISQDIST(x;DegreesOfFreedom;TRUE())."),
    NC_("ocCHISQ_INV", "Probability"),
    NC_("ocCHISQ_INV", "The probability value for which the inverse of the chi square distribution is to be calculated."),
    NC_("ocCHISQ_INV", "Degrees of Freedom"),
    NC_("ocCHISQ_INV", "The degrees of freedom of the chi square distribution.")
};


// -=*# Resource for function CHISQ.INV #*=-
const TranslateId ocCHISQ_INV_MS_ARY[] =
{
    NC_("ocCHISQ_INV_MS", "Values of the inverse of CHISQ.DIST(x;DegreesOfFreedom;TRUE())."),
    NC_("ocCHISQ_INV_MS", "Probability"),
    NC_("ocCHISQ_INV_MS", "The probability value for which the inverse of the chi square distribution is to be calculated."),
    NC_("ocCHISQ_INV_MS", "Degrees of Freedom"),
    NC_("ocCHISQ_INV_MS", "The degrees of freedom of the chi square distribution.")
};


// -=*# Resource for function STANDARDIZE #*=-
const TranslateId ocSTANDARD_ARY[] =
{
    NC_("ocSTANDARD", "Converts a random variable to a normalized value."),
    NC_("ocSTANDARD", "Number"),
    NC_("ocSTANDARD", "The value to be standardized."),
    NC_("ocSTANDARD", "Mean"),
    NC_("ocSTANDARD", "The mean value used for moving."),
    NC_("ocSTANDARD", "STDEV"),
    NC_("ocSTANDARD", "The standard deviation used for scaling.")
};

// -=*# Resource for function PERMUT #*=-
const TranslateId ocPERMUT_ARY[] =
{
    NC_("ocPERMUT", "Returns the number of permutations for a given number of elements without repetition."),
    NC_("ocPERMUT", "Count 1"),
    NC_("ocPERMUT", "The total number of elements."),
    NC_("ocPERMUT", "Count 2"),
    NC_("ocPERMUT", "The selection number taken from the elements.")
};

// -=*# Resource for function PERMUTATIONA #*=-
const TranslateId ocPERMUTATION_A_ARY[] =
{
    NC_("ocPERMUTATION_A", "Returns the number of permutations for a given number of objects (repetition allowed)."),
    NC_("ocPERMUTATION_A", "Count 1"),
    NC_("ocPERMUTATION_A", "The total number of elements."),
    NC_("ocPERMUTATION_A", "Count 2"),
    NC_("ocPERMUTATION_A", "The selection number taken from the elements.")
};

// -=*# Resource for function CONFIDENCE #*=-
const TranslateId ocCONFIDENCE_ARY[] =
{
    NC_("ocCONFIDENCE", "Returns a (1-alpha) confidence interval for a normal distribution."),
    NC_("ocCONFIDENCE", "Alpha"),
    NC_("ocCONFIDENCE", "The level of the confidence interval."),
    NC_("ocCONFIDENCE", "STDEV"),
    NC_("ocCONFIDENCE", "The standard deviation of the population."),
    NC_("ocCONFIDENCE", "Size"),
    NC_("ocCONFIDENCE", "The size of the population.")
};

// -=*# Resource for function CONFIDENCE.NORM #*=-
const TranslateId ocCONFIDENCE_N_ARY[] =
{
    NC_("ocCONFIDENCE_N", "Returns a (1-alpha) confidence interval for a normal distribution."),
    NC_("ocCONFIDENCE_N", "Alpha"),
    NC_("ocCONFIDENCE_N", "The level of the confidence interval."),
    NC_("ocCONFIDENCE_N", "STDEV"),
    NC_("ocCONFIDENCE_N", "The standard deviation of the population."),
    NC_("ocCONFIDENCE_N", "Size"),
    NC_("ocCONFIDENCE_N", "The size of the population.")
};

// -=*# Resource for function CONFIDENCE.T #*=-
const TranslateId ocCONFIDENCE_T_ARY[] =
{
    NC_("ocCONFIDENCE_T", "Returns a (1-alpha) confidence interval for a Student's t distribution."),
    NC_("ocCONFIDENCE_T", "Alpha"),
    NC_("ocCONFIDENCE_T", "The level of the confidence interval."),
    NC_("ocCONFIDENCE_T", "STDEV"),
    NC_("ocCONFIDENCE_T", "The standard deviation of the population."),
    NC_("ocCONFIDENCE_T", "Size"),
    NC_("ocCONFIDENCE_T", "The size of the population.")
};

// -=*# Resource for function ZTEST #*=-
const TranslateId ocZ_TEST_ARY[] =
{
    NC_("ocZ_TEST", "Calculates the probability of observing a z-statistic greater than the one computed based on a sample."),
    NC_("ocZ_TEST", "Data"),
    NC_("ocZ_TEST", "The given sample, drawn from a normally distributed population."),
    NC_("ocZ_TEST", "mu"),
    NC_("ocZ_TEST", "The known mean of the population."),
    NC_("ocZ_TEST", "sigma"),
    NC_("ocZ_TEST", "The known standard deviation of the population. If omitted, the standard deviation of the given sample is used.")
};

// -=*# Resource for function Z.TEST #*=-
const TranslateId ocZ_TEST_MS_ARY[] =
{
    NC_("ocZ_TEST_MS", "Calculates the probability of observing a z-statistic greater than the one computed based on a sample."),
    NC_("ocZ_TEST_MS", "Data"),
    NC_("ocZ_TEST_MS", "The given sample, drawn from a normally distributed population."),
    NC_("ocZ_TEST_MS", "mu"),
    NC_("ocZ_TEST_MS", "The known mean of the population."),
    NC_("ocZ_TEST_MS", "sigma"),
    NC_("ocZ_TEST_MS", "The known standard deviation of the population. If omitted, the standard deviation of the given sample is used.")
};

// -=*# Resource for function CHITEST #*=-
const TranslateId ocCHI_TEST_ARY[] =
{
    NC_("ocCHI_TEST", "Returns the chi square independence test."),
    NC_("ocCHI_TEST", "Data B"),
    NC_("ocCHI_TEST", "The observed data array."),
    NC_("ocCHI_TEST", "Data E"),
    NC_("ocCHI_TEST", "The expected data array.")
};

// -=*# Resource for function CHISQ.TEST #*=-
const TranslateId ocCHI_TEST_MS_ARY[] =
{
    NC_("ocCHI_TEST_MS", "Returns the chi square independence test."),
    NC_("ocCHI_TEST_MS", "Data B"),
    NC_("ocCHI_TEST_MS", "The observed data array."),
    NC_("ocCHI_TEST_MS", "Data E"),
    NC_("ocCHI_TEST_MS", "The expected data array.")
};

// -=*# Resource for function FTEST #*=-
const TranslateId ocF_TEST_ARY[] =
{
    NC_("ocF_TEST", "Calculates the F test."),
    NC_("ocF_TEST", "Data 1"),
    NC_("ocF_TEST", "The first record array."),
    NC_("ocF_TEST", "Data 2"),
    NC_("ocF_TEST", "The second record array.")
};

// -=*# Resource for function F.TEST #*=-
const TranslateId ocF_TEST_MS_ARY[] =
{
    NC_("ocF_TEST_MS", "Calculates the F test."),
    NC_("ocF_TEST_MS", "Data 1"),
    NC_("ocF_TEST_MS", "The first record array."),
    NC_("ocF_TEST_MS", "Data 2"),
    NC_("ocF_TEST_MS", "The second record array.")
};

// -=*# Resource for function TTEST #*=-
const TranslateId ocT_TEST_ARY[] =
{
    NC_("ocT_TEST", "Calculates the t-test."),
    NC_("ocT_TEST", "Data 1"),
    NC_("ocT_TEST", "The first record array."),
    NC_("ocT_TEST", "Data 2"),
    NC_("ocT_TEST", "The second record array."),
    NC_("ocT_TEST", "Mode"),
    NC_("ocT_TEST", "Mode specifies the number of distribution tails to return. 1 = one-tailed, 2 = two-tailed distribution"),
    NC_("ocT_TEST", "Type"),
    NC_("ocT_TEST", "The type of the t-test.")
};

// -=*# Resource for function T.TEST #*=-
const TranslateId ocT_TEST_MS_ARY[] =
{
    NC_("ocT_TEST_MS", "Calculates the t-test."),
    NC_("ocT_TEST_MS", "Data 1"),
    NC_("ocT_TEST_MS", "The first record array."),
    NC_("ocT_TEST_MS", "Data 2"),
    NC_("ocT_TEST_MS", "The second record array."),
    NC_("ocT_TEST_MS", "Mode"),
    NC_("ocT_TEST_MS", "Mode specifies the number of distribution tails to return. 1 = one-tailed, 2 = two-tailed distribution"),
    NC_("ocT_TEST_MS", "Type"),
    NC_("ocT_TEST_MS", "The type of the t-test.")
};

// -=*# Resource for function RSQ #*=-
const TranslateId ocRSQ_ARY[] =
{
    NC_("ocRSQ", "Returns the square of the Pearson product moment correlation coefficient."),
    NC_("ocRSQ", "Data Y"),
    NC_("ocRSQ", "The Y data array."),
    NC_("ocRSQ", "Data X"),
    NC_("ocRSQ", "The X data array.")
};

// -=*# Resource for function INTERCEPT #*=-
const TranslateId ocINTERCEPT_ARY[] =
{
    NC_("ocINTERCEPT", "Returns the intercept of the linear regression line and the Y axis."),
    NC_("ocINTERCEPT", "Data Y"),
    NC_("ocINTERCEPT", "The Y data array."),
    NC_("ocINTERCEPT", "Data X"),
    NC_("ocINTERCEPT", "The X data array.")
};

// -=*# Resource for function SLOPE #*=-
const TranslateId ocSLOPE_ARY[] =
{
    NC_("ocSLOPE", "Returns the slope of the linear regression line."),
    NC_("ocSLOPE", "Data Y"),
    NC_("ocSLOPE", "The Y data array."),
    NC_("ocSLOPE", "Data X"),
    NC_("ocSLOPE", "The X data array.")
};

// -=*# Resource for function STEYX #*=-
const TranslateId ocSTEYX_ARY[] =
{
    NC_("ocSTEYX", "Returns the standard error of the linear regression."),
    NC_("ocSTEYX", "Data Y"),
    NC_("ocSTEYX", "The Y data array."),
    NC_("ocSTEYX", "Data X"),
    NC_("ocSTEYX", "The X data array.")
};

// -=*# Resource for function PEARSON #*=-
const TranslateId ocPEARSON_ARY[] =
{
    NC_("ocPEARSON", "Returns the Pearson product moment correlation coefficient."),
    NC_("ocPEARSON", "Data 1"),
    NC_("ocPEARSON", "The first record array."),
    NC_("ocPEARSON", "Data 2"),
    NC_("ocPEARSON", "The second record array.")
};

// -=*# Resource for function CORREL #*=-
const TranslateId ocCORREL_ARY[] =
{
    NC_("ocCORREL", "Returns the correlation coefficient."),
    NC_("ocCORREL", "Data 1"),
    NC_("ocCORREL", "The first record array."),
    NC_("ocCORREL", "Data 2"),
    NC_("ocCORREL", "The second record array.")
};

// -=*# Resource for function COVAR #*=-
const TranslateId ocCOVAR_ARY[] =
{
    NC_("ocCOVAR", "Calculates the population covariance."),
    NC_("ocCOVAR", "Data 1"),
    NC_("ocCOVAR", "The first record array."),
    NC_("ocCOVAR", "Data 2"),
    NC_("ocCOVAR", "The second record array.")
};

// -=*# Resource for function COVARIANCE.P #*=-
const TranslateId ocCOVARIANCE_P_ARY[] =
{
    NC_("ocCOVARIANCE_P", "Calculates the population covariance."),
    NC_("ocCOVARIANCE_P", "Data 1"),
    NC_("ocCOVARIANCE_P", "The first record array."),
    NC_("ocCOVARIANCE_P", "Data 2"),
    NC_("ocCOVARIANCE_P", "The second record array.")
};

// -=*# Resource for function COVARIANCE.S #*=-
const TranslateId ocCOVARIANCE_S_ARY[] =
{
    NC_("ocCOVARIANCE_S", "Calculates the sample covariance."),
    NC_("ocCOVARIANCE_S", "Data 1"),
    NC_("ocCOVARIANCE_S", "The first record array."),
    NC_("ocCOVARIANCE_S", "Data 2"),
    NC_("ocCOVARIANCE_S", "The second record array.")
};

// -=*# Resource for function FORECAST #*=-
const TranslateId ocFORECAST_ARY[] =
{
    NC_("ocFORECAST", "Returns a value along a linear regression"),
    NC_("ocFORECAST", "Value"),
    NC_("ocFORECAST", "The X value for which the Y value on the regression linear is to be calculated."),
    NC_("ocFORECAST", "Data Y"),
    NC_("ocFORECAST", "The Y data array."),
    NC_("ocFORECAST", "Data X"),
    NC_("ocFORECAST", "The X data array.")
};

// -=*# Resource for function FORECAST.ETS #*=-
const TranslateId ocFORECAST_ETS_ADD_ARY[] =
{
    NC_("ocFORECAST_ETS_ADD", "Calculates future value(s) using additive Exponential Smoothing algorithm."),
    NC_("ocFORECAST_ETS_ADD", "Target"),
    NC_("ocFORECAST_ETS_ADD", "The date (array) for which you want to predict a value."),
    NC_("ocFORECAST_ETS_ADD", "Values"),
    NC_("ocFORECAST_ETS_ADD", "The data array from which you want to forecast."),
    NC_("ocFORECAST_ETS_ADD", "Timeline"),
    NC_("ocFORECAST_ETS_ADD", "The date or numeric array; a consistent step between values is needed."),
    NC_("ocFORECAST_ETS_ADD", "Period length"),
    NC_("ocFORECAST_ETS_ADD", "Number of Samples in Period (default 1); length of the seasonal pattern."),
    NC_("ocFORECAST_ETS_ADD", "Data completion"),
    NC_("ocFORECAST_ETS_ADD", "Data completion (default 1); 0 treats missing points as zero, 1 interpolates."),
    NC_("ocFORECAST_ETS_ADD", "Aggregation"),
    NC_("ocFORECAST_ETS_ADD", "Aggregation (default 1 = AVERAGE); method to be used to aggregate identical (time) values.")
};

// -=*# Resource for function FORECAST.ETS.MULT #*=-
const TranslateId ocFORECAST_ETS_MUL_ARY[] =
{
    NC_("ocFORECAST_ETS_MUL", "Calculates future value(s) using multiplicative Exponential Smoothing algorithm."),
    NC_("ocFORECAST_ETS_MUL", "Target"),
    NC_("ocFORECAST_ETS_MUL", "The date (array) for which you want to predict a value."),
    NC_("ocFORECAST_ETS_MUL", "Values"),
    NC_("ocFORECAST_ETS_MUL", "The data array from which you want to forecast."),
    NC_("ocFORECAST_ETS_MUL", "Timeline"),
    NC_("ocFORECAST_ETS_MUL", "The date or numeric array; a consistent step between values is needed."),
    NC_("ocFORECAST_ETS_MUL", "Period length"),
    NC_("ocFORECAST_ETS_MUL", "Number of Samples in Period (default 1); length of the seasonal pattern."),
    NC_("ocFORECAST_ETS_MUL", "Data completion"),
    NC_("ocFORECAST_ETS_MUL", "Data completion (default 1); 0 treats missing points as zero, 1 interpolates."),
    NC_("ocFORECAST_ETS_MUL", "Aggregation"),
    NC_("ocFORECAST_ETS_MUL", "Aggregation (default 1 = AVERAGE); method to be used to aggregate identical (time) values.")
};

// -=*# Resource for function FORECAST.ETS.CONFINT #*=-
const TranslateId ocFORECAST_ETS_PIA_ARY[] =
{
    NC_("ocFORECAST_ETS_PIA", "Returns a prediction interval at the specified target value(s) for additive Exponential Smoothing method"),
    NC_("ocFORECAST_ETS_PIA", "Target"),
    NC_("ocFORECAST_ETS_PIA", "The date (array) for which you want to predict a value."),
    NC_("ocFORECAST_ETS_PIA", "Values"),
    NC_("ocFORECAST_ETS_PIA", "The data array from which you want to forecast."),
    NC_("ocFORECAST_ETS_PIA", "Timeline"),
    NC_("ocFORECAST_ETS_PIA", "The date or numeric array; a consistent step between values is needed."),
    NC_("ocFORECAST_ETS_PIA", "Confidence level"),
    NC_("ocFORECAST_ETS_PIA", "Confidence level (default 0.95); value 0 to 1 (exclusive) for 0 to 100% calculated prediction interval."),
    NC_("ocFORECAST_ETS_PIA", "Period length"),
    NC_("ocFORECAST_ETS_PIA", "Number of Samples in Period (default 1); length of the seasonal pattern."),
    NC_("ocFORECAST_ETS_PIA", "Data completion"),
    NC_("ocFORECAST_ETS_PIA", "Data completion (default 1); 0 treats missing points as zero, 1 interpolates."),
    NC_("ocFORECAST_ETS_PIA", "Aggregation"),
    NC_("ocFORECAST_ETS_PIA", "Aggregation (default 1 = AVERAGE); method to be used to aggregate identical (time) values.")
};

// -=*# Resource for function FORECAST.ETS.PI.MULT #*=-
const TranslateId ocFORECAST_ETS_PIM_ARY[] =
{
    NC_("ocFORECAST_ETS_PIM", "Returns a prediction interval at the specified target value(s) for multiplicative Exponential Smoothing method"),
    NC_("ocFORECAST_ETS_PIM", "Target"),
    NC_("ocFORECAST_ETS_PIM", "The date (array) for which you want to predict a value."),
    NC_("ocFORECAST_ETS_PIM", "Values"),
    NC_("ocFORECAST_ETS_PIM", "The data array from which you want to forecast."),
    NC_("ocFORECAST_ETS_PIM", "Timeline"),
    NC_("ocFORECAST_ETS_PIM", "The date or numeric array; a consistent step between values is needed."),
    NC_("ocFORECAST_ETS_PIM", "Confidence level"),
    NC_("ocFORECAST_ETS_PIM", "Confidence level (default 0.95); value 0 to 1 (exclusive) for 0 to 100% calculated prediction interval."),
    NC_("ocFORECAST_ETS_PIM", "Period length"),
    NC_("ocFORECAST_ETS_PIM", "Number of Samples in Period (default 1); length of the seasonal pattern."),
    NC_("ocFORECAST_ETS_PIM", "Data completion"),
    NC_("ocFORECAST_ETS_PIM", "Data completion (default 1); 0 treats missing points as zero, 1 interpolates."),
    NC_("ocFORECAST_ETS_PIM", "Aggregation"),
    NC_("ocFORECAST_ETS_PIM", "Aggregation (default 1 = AVERAGE); method to be used to aggregate identical (time) values.")
};

// -=*# Resource for function FORECAST.ETS.SEASONALITY #*=-
const TranslateId ocFORECAST_ETS_SEA_ARY[] =
{
    NC_("ocFORECAST_ETS_SEA", "Calculates the number of samples in period (season) using additive Exponential Triple Smoothing algorithm."),
    NC_("ocFORECAST_ETS_SEA", "Values"),
    NC_("ocFORECAST_ETS_SEA", "The data array from which you want to forecast."),
    NC_("ocFORECAST_ETS_SEA", "Timeline"),
    NC_("ocFORECAST_ETS_SEA", "The date or numeric array; a consistent step between values is needed."),
    NC_("ocFORECAST_ETS_SEA", "Data completion"),
    NC_("ocFORECAST_ETS_SEA", "Data completion (default 1); 0 treats missing points as zero, 1 interpolates."),
    NC_("ocFORECAST_ETS_SEA", "Aggregation"),
    NC_("ocFORECAST_ETS_SEA", "Aggregation (default 1 = AVERAGE); method to be used to aggregate identical (time) values.")
};

// -=*# Resource for function FORECAST.ETS.STAT #*=-
const TranslateId ocFORECAST_ETS_STA_ARY[] =
{
    NC_("ocFORECAST_ETS_STA", "Returns statistical value(s) using additive Exponential Smoothing algorithm."),
    NC_("ocFORECAST_ETS_STA", "Values"),
    NC_("ocFORECAST_ETS_STA", "The data array from which you want to forecast."),
    NC_("ocFORECAST_ETS_STA", "Timeline"),
    NC_("ocFORECAST_ETS_STA", "The date or numeric array; a consistent step between values is needed."),
    NC_("ocFORECAST_ETS_STA", "Statistic type"),
    NC_("ocFORECAST_ETS_STA", "Value (1-9) or array of values, indicating which statistic will be returned for the calculated forecast"),
    NC_("ocFORECAST_ETS_STA", "Period length"),
    NC_("ocFORECAST_ETS_STA", "Number of Samples in Period (default 1); length of the seasonal pattern."),
    NC_("ocFORECAST_ETS_STA", "Data completion"),
    NC_("ocFORECAST_ETS_STA", "Data completion (default 1); 0 treats missing points as zero, 1 interpolates."),
    NC_("ocFORECAST_ETS_STA", "Aggregation"),
    NC_("ocFORECAST_ETS_STA", "Aggregation (default 1 = AVERAGE); method to be used to aggregate identical (time) values.")
};

// -=*# Resource for function FORECAST.ETS.STAT.MULT #*=-
const TranslateId ocFORECAST_ETS_STM_ARY[] =
{
    NC_("ocFORECAST_ETS_STM", "Returns statistical value(s) using multiplicative Exponential Smoothing algorithm."),
    NC_("ocFORECAST_ETS_STM", "Values"),
    NC_("ocFORECAST_ETS_STM", "The data array from which you want to forecast."),
    NC_("ocFORECAST_ETS_STM", "Timeline"),
    NC_("ocFORECAST_ETS_STM", "The date or numeric array; a consistent step between values is needed."),
    NC_("ocFORECAST_ETS_STM", "Statistic type"),
    NC_("ocFORECAST_ETS_STM", "Value (1-9) or array of values, indicating which statistic will be returned for the calculated forecast"),
    NC_("ocFORECAST_ETS_STM", "Period length"),
    NC_("ocFORECAST_ETS_STM", "Number of samples in period (default 1); length of the seasonal pattern."),
    NC_("ocFORECAST_ETS_STM", "Data completion"),
    NC_("ocFORECAST_ETS_STM", "Data completion (default 1); 0 treats missing points as zero, 1 interpolates."),
    NC_("ocFORECAST_ETS_STM", "Aggregation"),
    NC_("ocFORECAST_ETS_STM", "Aggregation (default 1 = AVERAGE); method to be used to aggregate identical (time) values.")
};

// -=*# Resource for function FORECAST.LINEAR #*=-
const TranslateId ocFORECAST_LIN_ARY[] =
{
    NC_("ocFORECAST_LIN", "Returns a value along a linear regression"),
    NC_("ocFORECAST_LIN", "Value"),
    NC_("ocFORECAST_LIN", "The X value for which the Y value on the regression linear is to be calculated."),
    NC_("ocFORECAST_LIN", "Data Y"),
    NC_("ocFORECAST_LIN", "The Y data array."),
    NC_("ocFORECAST_LIN", "Data X"),
    NC_("ocFORECAST_LIN", "The X data array.")
};

// -=*# Resource for function ADDRESS #*=-
const TranslateId ocADDRESS_ARY[] =
{
    NC_("ocADDRESS", "Returns the reference to a cell as text."),
    NC_("ocADDRESS", "Row"),
    NC_("ocADDRESS", "The row number of the cell."),
    NC_("ocADDRESS", "Column"),
    NC_("ocADDRESS", "The column number of the cell."),
    NC_("ocADDRESS", "ABS"),
    NC_("ocADDRESS", "Specifies whether absolute or relative referencing is to be used."),
    NC_("ocADDRESS", "A1"),
    NC_("ocADDRESS", "The reference style: 0 or FALSE means R1C1 style, any other value or omitted means A1 style."),
    NC_("ocADDRESS", "Sheet"),
    NC_("ocADDRESS", "The spreadsheet name of the cell reference.")
};

// -=*# Resource for function AREAS #*=-
const TranslateId ocAREAS_ARY[] =
{
    NC_("ocAREAS", "Returns the number of individual ranges that belong to a (multiple) range."),
    NC_("ocAREAS", "Reference"),
    NC_("ocAREAS", "The reference to a (multiple) range.")
};

// -=*# Resource for function CHOOSE #*=-
const TranslateId ocCHOOSE_ARY[] =
{
    NC_("ocCHOOSE", "Selects a value from a list of up to 30 value arguments."),
    NC_("ocCHOOSE", "Index"),
    NC_("ocCHOOSE", "The index of the value (1..30) selected."),
    NC_("ocCHOOSE", "Value "),
    NC_("ocCHOOSE", "Value 1, value 2,... The list of arguments from which a value is chosen.")
};

// -=*# Resource for function COLUMNS #*=-
const TranslateId ocCOLUMN_ARY[] =
{
    NC_("ocCOLUMN", "Returns the internal column number of a reference."),
    NC_("ocCOLUMN", "Reference"),
    NC_("ocCOLUMN", "The reference to a cell or a range.")
};

// -=*# Resource for function ROW #*=-
const TranslateId ocROW_ARY[] =
{
    NC_("ocROW", "Defines the internal row number of a reference."),
    NC_("ocROW", "Reference"),
    NC_("ocROW", "The reference to a cell or a range.")
};

// -=*# Resource for function SHEET #*=-
const TranslateId ocSHEET_ARY[] =
{
    NC_("ocSHEET", "Returns the internal sheet number of a reference or a string."),
    NC_("ocSHEET", "Reference"),
    NC_("ocSHEET", "The reference to a cell or a range or the character string of a sheet name.")
};

// -=*# Resource for function COLUMNS #*=-
const TranslateId ocCOLUMNS_ARY[] =
{
    NC_("ocCOLUMNS", "Returns the number of columns in an array or reference."),
    NC_("ocCOLUMNS", "Array"),
    NC_("ocCOLUMNS", "The array (reference) for which the number of columns is to be determined.")
};

// -=*# Resource for function ROWS #*=-
const TranslateId ocROWS_ARY[] =
{
    NC_("ocROWS", "Returns the number of rows in a reference or array."),
    NC_("ocROWS", "Array"),
    NC_("ocROWS", "The array (reference) for which the number of rows is to be determined.")
};

// -=*# Resource for function SHEETS #*=-
const TranslateId ocSHEETS_ARY[] =
{
    NC_("ocSHEETS", "Returns the number of sheets of a given reference. If no parameter has been entered, the total number of sheets in the document is returned."),
    NC_("ocSHEETS", "Reference"),
    NC_("ocSHEETS", "The reference to a cell or a range.")
};

// -=*# Resource for function HLOOKUP #*=-
const TranslateId ocH_LOOKUP_ARY[] =
{
    NC_("ocH_LOOKUP", "Horizontal search and reference to the cells located below."),
    NC_("ocH_LOOKUP", "Search criterion"),
    NC_("ocH_LOOKUP", "The value to be found in the first row."),
    NC_("ocH_LOOKUP", "Array"),
    NC_("ocH_LOOKUP", "The array or the range for the reference."),
    NC_("ocH_LOOKUP", "Index"),
    NC_("ocH_LOOKUP", "The row index in the array."),
    NC_("ocH_LOOKUP", "Sorted range lookup"),
    NC_("ocH_LOOKUP", "If the value is TRUE or not given, the search row of the array represents a series of ranges, and must be sorted in ascending order.")
};

// -=*# Resource for function VLOOKUP #*=-
const TranslateId ocV_LOOKUP_ARY[] =
{
    NC_("ocV_LOOKUP", "Vertical search and reference to indicated cells."),
    NC_("ocV_LOOKUP", "Search criterion"),
    NC_("ocV_LOOKUP", "The value to be found in the first column."),
    NC_("ocV_LOOKUP", "Array"),
    NC_("ocV_LOOKUP", "The array or range for referencing."),
    NC_("ocV_LOOKUP", "Index"),
    NC_("ocV_LOOKUP", "Column index number in the array."),
    NC_("ocV_LOOKUP", "Sorted range lookup"),
    NC_("ocV_LOOKUP", "If the value is TRUE or not given, the search column of the array represents a series of ranges, and must be sorted in ascending order.")
};

// -=*# Resource for function XLOOKUP #*=-
const TranslateId ocX_LOOKUP_ARY[] =
{
    NC_("ocX_LOOKUP", "Extended vertical search and reference to indicated cells."),
    NC_("ocX_LOOKUP", "Search criterion"),
    NC_("ocX_LOOKUP", "The value to be found in the first column."),
    NC_("ocX_LOOKUP", "Search Array"),
    NC_("ocX_LOOKUP", "The array or range to search."),
    NC_("ocX_LOOKUP", "Result Array"),
    NC_("ocX_LOOKUP", "The array or range to return."),
    NC_("ocX_LOOKUP", "Result if not found"),
    NC_("ocX_LOOKUP", "If given, return given text, otherwise return #N/A."),
    NC_("ocX_LOOKUP", "Match Mode"),
    NC_("ocX_LOOKUP", "0 - Exact match. Will return #N/A if no match. (default).\n-1 - Exact match or the next smaller item.\n1 - Exact match or the next larger item.\n2 - Wildcard match.\n3 - Regular expression match."),
    NC_("ocX_LOOKUP", "Search Mode"),
    NC_("ocX_LOOKUP", "1 - Search from the first value (default).\n-1 - Search from the last value (reverse).\n2 - Binary search values sorted in ascending order.\n-2 - Binary search values sorted in descending order.")
};

// -=*# Resource for function INDEX #*=-
const TranslateId ocINDEX_ARY[] =
{
    NC_("ocINDEX", "Returns a reference to a cell from a defined range."),
    NC_("ocINDEX", "Reference"),
    NC_("ocINDEX", "The reference to a (multiple) range."),
    NC_("ocINDEX", "Row"),
    NC_("ocINDEX", "The row in the range."),
    NC_("ocINDEX", "Column"),
    NC_("ocINDEX", "The column in the range."),
    NC_("ocINDEX", "Range"),
    NC_("ocINDEX", "The index of the subrange if referring to a multiple range.")
};

// -=*# Resource for function INDIRECT #*=-
const TranslateId ocINDIRECT_ARY[] =
{
    NC_("ocINDIRECT", "Returns the contents of a cell that is referenced in text form."),
    NC_("ocINDIRECT", "Reference"),
    NC_("ocINDIRECT", "The cell whose contents are to be evaluated is to be referenced in text form (e.g. \"A1\")."),
    NC_("ocINDIRECT", "A1"),
    NC_("ocINDIRECT", "The reference style: 0 or FALSE means R1C1 style, any other value or omitted means A1 style.")
};

// -=*# Resource for function LOOKUP #*=-
const TranslateId ocLOOKUP_ARY[] =
{
    NC_("ocLOOKUP", "Determines a value in a vector by comparison to values in another vector."),
    NC_("ocLOOKUP", "Search criterion"),
    NC_("ocLOOKUP", "The value to be used for comparison."),
    NC_("ocLOOKUP", "Search vector"),
    NC_("ocLOOKUP", "The vector (row or column) in which to search."),
    NC_("ocLOOKUP", "Result vector"),
    NC_("ocLOOKUP", "The vector (row or range) from which the value is to be determined.")
};

// -=*# Resource for function MATCH #*=-
const TranslateId ocMATCH_ARY[] =
{
    NC_("ocMATCH", "Defines a position in an array after comparing values."),
    NC_("ocMATCH", "Search criterion"),
    NC_("ocMATCH", "The value to be used for comparison."),
    NC_("ocMATCH", "Lookup array"),
    NC_("ocMATCH", "The array (range) in which the search is made."),
    NC_("ocMATCH", "Type"),
    NC_("ocMATCH", "Type can take the value 1 (first column array ascending), 0 (exact match or wildcard or regular expression match) or -1 (first column array descending) and determines the criteria to be used for comparison purposes.")
};

// -=*# Resource for function XMATCH #*=-
const TranslateId ocX_MATCH_ARY[] =
{
    NC_("ocX_MATCH", "Defines a relative position in an array or range of cells after comparing values."),
    NC_("ocX_MATCH", "Search criterion"),
    NC_("ocX_MATCH", "The value to be used for comparison."),
    NC_("ocX_MATCH", "Search Array"),
    NC_("ocX_MATCH", "The array or range to search."),
    NC_("ocX_MATCH", "Match Mode"),
    NC_("ocX_MATCH", "0 - Exact match. Will return #N/A if no match. (default).\n-1 - Exact match or the next smaller item.\n1 - Exact match or the next larger item.\n2 - Wildcard match.\n3 - Regular expression match."),
    NC_("ocX_MATCH", "Search Mode"),
    NC_("ocX_MATCH", "1 - Search from the first value (default).\n-1 - Search from the last value (reverse).\n2 - Binary search values sorted in ascending order.\n-2 - Binary search values sorted in descending order.")
};

// -=*# Resource for function OFFSET #*=-
const TranslateId ocOFFSET_ARY[] =
{
    NC_("ocOFFSET", "Returns a reference which has been moved in relation to the starting point."),
    NC_("ocOFFSET", "Reference"),
    NC_("ocOFFSET", "The reference (cell) from which to base the movement."),
    NC_("ocOFFSET", "Rows"),
    NC_("ocOFFSET", "The number of rows to be moved either up or down."),
    NC_("ocOFFSET", "Columns"),
    NC_("ocOFFSET", "The number of columns that are to be moved to the left or to the right."),
    NC_("ocOFFSET", "Height"),
    NC_("ocOFFSET", "The number of rows of the moved reference."),
    NC_("ocOFFSET", "Width"),
    NC_("ocOFFSET", "The number of columns in the moved reference.")
};

// -=*# Resource for function ERRORTYPE #*=-
const TranslateId ocERROR_TYPE_ARY[] =
{
    NC_("ocERROR_TYPE", "Returns a number corresponding to an error type"),
    NC_("ocERROR_TYPE", "Reference"),
    NC_("ocERROR_TYPE", "The reference (cell) in which the error occurred.")
};

// -=*# Resource for function ERROR.TYPE #*=-
const TranslateId ocERROR_TYPE_ODF_ARY[] =
{
    NC_("ocERROR_TYPE_ODF", "Returns a number corresponding to one of the error values or #N/A if no error exists"),
    NC_("ocERROR_TYPE_ODF", "Expression"),
    NC_("ocERROR_TYPE_ODF", "The error value whose identifying number you want to find. Can be the actual error value or a reference to a cell that you want to test.")
};

// -=*# Resource for function STYLE #*=-
const TranslateId ocSTYLE_ARY[] =
{
    NC_("ocSTYLE", "Applies a Style to the formula cell."),
    NC_("ocSTYLE", "Style"),
    NC_("ocSTYLE", "The name of the Style to be applied."),
    NC_("ocSTYLE", "Time"),
    NC_("ocSTYLE", "The time (in seconds) that the Style is to remain valid."),
    NC_("ocSTYLE", "Style 2"),
    NC_("ocSTYLE", "The style to be applied after time expires.")
};

// -=*# Resource for function DDE #*=-
const TranslateId ocDDE_ARY[] =
{
    NC_("ocDDE", "Result of a DDE link."),
    NC_("ocDDE", "Server"),
    NC_("ocDDE", "The name of the server application."),
    NC_("ocDDE", "Topic/file"),
    NC_("ocDDE", "The topic or name of the file."),
    NC_("ocDDE", "Item/range"),
    NC_("ocDDE", "The item or range from which data is to be taken."),
    NC_("ocDDE", "Mode"),
    NC_("ocDDE", "Defines how data is to be converted to numbers.")
};

// -=*# Resource for function HYPERLINK #*=-
const TranslateId ocHYPERLINK_ARY[] =
{
    NC_("ocHYPERLINK", "Construct a Hyperlink."),
    NC_("ocHYPERLINK", "URL"),
    NC_("ocHYPERLINK", "The clickable URL."),
    NC_("ocHYPERLINK", "Cell text"),
    NC_("ocHYPERLINK", "The cell text to be displayed.")
};

// -=*# Resource for function GETPIVOTDATA #*=-
const TranslateId ocGET_PIVOT_DATA_ARY[] =
{
    NC_("ocGET_PIVOT_DATA", "Extracts value(s) from a pivot table."),
    NC_("ocGET_PIVOT_DATA", "Data field"),
    NC_("ocGET_PIVOT_DATA", "The name of the pivot table field to extract."),
    NC_("ocGET_PIVOT_DATA", "Pivot table"),
    NC_("ocGET_PIVOT_DATA", "A reference to a cell or range in the pivot table."),
    NC_("ocGET_PIVOT_DATA", "Field name / item"),
    NC_("ocGET_PIVOT_DATA", "Field name/value pair to filter the target data.")
};

// -=*# Resource for function BAHTTEXT #*=-
const TranslateId ocBAHTTEXT_ARY[] =
{
    NC_("ocBAHTTEXT", "Converts a number to text (Baht)."),
    NC_("ocBAHTTEXT", "Number"),
    NC_("ocBAHTTEXT", "The number to convert.")
};

// -=*# Resource for function JIS #*=-
const TranslateId ocJIS_ARY[] =
{
    NC_("ocJIS", "Converts half-width ASCII and katakana characters to full-width."),
    NC_("ocJIS", "Text"),
    NC_("ocJIS", "The text to convert.")
};

// -=*# Resource for function ASC #*=-
const TranslateId ocASC_ARY[] =
{
    NC_("ocASC", "Converts full-width ASCII and katakana characters to half-width."),
    NC_("ocASC", "Text"),
    NC_("ocASC", "The text to convert.")
};

// -=*# Resource for function CODE #*=-
const TranslateId ocCODE_ARY[] =
{
    NC_("ocCODE", "Returns a numeric code for the first character in a text string."),
    NC_("ocCODE", "Text"),
    NC_("ocCODE", "This is the text for which the code of the first character is to be found.")
};

// -=*# Resource for function DOLLAR #*=-
const TranslateId ocCURRENCY_ARY[] =
{
    NC_("ocCURRENCY", "Converts a number to text in currency format."),
    NC_("ocCURRENCY", "Value"),
    NC_("ocCURRENCY", "Value is a number, a reference to a cell containing a number or a formula that results in a number."),
    NC_("ocCURRENCY", "Decimals"),
    NC_("ocCURRENCY", "Decimal places. Denotes the number of digits to the right of the decimal point.")
};

// -=*# Resource for function CHAR #*=-
const TranslateId ocCHAR_ARY[] =
{
    NC_("ocCHAR", "Converts a code number into a character or letter."),
    NC_("ocCHAR", "Number"),
    NC_("ocCHAR", "The code value for the character.")
};

// -=*# Resource for function CLEAN #*=-
const TranslateId ocCLEAN_ARY[] =
{
    NC_("ocCLEAN", "Removes all nonprintable characters from text."),
    NC_("ocCLEAN", "Text"),
    NC_("ocCLEAN", "The text from which nonprintable characters are to be removed.")
};

// -=*# Resource for function CONCATENATE #*=-
const TranslateId ocCONCAT_ARY[] =
{
    NC_("ocCONCAT", "Combines several text items into one."),
    NC_("ocCONCAT", "Text"),
    NC_("ocCONCAT", "Text for the concatenation.")
};

// -=*# Resource for function CONCAT #*=-
const TranslateId ocCONCAT_MS_ARY[] =
{
    NC_("ocCONCAT_MS", "Combines several text items into one, accepts cell ranges as arguments."),
    NC_("ocCONCAT_MS", "Text"),
    NC_("ocCONCAT_MS", "Text and/or cell ranges for the concatenation.")
};

// -=*# Resource for function TEXTJOIN #*=-
const TranslateId ocTEXTJOIN_MS_ARY[] =
{
    NC_("ocTEXTJOIN_MS", "Combines several text items into one, accepts cell ranges as arguments. Uses delimiter between items."),
    NC_("ocTEXTJOIN_MS", "Delimiter"),
    NC_("ocTEXTJOIN_MS", "Text string to be used as delimiter."),
    NC_("ocTEXTJOIN_MS", "Skip empty cells"),
    NC_("ocTEXTJOIN_MS", "If TRUE, empty cells will be ignored."),
    NC_("ocTEXTJOIN_MS", "Text"),
    NC_("ocTEXTJOIN_MS", "Text and/or cell ranges for the concatenation.")
};

// -=*# Resource for function IFS #*=-
const TranslateId ocIFS_MS_ARY[] =
{
    NC_("ocIFS_MS", "Checks 1 or more conditions and returns a value corresponding to the first true condition."),
    NC_("ocIFS_MS", "Test"),
    NC_("ocIFS_MS", "Any value or expression which can be either TRUE or FALSE."),
    NC_("ocIFS_MS", "Result"),
    NC_("ocIFS_MS", "The result of the function if test is TRUE.")
};

// -=*# Resource for function SWITCH #*=-
const TranslateId ocSWITCH_MS_ARY[] =
{
    NC_("ocSWITCH_MS", "Compares expression against list of value/result pairs, and returns result for first value that matches the expression.  If expression does not match any value, a default result is returned, if it is placed as final item in parameter list without a value."),
    NC_("ocSWITCH_MS", "Expression"),
    NC_("ocSWITCH_MS", "Value to be compared against value1…valueN (N ≤ 127)"),
    NC_("ocSWITCH_MS", "Value"),
    NC_("ocSWITCH_MS", "Value to compare against expression. If no result is given, then value is returned as default result."),
    NC_("ocSWITCH_MS", "Result"),
    NC_("ocSWITCH_MS", "Value to return when corresponding value argument matches expression.")
};

const TranslateId ocMINIFS_MS_ARY[] =
{
    NC_("ocMINIFS_MS", "Returns the minimum value in a range that meet multiple criteria in multiple ranges."),
    NC_("ocMINIFS_MS", "Min range"),
    NC_("ocMINIFS_MS", "The range from which the minimum will be determined."),
    NC_("ocMINIFS_MS", "Range "),
    NC_("ocMINIFS_MS", "Range 1, range 2,... are the ranges to be evaluated by the criteria given."),
    NC_("ocMINIFS_MS", "Criteria "),
    NC_("ocMINIFS_MS", "Criteria 1, criteria 2,... are the criteria to be applied to the ranges given.")
};

const TranslateId ocMAXIFS_MS_ARY[] =
{
    NC_("ocMAXIFS_MS", "Returns the maximum value in a range that meet multiple criteria in multiple ranges."),
    NC_("ocMAXIFS_MS", "Max range"),
    NC_("ocMAXIFS_MS", "The range from which the maximum will be determined."),
    NC_("ocMAXIFS_MS", "Range "),
    NC_("ocMAXIFS_MS", "Range 1, range 2,... are the ranges to be evaluated by the criteria given."),
    NC_("ocMAXIFS_MS", "Criteria "),
    NC_("ocMAXIFS_MS", "Criteria 1, criteria 2,... are the criteria to be applied to the ranges given.")
};

// -=*# Resource for function EXACT #*=-
const TranslateId ocEXACT_ARY[] =
{
    NC_("ocEXACT", "Specifies whether two texts are identical."),
    NC_("ocEXACT", "Text 1"),
    NC_("ocEXACT", "The first text to be used for comparing texts."),
    NC_("ocEXACT", "Text 2"),
    NC_("ocEXACT", "The second text for comparing texts.")
};

// -=*# Resource for function FIND #*=-
const TranslateId ocFIND_ARY[] =
{
    NC_("ocFIND", "Looks for a string of text within another (case sensitive)"),
    NC_("ocFIND", "Find text"),
    NC_("ocFIND", "The text to be found."),
    NC_("ocFIND", "Text"),
    NC_("ocFIND", "The text in which a search is to be made."),
    NC_("ocFIND", "Position"),
    NC_("ocFIND", "The position in the text from which the search starts.")
};

// -=*# Resource for function SEARCH #*=-
const TranslateId ocSEARCH_ARY[] =
{
    NC_("ocSEARCH", "Looks for one text value within another (not case-sensitive)."),
    NC_("ocSEARCH", "Find text"),
    NC_("ocSEARCH", "The text to be found."),
    NC_("ocSEARCH", "Text"),
    NC_("ocSEARCH", "The text in which a search is to be made."),
    NC_("ocSEARCH", "Position"),
    NC_("ocSEARCH", "The position in the text where the search is started.")
};

// -=*# Resource for function TRIM #*=-
const TranslateId ocTRIM_ARY[] =
{
    NC_("ocTRIM", "Removes extra spaces from text."),
    NC_("ocTRIM", "Text"),
    NC_("ocTRIM", "The text in which extra spaces between words are to be deleted.")
};

// -=*# Resource for function PROPER #*=-
const TranslateId ocPROPER_ARY[] =
{
    NC_("ocPROPER", "Capitalizes the first letter in all words."),
    NC_("ocPROPER", "Text"),
    NC_("ocPROPER", "The text in which the beginning of words are to be replaced by capital letters.")
};

// -=*# Resource for function UPPER #*=-
const TranslateId ocUPPER_ARY[] =
{
    NC_("ocUPPER", "Converts text to uppercase."),
    NC_("ocUPPER", "Text"),
    NC_("ocUPPER", "The text in which lower case letters are to be converted to capitals.")
};

// -=*# Resource for function LOWER #*=-
const TranslateId ocLOWER_ARY[] =
{
    NC_("ocLOWER", "Converts text to lowercase."),
    NC_("ocLOWER", "Text"),
    NC_("ocLOWER", "The text in which capitals are converted to lower case letters.")
};

// -=*# Resource for function VALUE #*=-
const TranslateId ocVALUE_ARY[] =
{
    NC_("ocVALUE", "Converts text to a number."),
    NC_("ocVALUE", "Text"),
    NC_("ocVALUE", "The text to be converted to a number.")
};

// -=*# Resource for function TEXT #*=-
const TranslateId ocTEXT_ARY[] =
{
    NC_("ocTEXT", "Converts a number to text according to a given format."),
    NC_("ocTEXT", "Number"),
    NC_("ocTEXT", "The numeric value to be converted."),
    NC_("ocTEXT", "Format"),
    NC_("ocTEXT", "The text that describes the format.")
};

// -=*# Resource for function T #*=-
const TranslateId ocT_ARY[] =
{
    NC_("ocT", "Returns a value if it is text, otherwise an empty string."),
    NC_("ocT", "Value"),
    NC_("ocT", "The value to be checked and returned if it is text.")
};

// -=*# Resource for function REPLACE #*=-
const TranslateId ocREPLACE_ARY[] =
{
    NC_("ocREPLACE", "Replaces characters within a text string with a different text string."),
    NC_("ocREPLACE", "Text"),
    NC_("ocREPLACE", "The text in which some characters are to be replaced."),
    NC_("ocREPLACE", "Position"),
    NC_("ocREPLACE", "The character position from which text is to be replaced."),
    NC_("ocREPLACE", "Length"),
    NC_("ocREPLACE", "The number of characters to be replaced."),
    NC_("ocREPLACE", "New text"),
    NC_("ocREPLACE", "The text to be inserted.")
};

// -=*# Resource for function FIXED #*=-
const TranslateId ocFIXED_ARY[] =
{
    NC_("ocFIXED", "Formats a number with a fixed number of places after the decimal point and thousands separator."),
    NC_("ocFIXED", "Number"),
    NC_("ocFIXED", "The number to be formatted."),
    NC_("ocFIXED", "Decimals"),
    NC_("ocFIXED", "Decimal places. The number of fixed decimal places that are to be displayed. Default 2."),
    NC_("ocFIXED", "No thousands separators"),
    NC_("ocFIXED", "Thousands separator. If 0 or omitted the locale group separator is used else the separator is suppressed.")
};

// -=*# Resource for function LEN #*=-
const TranslateId ocLEN_ARY[] =
{
    NC_("ocLEN", "Calculates length of a text string."),
    NC_("ocLEN", "Text"),
    NC_("ocLEN", "The text in which the length is to be determined.")
};

// -=*# Resource for function LEFT #*=-
const TranslateId ocLEFT_ARY[] =
{
    NC_("ocLEFT", "Returns the first character or characters of a text."),
    NC_("ocLEFT", "Text"),
    NC_("ocLEFT", "The text where the initial partial words are to be determined."),
    NC_("ocLEFT", "Number"),
    NC_("ocLEFT", "The number of characters for the start text.")
};

// -=*# Resource for function RIGHT #*=-
const TranslateId ocRIGHT_ARY[] =
{
    NC_("ocRIGHT", "Returns the last character or characters of a text."),
    NC_("ocRIGHT", "Text"),
    NC_("ocRIGHT", "The text in which the end partial words are to be determined."),
    NC_("ocRIGHT", "Number"),
    NC_("ocRIGHT", "The number of characters for the end text.")
};

// -=*# Resource for function MID #*=-
const TranslateId ocMID_ARY[] =
{
    NC_("ocMID", "Returns a partial text string of a text."),
    NC_("ocMID", "Text"),
    NC_("ocMID", "The text in which partial words are to be determined."),
    NC_("ocMID", "Start"),
    NC_("ocMID", "The position from which the part word is to be determined."),
    NC_("ocMID", "Number"),
    NC_("ocMID", "The number of characters for the text.")
};

// -=*# Resource for function REPT #*=-
const TranslateId ocREPT_ARY[] =
{
    NC_("ocREPT", "Repeats text a given number of times."),
    NC_("ocREPT", "Text"),
    NC_("ocREPT", "The text to be repeated."),
    NC_("ocREPT", "Number"),
    NC_("ocREPT", "The number of times the text is to be repeated.")
};

// -=*# Resource for function SUBSTITUTE #*=-
const TranslateId ocSUBSTITUTE_ARY[] =
{
    NC_("ocSUBSTITUTE", "Substitutes new text for old text in a string."),
    NC_("ocSUBSTITUTE", "Text"),
    NC_("ocSUBSTITUTE", "The text in which partial words are to be replaced."),
    NC_("ocSUBSTITUTE", "Search text"),
    NC_("ocSUBSTITUTE", "The partial string to be (repeatedly) replaced."),
    NC_("ocSUBSTITUTE", "New text"),
    NC_("ocSUBSTITUTE", "The text which is to replace the text string."),
    NC_("ocSUBSTITUTE", "Occurrence"),
    NC_("ocSUBSTITUTE", "Which occurrence of the old text is to be replaced.")
};

// -=*# Resource for function REGEX #*=-
const TranslateId ocREGEX_ARY[] =
{
    NC_("ocREGEX", "Matches and extracts or optionally replaces text using regular expressions."),
    NC_("ocREGEX", "Text"),
    NC_("ocREGEX", "The text to be operated on."),
    NC_("ocREGEX", "Expression"),
    NC_("ocREGEX", "The regular expression pattern to be matched."),
    NC_("ocREGEX", "Replacement"),
    NC_("ocREGEX", "The replacement text and references to capture groups."),
    NC_("ocREGEX", "Flags or Occurrence"),
    NC_("ocREGEX", "Text specifying option flags, \"g\" for global replacement. Or number of occurrence to match or replace.")
};

// -=*# Resource for function BASE #*=-
const TranslateId ocBASE_ARY[] =
{
    NC_("ocBASE", "Converts a positive integer to text from a number system to the base defined."),
    NC_("ocBASE", "Number"),
    NC_("ocBASE", "The number to be converted."),
    NC_("ocBASE", "Radix"),
    NC_("ocBASE", "The base number for conversion must be in the range 2 - 36."),
    NC_("ocBASE", "Minimum length"),
    NC_("ocBASE", "If the text is shorter than the specified length, zeros are added to the left of the string.")
};

// -=*# Resource for function DECIMAL #*=-
const TranslateId ocDECIMAL_ARY[] =
{
    NC_("ocDECIMAL", "Converts a text of a specified number system to a positive integer in the base given."),
    NC_("ocDECIMAL", "Text"),
    NC_("ocDECIMAL", "The text to be converted."),
    NC_("ocDECIMAL", "Radix"),
    NC_("ocDECIMAL", "The base number for conversion must be in the range 2 - 36.")
};

// -=*# Resource for function CONVERT_OOO #*=-
const TranslateId ocCONVERT_OOO_ARY[] =
{
    NC_("ocCONVERT_OOO", "Converts a value according to a conversion table in the configuration (main.xcd)."),
    NC_("ocCONVERT_OOO", "Value"),
    NC_("ocCONVERT_OOO", "The value to be converted."),
    NC_("ocCONVERT_OOO", "Text"),
    NC_("ocCONVERT_OOO", "Unit from which something is converted, case-sensitive."),
    NC_("ocCONVERT_OOO", "Text"),
    NC_("ocCONVERT_OOO", "Unit into which something is converted, case-sensitive.")
};

// -=*# Resource for function ROMAN #*=-
const TranslateId ocROMAN_ARY[] =
{
    NC_("ocROMAN", "Converts a number to a Roman numeral."),
    NC_("ocROMAN", "Number"),
    NC_("ocROMAN", "The number to be converted to a Roman numeral must be in the 0 - 3999 range."),
    NC_("ocROMAN", "Mode"),
    NC_("ocROMAN", "The more this value increases, the more the Roman numeral is simplified. The value must be in the 0 - 4 range.")
};

// -=*# Resource for function ARABIC #*=-
const TranslateId ocARABIC_ARY[] =
{
    NC_("ocARABIC", "Calculates the value of a Roman numeral."),
    NC_("ocARABIC", "Text"),
    NC_("ocARABIC", "The text that represents a Roman numeral.")
};

const TranslateId ocINFO_ARY[] =
{
    NC_("ocINFO", "Returns information about the environment."),
    NC_("ocINFO", "Text"),
    NC_("ocINFO", "Can be \"osversion\", \"system\", \"release\", \"numfile\", and \"recalc\".")
};

const TranslateId ocUNICODE_ARY[] =
{
    NC_("ocUNICODE", "Returns the numeric code for the first Unicode character in a text string."),
    NC_("ocUNICODE", "Text"),
    NC_("ocUNICODE", "This is the text for which the code of the first character is to be found.")
};

const TranslateId ocUNICHAR_ARY[] =
{
    NC_("ocUNICHAR", "Converts a code number into a Unicode character or letter."),
    NC_("ocUNICHAR", "Number"),
    NC_("ocUNICHAR", "The code value for the character.")
};

const TranslateId ocEUROCONVERT_ARY[] =
{
    NC_("ocEUROCONVERT", "Converts a value from one to another Euro currency."),
    NC_("ocEUROCONVERT", "Value"),
    NC_("ocEUROCONVERT", "The value to be converted."),
    NC_("ocEUROCONVERT", "From currency"),
    NC_("ocEUROCONVERT", "ISO 4217 code of the currency from which is converted."),
    NC_("ocEUROCONVERT", "To currency"),
    NC_("ocEUROCONVERT", "ISO 4217 code of the currency into which is converted."),
    NC_("ocEUROCONVERT", "Full precision"),
    NC_("ocEUROCONVERT", "If omitted or 0 or FALSE, the result is rounded to the decimals of To_currency. Else the result is not rounded."),
    NC_("ocEUROCONVERT", "Triangulation precision"),
    /* This description uses almost all available space in the dialog, make sure translations fit in size */
    NC_("ocEUROCONVERT", "If given and >=3, the intermediate result of a triangular conversion is rounded to that precision. If omitted, the result is not rounded.")
};

const TranslateId ocNUMBERVALUE_ARY[] =
{
    NC_("ocNUMBERVALUE", "Converts text to a number, in a locale-independent way."),
    NC_("ocNUMBERVALUE", "Text"),
    NC_("ocNUMBERVALUE", "The text to be converted to a number."),
    NC_("ocNUMBERVALUE", "Decimal separator"),
    NC_("ocNUMBERVALUE", "Defines the character used as the decimal separator."),
    NC_("ocNUMBERVALUE", "Group separator"),
    NC_("ocNUMBERVALUE", "Defines the character(s) used as the group separator.")
};


const TranslateId ocBITAND_ARY[] =
{
    NC_("ocBITAND", "Bitwise \"AND\" of two integers."),
    NC_("ocBITAND", "Number1"),
    NC_("ocBITAND", "Positive integer less than 2^48."),
    NC_("ocBITAND", "Number2"),
    NC_("ocBITAND", "Positive integer less than 2^48.")
};

const TranslateId ocBITOR_ARY[] =
{
    NC_("ocBITOR", "Bitwise \"OR\" of two integers."),
    NC_("ocBITOR", "Number1"),
    NC_("ocBITOR", "Positive integer less than 2^48."),
    NC_("ocBITOR", "Number2"),
    NC_("ocBITOR", "Positive integer less than 2^48.")
};

const TranslateId ocBITXOR_ARY[] =
{
    NC_("ocBITXOR", "Bitwise \"exclusive OR\" of two integers."),
    NC_("ocBITXOR", "Number1"),
    NC_("ocBITXOR", "Positive integer less than 2^48."),
    NC_("ocBITXOR", "Number2"),
    NC_("ocBITXOR", "Positive integer less than 2^48.")
};

const TranslateId ocBITRSHIFT_ARY[] =
{
    NC_("ocBITRSHIFT", "Bitwise right shift of an integer value."),
    NC_("ocBITRSHIFT", "Number"),
    NC_("ocBITRSHIFT", "The value to be shifted. Positive integer less than 2^48."),
    NC_("ocBITRSHIFT", "Shift"),
    NC_("ocBITRSHIFT", "The integer number of bits the value is to be shifted.")
};

const TranslateId ocBITLSHIFT_ARY[] =
{
    NC_("ocBITLSHIFT", "Bitwise left shift of an integer value."),
    NC_("ocBITLSHIFT", "Number"),
    NC_("ocBITLSHIFT", "The value to be shifted. Positive integer less than 2^48."),
    NC_("ocBITLSHIFT", "Shift"),
    NC_("ocBITLSHIFT", "The integer number of bits the value is to be shifted.")
};

const TranslateId ocLENB_ARY[] =
{
    NC_("ocLENB", "Calculates length of a text string, with DBCS"),
    NC_("ocLENB", "Text"),
    NC_("ocLENB", "The text in which the length is to be determined.")
};

const TranslateId ocRIGHTB_ARY[] =
{
    NC_("ocRIGHTB", "Returns the last character or characters of a text,with DBCS"),
    NC_("ocRIGHTB", "Text"),
    NC_("ocRIGHTB", "The text in which the end partial words are to be determined."),
    NC_("ocRIGHTB", "Number"),
    NC_("ocRIGHTB", "The number of characters for the end text.")
};

const TranslateId ocLEFTB_ARY[] =
{
    NC_("ocLEFTB", "Returns the first character or characters of a text,with DBCS"),
    NC_("ocLEFTB", "Text"),
    NC_("ocLEFTB", "The text where the initial partial words are to be determined."),
    NC_("ocLEFTB", "Number"),
    NC_("ocLEFTB", "The number of characters for the start text.")
};

const TranslateId ocMIDB_ARY[] =
{
    NC_("ocMIDB", "Returns a partial text string of a text, with DBCS"),
    NC_("ocMIDB", "Text"),
    NC_("ocMIDB", "The text in which partial words are to be determined."),
    NC_("ocMIDB", "Start"),
    NC_("ocMIDB", "The position from which the part word is to be determined."),
    NC_("ocMIDB", "Number"),
    NC_("ocMIDB", "The number of characters for the text.")
};

const TranslateId ocFILTERXML_ARY[] =
{
    NC_("ocFILTERXML", "Apply an XPath expression to an XML document"),
    NC_("ocFILTERXML", "XML Document"),
    NC_("ocFILTERXML", "String containing a valid XML stream"),
    NC_("ocFILTERXML", "XPath expression"),
    NC_("ocFILTERXML", "String containing a valid XPath expression")
};

const TranslateId ocCOLOR_ARY[] =
{
    NC_("ocCOLOR", "Returns an implementation defined value representing a RGBA color"),
    NC_("ocCOLOR", "Red"),
    NC_("ocCOLOR", "Value of red"),
    NC_("ocCOLOR", "Green"),
    NC_("ocCOLOR", "Value of green"),
    NC_("ocCOLOR", "Blue"),
    NC_("ocCOLOR", "Value of blue"),
    NC_("ocCOLOR", "Alpha"),
    NC_("ocCOLOR", "Value of alpha")
};

const TranslateId ocWEBSERVICE_ARY[] =
{
    NC_("ocWEBSERVICE", "Get some web-content from a URI."),
    NC_("ocWEBSERVICE", "URI"),
    NC_("ocWEBSERVICE", "URI of the webservice")
};

const TranslateId ocENCODEURL_ARY[] =
{
    NC_("ocENCODEURL", "Return a URL-encoded string."),
    NC_("ocENCODEURL", "Text"),
    NC_("ocENCODEURL", "A string to be URL-encoded")
};

const TranslateId ocERF_MS_ARY[] =
{
    NC_("ocERF_MS", "Returns the error function."),
    NC_("ocERF_MS", "Lower limit"),
    NC_("ocERF_MS", "The lower limit for integration")
};

const TranslateId ocERFC_MS_ARY[] =
{
    NC_("ocERFC_MS", "Returns the complementary error function."),
    NC_("ocERFC_MS", "Lower limit"),
    NC_("ocERFC_MS", "The lower limit for integration")
};

const TranslateId ocRAWSUBTRACT_ARY[] =
{
    NC_("ocRAWSUBTRACT", "Returns the subtraction of numbers. Like a-b-c but without eliminating small roundoff errors."),
    NC_("ocRAWSUBTRACT", "Minuend"),
    NC_("ocRAWSUBTRACT", "Number from which following arguments are subtracted."),
    NC_("ocRAWSUBTRACT", "Subtrahend "),
    NC_("ocRAWSUBTRACT", "Subtrahend 1, subtrahend 2, ... are numerical arguments subtracted from the minuend.")
};

// -=*# Resource for function ROUNDSIG #*=-
const TranslateId ocROUNDSIG_ARY[] =
{
    NC_("ocROUNDSIG", "Rounds a number to predefined significant digits."),
    NC_("ocROUNDSIG", "Value"),
    NC_("ocROUNDSIG", "The number to be rounded."),
    NC_("ocROUNDSIG", "Digits"),
    NC_("ocROUNDSIG", "The number of significant digits to which value is to be rounded.")
};

const TranslateId ocREPLACEB_ARY[] =
{
    NC_("ocREPLACEB", "Replaces characters within a text string with a different text string, with DBCS."),
    NC_("ocREPLACEB", "Text"),
    NC_("ocREPLACEB", "The text in which some characters are to be replaced."),
    NC_("ocREPLACEB", "Position"),
    NC_("ocREPLACEB", "The character position from which text is to be replaced."),
    NC_("ocREPLACEB", "Length"),
    NC_("ocREPLACEB", "The number of characters to be replaced."),
    NC_("ocREPLACEB", "New text"),
    NC_("ocREPLACEB", "The text to be inserted.")
};

 // -=*# Resource for function FINDB #*=-
const TranslateId ocFINDB_ARY[] =
{
    NC_("ocFINDB", "Looks for a string of text within another (case sensitive), using byte positions."),
    NC_("ocFINDB", "Find text"),
    NC_("ocFINDB", "The text to be found."),
    NC_("ocFINDB", "Text"),
    NC_("ocFINDB", "The text in which a search is to be made."),
    NC_("ocFINDB", "Position"),
    NC_("ocFINDB", "The position in the text from which the search starts.")
};

 // -=*# Resource for function SEARCHB #*=-
const TranslateId ocSEARCHB_ARY[] =
{
    NC_("ocSEARCHB", "Looks for a string of text within another (not case sensitive), using byte positions."),
    NC_("ocSEARCHB", "Find text"),
    NC_("ocSEARCHB", "The text to be found."),
    NC_("ocSEARCHB", "Text"),
    NC_("ocSEARCHB", "The text in which a search is to be made."),
    NC_("ocSEARCHB", "Position"),
    NC_("ocSEARCHB", "The position in the text from which the search starts.")
};

// -=*# Resource for function FOURIER #*=-
const TranslateId ocFOURIER_ARY[] =
{
    NC_("ocFOURIER", "Computes the Discrete Fourier Transform (DFT) of an array"),
    NC_("ocFOURIER", "Array"),
    NC_("ocFOURIER", "The array whose DFT needs to be computed. The dimensions of this array can be Nx1 or Nx2 or 1xN or 2xN."),
    NC_("ocFOURIER", "GroupedByColumns"),
    NC_("ocFOURIER", "Flag to indicate whether the array is grouped by columns or not (default TRUE)."),
    NC_("ocFOURIER", "Inverse"),
    NC_("ocFOURIER", "Flag to indicate whether an inverse DFT is to be computed (default FALSE)."),
    NC_("ocFOURIER", "Polar"),
    NC_("ocFOURIER", "Flag to indicate whether to return the results in polar form (default FALSE)."),
    NC_("ocFOURIER", "MinimumMagnitude"),
    NC_("ocFOURIER", "In case of Polar=TRUE, the frequency components below this magnitude are clipped out (default 0.0).")
};

// -=*# Resource for function RAND.NV #*=-
const TranslateId ocRANDOM_NV_ARY[] =
{
    NC_("ocRANDOM_NV", "Returns a random number between 0 and 1, non-volatile.")
};

// -=*# Resource for function RANDBETWEEN.NV #*=-
const TranslateId ocRANDBETWEEN_NV_ARY[] =
{
    NC_("ocRANDBETWEEN_NV", "Returns a random integer between the specified Bottom and Top values (both inclusive), non-volatile."),
    NC_("ocRANDBETWEEN_NV", "Bottom"),
    NC_("ocRANDBETWEEN_NV", "The smallest integer that can be returned."),
    NC_("ocRANDBETWEEN_NV", "Top"),
    NC_("ocRANDBETWEEN_NV", "The largest integer that can be returned.")
};

// -=*# Resource for function FILTER #*=-
const TranslateId ocFILTER_ARY[] =
{
    NC_("ocFILTER", "Filters an array based on a Boolean (True/False) array."),
    NC_("ocFILTER", "Range"),
    NC_("ocFILTER", "The array, or range to filter."),
    NC_("ocFILTER", "Include"),
    NC_("ocFILTER", "A Boolean array whose height or width is the same as the array."),
    NC_("ocFILTER", "Result if empty"),
    NC_("ocFILTER", "The value to return if all values in the included array are empty (filter returns nothing).")
};

// -=*# Resource for function SORT #*=-
const TranslateId ocSORT_ARY[] =
{
    NC_("ocSORT", "Sorts the contents of a range or array."),
    NC_("ocSORT", "Range"),
    NC_("ocSORT", "The range, or array to sort."),
    NC_("ocSORT", "Sort index"),
    NC_("ocSORT", "A number indicating the row or column to sort by."),
    NC_("ocSORT", "Sort order"),
    NC_("ocSORT", "A number indicating the desired sort order; 1 for ascending order (default), -1 for descending order."),
    NC_("ocSORT", "By col"),
    NC_("ocSORT", "A logical value indicating the desired sort direction; FALSE to sort by row (default), TRUE to sort by column.")
};

// -=*# Resource for function SORTBY #*=-
const TranslateId ocSORTBY_ARY[] =
{
    NC_("ocSORTBY", "Sorts the contents of a range or array based on the values in a corresponding range or array."),
    NC_("ocSORTBY", "Sort range"),
    NC_("ocSORTBY", "The array or range to sort."),
    NC_("ocSORTBY", "Sort by range "),
    NC_("ocSORTBY", "Range 1, range 2,... are the arrays or ranges to sort on."),
    NC_("ocSORTBY", "Sort order "),
    NC_("ocSORTBY", "Order 1, order 2,... are the orders to use for sorting. 1 for ascending, -1 for descending. Default is ascending.")
};

// -=*# Resource for function SEQUENCE #*=-
const TranslateId ocMAT_SEQUENCE_ARY[] =
{
    NC_("ocMAT_SEQUENCE", "Generates a list of sequential numbers in an array, such as 1, 2, 3, 4."),
    NC_("ocMAT_SEQUENCE", "Rows"),
    NC_("ocMAT_SEQUENCE", "The number of rows to return."),
    NC_("ocMAT_SEQUENCE", "Columns"),
    NC_("ocMAT_SEQUENCE", "The number of columns to return."),
    NC_("ocMAT_SEQUENCE", "Start"),
    NC_("ocMAT_SEQUENCE", "The first number in the sequence."),
    NC_("ocMAT_SEQUENCE", "Step"),
    NC_("ocMAT_SEQUENCE", "The amount to increment each subsequent value in the array.")
};

// -=*# Resource for function RANDARRAY #*=-
const TranslateId ocRANDARRAY_ARY[] =
{
    NC_("ocRANDARRAY", "Generates an array of random numbers between two limit values."),
    NC_("ocRANDARRAY", "Rows"),
    NC_("ocRANDARRAY", "The number of rows to return."),
    NC_("ocRANDARRAY", "Columns"),
    NC_("ocRANDARRAY", "The number of columns to return."),
    NC_("ocRANDARRAY", "Min"),
    NC_("ocRANDARRAY", "The lower limit of the generated numbers."),
    NC_("ocRANDARRAY", "Max"),
    NC_("ocRANDARRAY", "The upper limit of the generated numbers."),
    NC_("ocRANDARRAY", "Integers"),
    NC_("ocRANDARRAY", "Return integer (TRUE) or decimal (FALSE) values.")
};

// -=*# Resource for function CHOOSECOLS #*=-
const TranslateId ocCHOOSECOLS_ARY[] =
{
    NC_("ocCHOOSECOLS", "Returns the specified columns from an array."),
    NC_("ocCHOOSECOLS", "Array"),
    NC_("ocCHOOSECOLS", "The array containing the columns to be returned in the new array."),
    NC_("ocCHOOSECOLS", "Column "),
    NC_("ocCHOOSECOLS", "Column 1, Column 2,... The list of column numbers to be returned.")
};

// -=*# Resource for function CHOOSEROWS #*=-
const TranslateId ocCHOOSEROWS_ARY[] =
{
    NC_("ocCHOOSEROWS", "Returns the specified rows from an array."),
    NC_("ocCHOOSEROWS", "Array"),
    NC_("ocCHOOSEROWS", "The array containing the rows to be returned in the new array."),
    NC_("ocCHOOSEROWS", "Row "),
    NC_("ocCHOOSEROWS", "Row 1, Row 2,... The list of row numbers to be returned.")
};

// -=*# Resource for function DROP #*=-
const TranslateId ocDROP_ARY[] =
{
    NC_("ocDROP", "Excludes a specified number of contiguous rows or columns from the start or end of an array."),
    NC_("ocDROP", "Array"),
    NC_("ocDROP", "The array from which to drop rows or columns."),
    NC_("ocDROP", "Rows"),
    NC_("ocDROP", "The number of rows to drop. A negative value drops from the end of the array."),
    NC_("ocDROP", "Columns"),
    NC_("ocDROP", "The number of columns to drop. A negative value drops from the end of the array.")
};

// -=*# Resource for function EXPAND #*=-
const TranslateId ocEXPAND_ARY[] =
{
    NC_("ocEXPAND", "Expands or pads an array to specified row and column dimensions."),
    NC_("ocEXPAND", "Array"),
    NC_("ocEXPAND", "The array to expand."),
    NC_("ocEXPAND", "Rows"),
    NC_("ocEXPAND", "The number of rows in the expanded array. If missing, rows will not be expanded."),
    NC_("ocEXPAND", "Columns"),
    NC_("ocEXPAND", "The number of columns in the expanded array. If missing, columns will not be expanded."),
    NC_("ocEXPAND", "Pad with"),
    NC_("ocEXPAND", "The value with which to pad. The default is #N/A.")
};

// -=*# Resource for function HSTACK #*=-
const TranslateId ocHSTACK_ARY[] =
{
    NC_("ocHSTACK", "Appends arrays horizontally to create a larger array."),
    NC_("ocHSTACK", "Array"),
    NC_("ocHSTACK", "The first array to append."),
    NC_("ocHSTACK", "Array"),
    NC_("ocHSTACK", "Array 1, Array 2,... The following arrays to append. If an array has fewer rows, #N/A error will be returned in the additional rows."),
};

// -=*# Resource for function VSTACK #*=-
const TranslateId ocVSTACK_ARY[] =
{
    NC_("ocVSTACK", "Appends arrays vertically to create a larger array."),
    NC_("ocVSTACK", "Array"),
    NC_("ocVSTACK", "The first array to append."),
    NC_("ocVSTACK", "Array"),
    NC_("ocVSTACK", "Array 1, Array 2,... The following arrays to append. If an array has fewer columns, #N/A error will be returned in the additional columns."),
};

// -=*# Resource for function TAKE #*=-
const TranslateId ocTAKE_ARY[] =
{
    NC_("ocTAKE", "Returns a specified number of contiguous rows or columns from the start or end of an array."),
    NC_("ocTAKE", "Array"),
    NC_("ocTAKE", "The array from which to take rows or columns."),
    NC_("ocTAKE", "Rows"),
    NC_("ocTAKE", "The number of rows to take. A negative value takes from the end of the array."),
    NC_("ocTAKE", "Columns"),
    NC_("ocTAKE", "The number of columns to take. A negative value takes from the end of the array.")
};

// -=*# Resource for function TEXTAFTER #*=-
const TranslateId ocTEXTAFTER_ARY[] =
{
    NC_("ocTEXTAFTER", "Returns the text that occurs after a given substring or delimiter."),
    NC_("ocTEXTAFTER", "Text"),
    NC_("ocTEXTAFTER", "The original text."),
    NC_("ocTEXTAFTER", "Delimiter"),
    NC_("ocTEXTAFTER", "The delimiter. Multiple delimiters can be supplied."),
    NC_("ocTEXTAFTER", "Instance Number"),
    NC_("ocTEXTAFTER", "The instance of the delimiter after which to extract text. The default is 1. A negative number starts searching from the end."),
    NC_("ocTEXTAFTER", "Match Mode"),
    NC_("ocTEXTAFTER", "Set to 1 to perform a case-insensitive match. The default is 0."),
    NC_("ocTEXTAFTER", "Match End"),
    NC_("ocTEXTAFTER", "Set to 1 to treat the end of text as a delimiter. The default is 0."),
    NC_("ocTEXTAFTER", "If Not Found"),
    NC_("ocTEXTAFTER", "The value returned if no match is found. The default is #N/A.")
};

// -=*# Resource for function TEXTBEFORE #*=-
const TranslateId ocTEXTBEFORE_ARY[] =
{
    NC_("ocTEXTBEFORE", "Returns the text that occurs before a given substring or delimiter."),
    NC_("ocTEXTBEFORE", "Text"),
    NC_("ocTEXTBEFORE", "The original text."),
    NC_("ocTEXTBEFORE", "Delimiter"),
    NC_("ocTEXTBEFORE", "The delimiter. Multiple delimiters can be supplied."),
    NC_("ocTEXTBEFORE", "Instance Number"),
    NC_("ocTEXTBEFORE", "The instance of the delimiter before which to extract text. The default is 1. A negative number starts searching from the end."),
    NC_("ocTEXTBEFORE", "Match Mode"),
    NC_("ocTEXTBEFORE", "Set to 1 to perform a case-insensitive match. The default is 0."),
    NC_("ocTEXTBEFORE", "Match End"),
    NC_("ocTEXTBEFORE", "Set to 1 to treat the end of text as a delimiter. The default is 0."),
    NC_("ocTEXTBEFORE", "If Not Found"),
    NC_("ocTEXTBEFORE", "The value returned if no match is found. The default is #N/A.")
};

// -=*# Resource for function TEXTSPLIT #*=-
const TranslateId ocTEXTSPLIT_ARY[] =
{
    NC_("ocTEXTSPLIT", "Splits text by a given delimiter to an array of multiple cells."),
    NC_("ocTEXTSPLIT", "Text"),
    NC_("ocTEXTSPLIT", "The text to split."),
    NC_("ocTEXTSPLIT", "Column Delimiter"),
    NC_("ocTEXTSPLIT", "The text to delimit the columns. Multiple delimiters can be supplied."),
    NC_("ocTEXTSPLIT", "Row Delimiter"),
    NC_("ocTEXTSPLIT", "The text to delimit the rows. Multiple delimiters can be supplied."),
    NC_("ocTEXTSPLIT", "Ignore Empty"),
    NC_("ocTEXTSPLIT", "Set to TRUE to ignore consecutive delimiters otherwise it creates an empty cell. The default is FALSE."),
    NC_("ocTEXTSPLIT", "Match mode"),
    NC_("ocTEXTSPLIT", "Set to 1 to perform a case-insensitive match. The default is 0."),
    NC_("ocTEXTSPLIT", "Pad with"),
    NC_("ocTEXTSPLIT", "The value with which to pad. The default is #N/A.")
};

// -=*# Resource for function TOCOL #*=-
const TranslateId ocTOCOL_ARY[] =
{
    NC_("ocTOCOL", "Transforms an array into a single column."),
    NC_("ocTOCOL", "Array"),
    NC_("ocTOCOL", "The range or array to return as a single column."),
    NC_("ocTOCOL", "Ignore"),
    NC_("ocTOCOL", "Whether to ignore certain types of values. 0 or omitted - keep all values (default). 1 - ignore blank cells. 2 - ignore cells with error. 3 - ignore blanks cells and cells with error."),
    NC_("ocTOCOL", "Scan by column"),
    NC_("ocTOCOL", "Scan the array by column. FALSE or omitted (default) - the array is scanned by row. TRUE - the array is scanned by column.")
};

// -=*# Resource for function TOROW #*=-
const TranslateId ocTOROW_ARY[] =
{
    NC_("ocTOROW", "transforms an array into a single row."),
    NC_("ocTOROW", "Array"),
    NC_("ocTOROW", "The range or array to return as a single row."),
    NC_("ocTOROW", "Ignore"),
    NC_("ocTOROW", "Whether to ignore certain types of values. 0 or omitted - keep all values (default). 1 - ignore blank cells. 2 - ignore cells with error. 3 - ignore blanks cells and cells with error."),
    NC_("ocTOROW", "Scan by column"),
    NC_("ocTOROW", "Scan the array by column. FALSE or omitted (default) - the array is scanned by row. TRUE - the array is scanned by column.")
};

// -=*# Resource for function UNIQUE #*=-
const TranslateId ocUNIQUE_ARY[] =
{
    NC_("ocUNIQUE", "Returns a list of unique values from a range or array."),
    NC_("ocUNIQUE", "Array"),
    NC_("ocUNIQUE", "The range or array from which to return unique values."),
    NC_("ocUNIQUE", "By col"),
    NC_("ocUNIQUE", "Logical value indicating how to compare data: TRUE - compares data across columns. FALSE or omitted (default) - compares data across rows."),
    NC_("ocUNIQUE", "Uniqueness"),
    NC_("ocUNIQUE", "Logical value that defines what values are considered unique: TRUE - returns values that occur only once. FALSE or omitted (default) - returns all distinct (different) values in the range or array.")
};

// -=*# Resource for function LET #*=-
const TranslateId ocLET_ARY[] =
{
    NC_("ocLET", "The LET function assigns names to calculation results. This allows storing intermediate calculations, values, or defining names inside a formula. These names only apply within the scope of the LET function."),
    NC_("ocLET", "Name 1"),
    NC_("ocLET", "The first name to assign. Must start with a letter. Cannot be the output of a formula or conflict with range syntax."),
    NC_("ocLET", "Name value "),
    NC_("ocLET", "Name value 1, Name value 2,... The value or calculation to assign to Name."),
    NC_("ocLET", "Calculation or Name "),
    NC_("ocLET", "A calculation that uses all names within the LET function. This must be the last argument in the LET function. Or a second Name to assign to a second Name value. If a second Name is specified, Name value 2 and Calculation or Name 3 become required.")
};

// -=*# Resource for function WRAPCOLS #*=-
const TranslateId ocWRAPCOLS_ARY[] =
{
    NC_("ocWRAPCOLS", "Wraps the provided row or column of values by columns after a specified number of elements to form a new array."),
    NC_("ocWRAPCOLS", "Range"),
    NC_("ocWRAPCOLS", "the range to wrap."),
    NC_("ocWRAPCOLS", "Wrap count"),
    NC_("ocWRAPCOLS", "The maximum number of values for each column."),
    NC_("ocWRAPCOLS", "Pad with"),
    NC_("ocWRAPCOLS", "The value with which to pad. The default is #N/A.")
};

// -=*# Resource for function WRAPROWS #*=-
const TranslateId ocWRAPROWS_ARY[] =
{
    NC_("ocWRAPROWS", "Wraps the provided row or column of values by rows after a specified number of elements to form a new array."),
    NC_("ocWRAPROWS", "Range"),
    NC_("ocWRAPROWS", "the range to wrap."),
    NC_("ocWRAPROWS", "Wrap count"),
    NC_("ocWRAPROWS", "The maximum number of values for each row."),
    NC_("ocWRAPROWS", "Pad with"),
    NC_("ocWRAPROWS", "The value with which to pad. The default is #N/A.")
};

// -=*# Resource for function ARRAYTOTEXT #*=-
const TranslateId ocARRAYTOTEXT_ARY[] =
{
    NC_("ocARRAYTOTEXT", "Returns the values of a range or array as one text string."),
    NC_("ocARRAYTOTEXT", "Array"),
    NC_("ocARRAYTOTEXT", "The range or array to return as text."),
    NC_("ocARRAYTOTEXT", "Format"),
    NC_("ocARRAYTOTEXT", "The format of the returned text. 0 or omitted - concise format, the values separated by commas (default). 1 - strict format, an array constant in braces with quoted text, comma column separators and semicolon row separators.")
};

// -=*# Resource for function LAMBDA #*=-
const TranslateId ocLAMBDA_ARY[] =
{
    NC_("ocLAMBDA", "LAMBDA builds new functions. This allows you to write formulas that can be reused with different inputs, and to use more complicated features such as recursion and higher-order functions."),
    NC_("ocLAMBDA", "Name 1"),
    NC_("ocLAMBDA", "The name of the first input to the function. Must start with a letter. Cannot be the output of a formula or conflict with range syntax. All names only apply within the Formula (last) argument inside the LAMBDA."),
    NC_("ocLAMBDA", "Formula or Name "),
    NC_("ocLAMBDA", "A formula that uses any or (more likely) all of the names within the LAMBDA. This must be the last argument to LAMBDA. If more than one input is desired, more names can be provided, but the last argument must be the formula.")
};

// -=*# Resource for function ISOMITTED #*=-
const TranslateId ocIS_OMITTED_ARY[] =
{
    NC_("ocIS_OMITTED", "Reports whether a LAMBDA parameter was provided (FALSE) or omitted (TRUE). Only valid within a LAMBDA."),
    NC_("ocIS_OMITTED", "Name"),
    NC_("ocIS_OMITTED", "The name of the parameter to check.")
};

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */