Excel 2016 introduces fast MAXIFS and MINIFS functions. In versions earlier than Excel 2007, array formulas are often used to calculate a sum with multiple conditions. This is relatively easy to do, especially if you use the Conditional Sum Wizard in Excel, but it is often slow. Usually there are much faster ways of getting the same result. 2016-10-23 Word Mac 2016: Type words extremely slow with table in the same page Where someone posted a link to this Microsoft support article: How to use a 'clean startup' to determine whether background programs are interfering with Office for Mac It worked for me and the culprit item was Magnet.
Office 2016 for Mac is a version of Office that’s available as a one-time purchase from a retail store or through a volume licensing agreement. It will be supported with security updates and bug fixes, as needed, until October 13, 2020. The minimum supported macOS for Office 2016 for Mac is 10.10 (Yosemite).
Note
Updates for Office 2016 for Mac are available from Microsoft AutoUpdate (MAU). To use Microsoft AutoUpdate, start an Office application, such as Word, and then choose Help > Check for Updates. If you're an admin and want to update the computers in your organization with your existing software deployment tools, you can download and deploy the update packages for each application.
Most current packages for Office 2016 for Mac
The following table lists the most current packages for Office 2016 for Mac and for the individual applications, such as Word and Excel. All packages are 64-bit only. The build date is listed in parentheses, in a YYMMDD format, after the version number. The install package is used if you don't have the application already installed, while the update package is used to update an existing installation.
March 10, 2020
Version 16.16.20 (20030700)
March 2020 release
Release Date: March 10, 2020
Version 16.16.20 (Build 20030700)
This release provides the following updates.
February 2020 release
Release Date: February 11, 2020
Version 16.16.19 (Build 20021000)
This release provides the following updates.
January 2020 release![]()
Release Date: January 14, 2020
Version 16.16.18 (Build 20011202)
This release provides the following updates.
December 2019 release
Release Date: December 10, 2019
Version 16.16.17 (Build 19120800)
This release provides the following updates.
November 2019 release
Release Date: November 12, 2019
Version 16.16.16 (Build 19111100)
This release provides the following updates.
October 2019 release
Release Date: October 15, 2019
Version 16.16.15 (Build 19101400)
This release provides the following updates.
September 2019 release
Release Date: September 10, 2019
Version 16.16.14 (Build 19090900)
This release provides the following updates.
August 2019 release
Release Date: August 13, 2019
Version 16.16.13 (Build 19081100)
This release provides the following updates.
July 2019 release
Release Date: July 16, 2019
Version 16.16.12 (Build 19071500)
This release provides the following updates.
June 2019 release
Release Date: June 11, 2019
Version 16.16.11 (Build 19060902)
This release provides the following updates.
![]()
May 2019 release
Release Date: May 14, 2019
Version 16.16.10 (Build 19051200)
This release provides the following updates.
April 2019 release
Release Date: April 16, 2019
Version 16.16.9 (Build 19041201)
This release provides the following updates.
March 2019 release
Release Date: March 12, 2019
Version 16.16.8 (Build 19031202)
This release provides the following updates.
February 2019 release
Release Date: February 12, 2019
Version 16.16.7 (Build 19021001)
This release provides the following updates.
January 2019 release
Release Date: January 16, 2019
Version 16.16.6 (Build 19011400)
This release provides the following updates.
December 2018 release
Release Date: December 11, 2018
Version 16.16.5 (Build 18120801)
This release provides the following updates.
November 2018 release
Release Date: November 13, 2018
Version 16.16.4 (Build 18111001)
This release provides the following updates.
October 2018 release
Release Date: October 16, 2018
Version 16.16.3 (Build 18101500)
This release provides the following updates.
September 2018 release
Release Date: September 11, 2018
Version 16.16.2 (Build 18091001)
This release provides the following updates.
Applies to: Excel | Excel 2013 | Office 2016 | VBA
Follow these tips for optimizing many frequently occurring performance obstructions in Excel.
Optimize references and links
Learn how to improve performance related to types of references and links.
Do not use forward referencing and backward referencing
To increase clarity and avoid errors, design your formulas so that they do not refer forward (to the right or below) to other formulas or cells. Forward referencing usually does not affect calculation performance, except in extreme cases for the first calculation of a workbook, where it might take longer to establish a sensible calculation sequence if there are many formulas that need to have their calculation deferred.
Minimize use of circular references with iteration
Calculating circular references with iterations is slow because multiple calculations are needed, and these calculations are single-threaded. Frequently you can 'unroll' the circular references by using algebra so that iterative calculation is no longer needed. For example, in cash flow and interest calculations, try to calculate the cash flow before interest, calculate the interest, and then calculate the cash flow including the interest.
Excel calculates circular references sheet-by-sheet without considering dependencies. Therefore, you usually get slow calculation if your circular references span more than one worksheet. Try to move the circular calculations onto a single worksheet or optimize the worksheet calculation sequence to avoid unnecessary calculations.
Before the iterative calculations start, Excel must recalculate the workbook to identify all the circular references and their dependents. This process is equal to two or three iterations of the calculation.
After the circular references and their dependents are identified, each iteration requires Excel to calculate not only all the cells in the circular reference, but also any cells that depend on the cells in the circular reference chain, together with volatile cells and their dependents. If you have a complex calculation that depends on cells in the circular reference, it can be faster to isolate this into a separate closed workbook and open it for recalculation after the circular calculation has converged.
It is important to reduce the number of cells in the circular calculation and the calculation time that is taken by these cells.
Avoid links between workbooks
Avoid inter-workbook links when it is possible; they can be slow, easily broken, and not always easy to find and fix.
Using fewer larger workbooks is usually, but not always, better than using many smaller workbooks. Some exceptions to this might be when you have many front-end calculations that are so rarely recalculated that it makes sense to put them in a separate workbook, or when you have insufficient RAM.
Try to use simple direct cell references that work on closed workbooks. By doing this, you can avoid recalculating all your linked workbooks when you recalculate any workbook. Also, you can see the values Excel has read from the closed workbook, which is frequently important for debugging and auditing the workbook.
If you cannot avoid using linked workbooks, try to have them all open instead of closed, and open the workbooks that are linked to before you open the workbooks that are linked from.
Minimize links between worksheets
Using many worksheets can make your workbook easier to use, but generally it is slower to calculate references to other worksheets than references within worksheets.
Minimize the used range
To save memory and reduce file size, Excel tries to store information about only the area on a worksheet that was used. This is called the used range. Sometimes various editing and formatting operations extend the used range significantly beyond the range that you would currently consider used. This can cause performance obstructions and file-size obstructions.
You can check the visible used range on a worksheet by using Ctrl+End. Where this is excessive, you should consider deleting all the rows and columns below and to the right of your real last used cell, and then saving the workbook. Create a backup copy first. If you have formulas with ranges that extend into or refer to the deleted area, these ranges will be reduced in size or changed to #N/A.
Allow for extra data
When you frequently add rows or columns of data to your worksheets, you need to find a way of having your Excel formulas automatically refer to the new data area, instead of trying to find and change your formulas every time.
You can do this by using a large range in your formulas that extends well beyond your current data boundaries. However, this can cause inefficient calculation under certain circumstances, and it is difficult to maintain because deleting rows and columns can decrease the range without you noticing.
Use structured table references (recommended)
Starting in Excel 2007, you can use structured table references, which automatically expand and contract as the size of the referenced table increases or decreases.
This solution has several advantages:
Alternatively, use whole column and row references
An alternative approach is to use a whole column reference, for example $A:$A. This reference returns all the rows in Column A. Therefore, you can add as much data as you want, and the reference will always include it.
This solution has both advantages and disadvantages:
Alternatively, use dynamic ranges
By using the OFFSET or INDEX and COUNTA functions in the definition of a named range, you can make the area that the named range refers to dynamically expand and contract. For example, create a defined name using one of the following formulas:
When you use the dynamic range name in a formula, it automatically expands to include new entries.
Using the INDEX formula for a dynamic range is generally preferable to the OFFSET formula because OFFSET has the disadvantage of being a volatile function that will be calculated at every recalculation.
Performance decreases because the COUNTA function inside the dynamic range formula must examine many rows. You can minimize this performance decrease by storing the COUNTA part of the formula in a separate cell or defined name, and then referring to the cell or name in the dynamic range:
You can also use functions such as INDIRECT to construct dynamic ranges, but INDIRECT is volatile and always calculates single-threaded.
Dynamic ranges have the following advantages and disadvantages:
Improve lookup calculation time
In Office 365 version 1809 and later, Excel's VLOOKUP, HLOOKUP, and MATCH for exact match on unsorted data is much faster than ever before when looking up multiple columns (or rows with HLOOKUP) from the same table range.
That said, for earlier Excel versions, Lookups continue to be frequently significant calculation obstructions. Fortunately, there are many ways of improving lookup calculation time. If you use the exact match option, the calculation time for the function is proportional to the number of cells scanned before a match is found. For lookups over large ranges, this time can be significant.
Lookup time using the approximate match options of VLOOKUP, HLOOKUP, and MATCH on sorted data is fast and is not significantly increased by the length of the range you are looking up. Characteristics are the same as binary search.
Understand lookup options
Ensure that you understand the match-type and range-lookup options in MATCH, VLOOKUP, and HLOOKUP.
The following code example shows the syntax for the MATCH function. For more information, see the Match method of the WorksheetFunction object.
The following code example shows the syntax for the VLOOKUP and HLOOKUP functions. For more information, see the VLOOKUP and HLOOKUP methods of the WorksheetFunction object.
Avoid performing lookups on unsorted data where possible because it is slow. If your data is sorted, but you want an exact match, see Use two lookups for sorted data with missing values.
Use INDEX and MATCH or OFFSET instead of VLOOKUP
Try using the INDEX and MATCH functions instead of VLOOKUP. Although VLOOKUP is slightly faster (approximately 5 percent faster), simpler, and uses less memory than a combination of MATCH and INDEX, or OFFSET, the additional flexibility that MATCH and INDEX offer often enables you to significantly save time. For example, you can store the result of an exact MATCH in a cell and reuse it in several INDEX statements.
The INDEX function is fast and is a non-volatile function, which speeds up recalculation. The OFFSET function is also fast; however, it is a volatile function, and it sometimes significantly increases the time taken to process the calculation chain.
It is easy to convert VLOOKUP to INDEX and MATCH. The following two statements return the same answer:
Speed up lookups
Because exact match lookups can be slow, consider the following options for improving performance:
Use two lookups for sorted data with missing values
Two approximate matches are significantly faster than one exact match for a lookup over more than a few rows. (The breakeven point is about 10-20 rows.)
If you can sort your data but still cannot use approximate match because you cannot be sure that the value you are looking up exists in the lookup range, you can use this formula:
The first part of the formula works by doing an approximate lookup on the lookup column itself.
You can check if the answer from the lookup column is the same as the lookup value (in which case you have an exact match) by using the following formula:
If this formula returns True, you have found an exact match, so you can do the approximate lookup again, but this time, return the answer from the column you want.
If the answer from the lookup column did not match the lookup value, you have a missing value, and the formula returns 'notexist'.
Be aware that if you look up a value smaller than the smallest value in the list, you receive an error. You can handle this error by using IFERROR, or by adding a small test value to the list.
Use IFERROR function for unsorted data with missing values
If you must use exact match lookup on unsorted data, and you cannot be sure whether the lookup value exists, you often must handle the #N/A that is returned if no match is found. Beginning with Excel 2007, you can use the IFERROR function, which is both simple and fast.
In earlier versions, a simple but slow way is to use an IF function that contains two lookups.
You can avoid the double exact lookup if you use exact MATCH once, store the result in a cell, and then test the result before doing an INDEX.
If you cannot use two cells, use COUNTIF. It is generally faster than an exact match lookup.
Use MATCH and INDEX for exact match lookups on multiple columns
You can often reuse a stored exact MATCH many times. For example, if you are doing exact lookups on multiple result columns, you can save time by using one MATCH and many INDEX statements rather than many VLOOKUP statements.
Add an extra column for the MATCH to store the result (
stored_row ), and for each result column use the following:
Alternatively, you can use VLOOKUP in an array formula. (Array formulas must be entered by using Ctrl+-Shift+Enter. Excel will add the { and } to show you that this is an array formula).
Use INDEX for a set of contiguous rows or columns
You can also return many cells from one lookup operation. To look up several contiguous columns, you can use the INDEX function in an array formula to return multiple columns at once (use 0 as the column number). You can also use the INDEX function to return multiple rows at one time.
This returns column A to column J from the stored row created by a previous MATCH statement.
Use MATCH to return a rectangular block of cells
You can use the MATCH and OFFSET functions to return a rectangular block of cells.
Use MATCH and INDEX for two-dimensional lookup
You can efficiently do a two-dimensional table lookup by using separate lookups on the rows and columns of a table by using an INDEX function with two embedded MATCH functions, one for the row and one for the column.
Use a subset range for multiple-index lookup
In large worksheets, you may frequently need to look up by using multiple indexes, such as looking up product volumes in a country. To do this, you can concatenate the indexes and perform the lookup by using concatenated lookup values. However, this is inefficient for two reasons:
It is often more efficient to calculate a subset range for the lookup (for example, by finding the first and last row for the country, and then looking up the product within that subset range).
Consider options for three-dimensional lookup
To look up the table to use in addition to the row and the column, you can use the following techniques, focusing on how to make Excel look up or choose the table.
If each table that you want to look up (the third dimension) is stored as a set of named structured tables, range names, or as a table of text strings that represent ranges, you might be able to use the CHOOSE or INDIRECT functions.
Another technique is to aggregate all your tables into one giant table that has an additional column that identifies the individual tables. You can then use the techniques for multiple-index lookup shown in the previous examples.
Use wildcard lookup
The MATCH, VLOOKUP, and HLOOKUP functions allow you to use the wildcard characters ? (any single character) and * (no character or any number of characters) on alphabetical exact matches. Sometimes you can use this method to avoid multiple matches.
Optimize array formulas and SUMPRODUCT
Array formulas and the SUMPRODUCT function are powerful, but you must handle them carefully. A single array formula might require many calculations.
The key to optimizing the calculation speed of array formulas is to ensure that the number of cells and expressions that are evaluated in the array formula is as small as possible. Remember that an array formula is a bit like a volatile formula: if any one of the cells that it references has changed, is volatile, or has been recalculated, the array formula calculates all the cells in the formula and evaluates all the virtual cells it needs to do the calculation.
To optimize the calculation speed of array formulas:
Consider options for using SUM for multiple-condition array formulas
You should always use the SUMIFS, COUNTIFS, and AVERAGEIFS functions instead of array formulas where you can because they are much faster to calculate. Excel 2016 introduces fast MAXIFS and MINIFS functions.
In versions earlier than Excel 2007, array formulas are often used to calculate a sum with multiple conditions. This is relatively easy to do, especially if you use the Conditional Sum Wizard in Excel, but it is often slow. Usually there are much faster ways of getting the same result. If you have only a few multiple-condition SUMs, you may be able to use the DSUM function, which is much faster than the equivalent array formula.
If you must use array formulas, some good methods of speeding them up are as follows:
Prioritize multiple-condition SUMIFS, COUNTIFS, and other IFS family functions
These functions evaluate each of the conditions from left to right in turn. Therefore, it is more efficient to put the most restrictive condition first, so that subsequent conditions only need to look at the smallest number of rows.
Consider options for using SUMPRODUCT for multiple-condition array formulas
Starting in Excel 2007, you should always use the SUMIFS, COUNTIFS, and AVERAGEIFS functions, and in Excel 2016 MAXIFS and MINIFS functions, instead of SUMPRODUCT formulas where possible.
In earlier versions, there are a few advantages to using SUMPRODUCT instead of SUM array formulas:
You can use SUMPRODUCT for multiple-condition array formulas as follows:
In this example,
Condition1 and Condition2 are conditional expressions such as $A$1:$A$10000<=$Z4 . Because conditional expressions return True or False instead of numbers, they must be coerced to numbers inside the SUMPRODUCT function. You can do this by using two minus signs (--), or by adding 0 (+0), or by multiplying by 1 (x1). Using -- is slightly faster than +0 or x1.
Note that the size and shape of the ranges or arrays that are used in the conditional expressions and range to sum must be the same, and they cannot contain entire columns.
You can also directly multiply the terms inside SUMPRODUCT rather than separate them by commas:
This is usually slightly slower than using the comma syntax, and it gives an error if the range to sum contains a text value. However, it is slightly more flexible in that the range to sum may have, for example, multiple columns when the conditions have only one column.
Use SUMPRODUCT to multiply and add ranges and arrays
In cases like weighted average calculations, where you need to multiply a range of numbers by another range of numbers and sum the results, using the comma syntax for SUMPRODUCT can be 20 to 25 percent faster than an array-entered SUM.
These three formulas all produce the same result, but the third formula, which uses the comma syntax for SUMPRODUCT, takes only about 77 percent of the calculation time that the other two formulas need.
Be aware of potential array and function calculation obstructions
The calculation engine in Excel is optimized to exploit array formulas and functions that reference ranges. However, some unusual arrangements of these formulas and functions can sometimes, but not always, cause significantly increased calculation time.
If you find a calculation obstruction that involves array formulas and range functions, you should look for the following:
Use functions efficiently
Functions significantly extend the power of Excel, but the way in which you use them can often affect calculation time.
Avoid single-threaded functions
Most native Excel functions work well with multi-threaded calculation. However, where possible, avoid using the following single-threaded functions:
Use tables for functions that handle ranges
For functions like SUM, SUMIF, and SUMIFS that handle ranges, the calculation time is proportional to the number of used cells you are summing or counting. Unused cells are not examined, so whole column references are relatively efficient, but it is better to ensure that you do not include more used cells than you need. Use tables, or calculate subset ranges or dynamic ranges.
Reduce volatile functions
Volatile functions can slow recalculation because they increase the number of formulas that must be recalculated at each calculation.
You can often reduce the number of volatile functions by using INDEX instead of OFFSET, and CHOOSE instead of INDIRECT. However, OFFSET is a fast function and can often be used in creative ways that give fast calculation.
Use C or C++ user-defined functions
User-defined functions that are programmed in C or C++ and that use the C API (XLL add-in functions) generally perform faster than user-defined functions that are developed by using VBA or Automation (XLA or Automation add-ins). For more information, see Developing Excel 2010 XLLs.
The performance of VBA user-defined functions is sensitive to how you program and call them.
Use faster VBA user-defined functions
It is usually faster to use the Excel formula calculations and worksheet functions than to use VBA user-defined functions. This is because there is a small overhead for each user-defined function call and significant overhead transferring information from Excel to the user-defined function. But well-designed and called user-defined functions can be much faster than complex array formulas.
Ensure that you have put all the references to worksheet cells in the user-defined function input parameters instead of in the body of the user-defined function, so that you can avoid adding Application.Volatile unnecessarily.
If you must have many formulas that use user-defined functions, ensure that you are in manual calculation mode, and that the calculation is initiated from VBA. VBA user-defined functions calculate much more slowly if the calculation is not called from VBA (for example, in automatic mode or when you press F9 in manual mode). This is particularly true when the Visual Basic Editor (Alt+F11) is open or has been opened in the current Excel session.
You can trap F9 and redirect it to a VBA calculation subroutine as follows. Add this subroutine to the Thisworkbook module.
Add this subroutine to a standard module.
User-defined functions in Automation add-ins (Excel 2002 and later versions) do not incur the Visual Basic Editor overhead because they do not use the integrated editor. Other performance characteristics of Visual Basic 6 user-defined functions in Automation add-ins are similar to VBA functions.
If your user-defined function processes each cell in a range, declare the input as a range, assign it to a variant that contains an array, and loop on that. If you want to handle whole column references efficiently, you must make a subset of the input range, dividing it at its intersection with the used range, as in this example.
If your user-defined function is using worksheet functions or Excel object model methods to process a range, it is generally more efficient to keep the range as an object variable than to transfer all the data from Excel to the user-defined function.
If your user-defined function is called early in the calculation chain, it can be passed as uncalculated arguments. Inside a user-defined function, you can detect uncalculated cells by using the following test for empty cells that contain a formula:
A time overhead exists for each call to a user-defined function and for each transfer of data from Excel to VBA. Sometimes one multi-cell array formula user-defined function can help you minimize these overheads by combining multiple function calls into a single function with a multi-cell input range that returns a range of answers.
Minimize range of cells that SUM and SUMIF reference
The Excel SUM and SUMIF functions are frequently used over a large number of cells. Calculation time for these functions is proportionate to the number of cells covered, so try to minimize the range of cells that the functions are referencing.
Use wildcard SUMIF, COUNTIF, SUMIFS, COUNTIFS, and other IFS functionsMicrosoft Excel 2016 Mac Slow Download
You can use the wildcard characters ? (any single character) and * (no character or any number of characters) in the criteria for alphabetical ranges as part of the SUMIF, COUNTIF, SUMIFS, COUNTIFS, and other IFS functions.
Choose method for period-to-date and cumulative SUMs
There are two methods of doing period-to-date or cumulative SUMs. Suppose the numbers that you want to cumulatively SUM are in column A, and you want column B to contain the cumulative sum; you can do either of the following:
For 1,000 rows, the first method makes Excel do about 500,000 calculations, but the second method makes Excel do only about 2,000 calculations.
Calculate subset sums
When you have multiple sorted indexes to a table (for example, Site within Area) you can often save significant calculation time by dynamically calculating the address of a subset range of rows (or columns) to use in the SUM or SUMIF function.
To calculate the address of a subset range of row or columns:
Use SUBTOTAL for filtered lists
Use the SUBTOTAL function to SUM filtered lists. The SUBTOTAL function is useful because, unlike SUM, it ignores the following:
Use the AGGREGATE function
The AGGREGATE function is a powerful and efficient way of calculating 19 different methods of aggregating data (such as SUM, MEDIAN, PERCENTILE and LARGE). AGGREGATE has options for ignoring hidden or filtered rows, error values, and nested SUBTOTAL and AGGREGATE functions.
Avoid using DFunctions
The DFunctions DSUM, DCOUNT, DAVERAGE, and so on are significantly faster than equivalent array formulas. The disadvantage of the DFunctions is that the criteria must be in a separate range, which makes them impractical to use and maintain in many circumstances. Starting in Excel 2007, you should use SUMIFS, COUNTIFS, and AVERAGEIFS functions instead of the DFunctions.
Create faster VBA macros
Use the following tips to create faster VBA macros.
Turn off everything but the essentials while code is running
To improve performance for VBA macros, explicitly turn off the functionality that is not required while your code executes. Often, one recalculation or one redraw after your code runs is all that is necessary and can improve performance. After your code executes, restore the functionality to its original state.
The following functionality can usually be turned off while your VBA macro executes:
Important
Remember to restore this functionality to its original state after your code executes.
The following example shows the functionality that you can turn off while your VBA macro executes.
Read and write large blocks of data in a single operation
Optimize your code by explicitly reducing the number of times data is transferred between Excel and your code. Instead of looping through cells one at a time to get or set a value, get or set the values in the entire range of cells in one line, using a variant containing a two-dimensional array to store values as needed. The following code examples compare these two methods.
The following code example shows non-optimized code that loops through cells one at a time to get and set the values of cells A1:C10000. These cells do not contain formulas.
The following code example shows optimized code that uses an array to get and set the values of cells A1:C10000 all at the same time. These cells do not contain formulas.
Use .Value2 rather than .Value or .Text when reading data from an Excel range
Avoid selecting and activating objects
Selecting and activating objects is more processing intensive than referencing objects directly. By referencing an object such as a Range or a Shape directly, you can improve performance. The following code examples compare the two methods.
The following code example shows non-optimized code that selects each Shape on the active sheet and changes the text to 'Hello'.
The following code example shows optimized code that references each Shape directly and changes the text to 'Hello'.
Use these additional VBA performance optimizations
The following is a list of additional performance optimizations you can use in your VBA code:
Consider performance and size of Excel file formats
Starting in Excel 2007, Excel contains a wide variety of file formats compared to earlier versions. Ignoring the Macro, Template, Add-in, PDF, and XPS file format variations, the three main formats are XLS, XLSB, and XLSX.
Open, close, and save workbooks
You may find that opening, closing, and saving workbooks is much slower than calculating them. Sometimes this is just because you have a large workbook, but there can also be other reasons.
If one or more of your workbooks open and close more slowly than is reasonable, it might be caused by one of the following issues.
An easy way to open your temp directory is from the Windows Start menu: Click Start, and then click Run. In the text box, type %temp%, and then click OK.
Make additional performance optimizations
You can make performance improvements in the following areas.
Microsoft Excel 2016 Mac Slow Motion
Conclusion
This article covered ways to optimize Excel functionality such as links, lookups, formulas, functions, and VBA code to avoid common obstructions and improve performance.
Microsoft Excel 2016 Mac Slow CookerSee alsoSupport and feedbackMicrosoft Excel 2016 Mac Slow Download
Have questions or feedback about Office VBA or this documentation? Please see Office VBA support and feedback for guidance about the ways you can receive support and provide feedback.
Comments are closed.
|
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |