Help with max rows of a million+

cspengel

Board Regular
Joined
Oct 29, 2022
Messages
173
Office Version
  1. 365
  2. 2021
Platform
  1. Windows
Back again...

I need assistance with my macro as I am running into issues with the max rows exceeding 1,048,576.

The macros current method in order:

-writes a combination of names
-once names are written, it then copies those names into helper columns and replaces the names with a salary
-adds salary together in a new column
-sorts names in order
-removes duplicates

I have enough filters where the number of rows in the end will never exceed 1,048,576...however the macro still has to "write" the names and salaries to determine if it meets criteria. The removal of duplicates and salary over 60000 doesn't occur until after all the combinations are all written. Is there any way for me to continue with the rest of code if max rows written is reached and then loop back to start writing the combinations again... Thanks for any assistance


VBA Code:
Public CalcState As Long
Public EventState As Boolean
Public PageBreakState As Boolean

Sub OptimizeCode_Begin()

Application.ScreenUpdating = False

EventState = Application.EnableEvents
Application.EnableEvents = False

CalcState = Application.Calculation
Application.Calculation = xCalculationManual

PageBreakState = ActiveSheet.DisplayPageBreaks
ActiveSheet.DisplayPageBreaks = False

End Sub

Sub OptimizeCode_End()

ActiveSheet.DisplayPageBreaks = PageBreakState
Application.Calculation = CalcState
Application.EnableEvents = EventState
Application.ScreenUpdating = True

End Sub


Sub NameCombos()
    'https://www.mrexcel.com/forum/excel-questions/1106189-all-combinations-multiple-columns-without-duplicates.html
    
    Dim lLastColumn As Long
    Dim lLastUsedColumn As Long
    Dim aryNames As Variant
    Dim lColumnIndex As Long
    Dim lWriteRow As Long
    Dim bCarry As Boolean
    Dim lWriteColumn As Long
    Dim rngWrite As Range
    Dim lFirstWriteColumn As Long
    Dim lLastWriteColumn As Long
    Dim oFound As Object
    Dim lRefColumn As Long
    Dim lInUseRow As Long
    Dim lCarryColumn As Long
    Dim lPrint As Long
    Dim lLastIteration As Long
    Dim lIterationCount As Long
    Dim sErrorMsg As String
    Dim bShowError As Boolean
    Dim lLastRow As Long
    Dim lLastRowDeDuped As Long
    Dim aryDeDupe As Variant
    Dim s As Long
    Dim sRow As Long
    Dim x As Long
    Dim wksData As Worksheet
    Dim rngDataBlock As Range
    Dim lngLastRow As Long, lngLastCol As Long
    
    Dim sName As String
    Dim bDupeName As Boolean
    
    Dim oSD As Object
    Dim rngCell As Range
    Dim varK As Variant, varI As Variant, varTemp As Variant, lIndex As Long
    Dim lRowIndex As Long
    Dim lRowIndex2 As Long
    Dim rngSortRange As Range
    Dim dteStart As Date
    Dim sOutput As String
    Dim lFirstHSortColumn As Long
    Dim lFirstHSortColumn2 As Long
    Dim lFirstHTeamCol As Long
    Dim firstrow As Long
    Dim v
    Dim lLastHTeamCol As Long
    Dim currow As Long
    Dim diff As Long
    Dim lLastHSortColumn As Long
    Dim lLastHSortColumn2 As Long
    Dim lLastSalaryRow As Long
    Dim rngReplace As Range
    Dim wks As Worksheet
    Dim bFoundSalary As Boolean
    Dim sMissingSalary As String
    Dim names As Worksheet

    
    Call OptimizeCode_Begin
    
    Application.StatusBar = False
    Set wksData = ThisWorkbook.Sheets("Worksheet")
    Set names = Sheets("Salary")
    'Check for salary worksheet
    For Each wks In ThisWorkbook.Worksheets
        If wks.Name = "Salary" Then bFoundSalary = True
    Next
    If Not bFoundSalary Then
        MsgBox "The workbook must contain a worksheet named 'Salary' with data starting in row 2 " & _
            "that consists of column A containing each name in the name/column layout worksheet " & _
            "and column B containng their salary."
        GoTo End_Sub
    End If
    
    'Make sure each name has a corresponding salary entry
    'Initialize the scripting dictionary
    Set oSD = CreateObject("Scripting.Dictionary")
    oSD.CompareMode = vbTextCompare
    'Inventory names on the main worksheet
    For Each rngCell In ActiveSheet.Range("A1").CurrentRegion.Offset(1, 0)
        rngCell.Value = Trim(rngCell.Value)
        If rngCell.Value <> vbNullString Then
            oSD.Item(rngCell.Value) = oSD.Item(rngCell.Value) + 1
        End If
    Next
    'Remove names on the Salary worksheet
    With Worksheets("Salary")
        For Each rngCell In .Range("A2:A" & .Cells(Rows.Count, 1).End(xlUp).Row)
            rngCell.Value = Trim(rngCell.Value)
            If oSD.exists(rngCell.Value) Then
                oSD.Remove rngCell.Value
            End If
        Next
    End With
    
    'Any names not accounted for?
    If oSD.Count <> 0 Then
        varK = oSD.keys
        For lIndex = LBound(varK) To UBound(varK)
            sMissingSalary = sMissingSalary & ", " & varK(lIndex)
        Next
        sMissingSalary = Mid(sMissingSalary, 3)
        sOutput = "The following names on the main worksheet do not have a corresponding entry on the 'Salary' worksheet." & vbLf & vbLf & _
            sMissingSalary
        MsgBox sOutput
        Debug.Print sOutput
        GoTo End_Sub
    End If
    
    sErrorMsg = "Ensure a Worksheet is active with a header row starting in A1" & _
        "and names under each header entry."
    
    If TypeName(ActiveSheet) <> "Worksheet" Then
        bShowError = True
    End If
    
    If bShowError Then
        MsgBox sErrorMsg, , "Problems Found in Data"
        GoTo End_Sub
    End If
    
    lLastColumn = Range("A1").CurrentRegion.Columns.Count
    lLastUsedColumn = ActiveSheet.UsedRange.Columns.Count
    ReDim aryNames(1 To 2, 1 To lLastColumn)    '1 holds the in-use entry row
                                                
    'How many combinations? (Order does not matter)
    lLastIteration = 1
    For lColumnIndex = 1 To lLastColumn
        aryNames(1, lColumnIndex) = 2
        aryNames(2, lColumnIndex) = Cells(Rows.Count, lColumnIndex).End(xlUp).Row
        lLastIteration = lLastIteration * (aryNames(2, lColumnIndex) - 1)
    Next
    
    lRefColumn = lLastColumn + 1
    lFirstWriteColumn = lLastColumn + 2
    lLastWriteColumn = (2 * lLastColumn) + 1
    
    Select Case MsgBox("Process a " & lLastColumn & " column table with " & _
        lLastIteration & " possible combinations?" & vbLf & vbLf & _
        "WARNING: Columns right of the input range will be erased before continuing.", vbOKCancel + vbCritical + _
        vbDefaultButton2, "Process table?")
    Case vbCancel
        GoTo End_Sub
    End Select
    
    dteStart = Now()
    
    'Clear all columns right of input range
    If lLastUsedColumn > lLastColumn Then
        Range(Cells(1, lLastColumn + 1), Cells(1, lLastUsedColumn)).EntireColumn.ClearContents
    End If
    Cells(1, lLastWriteColumn + 1).Value = "ComboID"
    
    'Add Output Header
    Range(Cells(1, 1), Cells(1, lLastColumn)).Copy Destination:=Cells(1, lFirstWriteColumn)
    
    'Start checking combinations
    lWriteRow = 2
    For lIterationCount = 1 To lLastIteration
        If lIterationCount / 1000 = lIterationCount \ 1000 Then Application.StatusBar = _
            lIterationCount & " / " & lLastIteration
            
        'Reset the Dupe Name flag
        bDupeName = False
        
        'Check Active Combo for Dupe Names
        'Initialize the scripting dictionary
        Set oSD = CreateObject("Scripting.Dictionary")
        oSD.CompareMode = vbTextCompare
        
        'Load names into scripting dictionary
        For lColumnIndex = lLastColumn To 1 Step -1
            sName = Cells(aryNames(1, lColumnIndex), lColumnIndex).Value
            oSD.Item(sName) = oSD.Item(sName) + 1
        Next
        
        'If there are names, and at least one duplicate, set the bDupeName flag
        If oSD.Count > 0 Then
            varK = oSD.keys
            varI = oSD.Items
            For lIndex = 1 To oSD.Count
                If varI(lIndex - 1) > 1 Then
                    bDupeName = True: Exit For
                End If
            Next
        End If
        
        
        If Not bDupeName Then
            'The current row had names and no duplicates
            'Print Active Combo to the lWriteRow row
            For lColumnIndex = lLastColumn To 1 Step -1
                lWriteColumn = lColumnIndex + lLastColumn + 2
                Set rngWrite = Range(Cells(lWriteRow, lFirstWriteColumn), Cells(lWriteRow, lLastWriteColumn))
                Cells(lWriteRow, lRefColumn + lColumnIndex).Value = Cells(aryNames(1, lColumnIndex), lColumnIndex).Value
            Next
            
            'Uncomment next row to see the lIterationCount for the printed row
            Cells(lWriteRow, lLastWriteColumn + 1).Value = lIterationCount
            
            'Point to the next blank row
            lWriteRow = lWriteRow + 1
            
        End If
    
        'Increment Counters
        'Whether the line had duplicates or not, move to the next name in the
        '  rightmost column, if it was ag the last name, go to the first name in that column and
        '  move the name in the column to the left down to the next name (recursive check if THAT
        '  column was already using the last name for remaining columns to the left)
        aryNames(1, lLastColumn) = aryNames(1, lLastColumn) + 1
        If aryNames(1, lLastColumn) > aryNames(2, lLastColumn) Then
            bCarry = True
            lCarryColumn = lLastColumn
            Do While bCarry = True And lCarryColumn > 0
                aryNames(1, lCarryColumn) = 2
                bCarry = False
                lCarryColumn = lCarryColumn - 1
                If lCarryColumn = 0 Then Exit Do
                aryNames(1, lCarryColumn) = aryNames(1, lCarryColumn) + 1
                If aryNames(1, lCarryColumn) > aryNames(2, lCarryColumn) Then bCarry = True
            Loop
        End If
        
        'Check counter values (for debug)
'        Debug.Print lWriteRow,
'        For lPrint = 1 To lLastColumn
'            Debug.Print aryNames(1, lPrint) & ", ";
'        Next
'        Debug.Print
        DoEvents
    Next
    
    Application.StatusBar = "Sorting"
    Application.ScreenUpdating = False
    
    'Copy row names to right so that each copied row can be sorted alphabetically left to right
    '  this will allow the Excel remove duplicate fuction to remove rows that have identical names
    '  in all of their sorted columns.
    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
    Range(Cells(1, lFirstWriteColumn), Cells(lLastRow, lLastWriteColumn)).Copy Destination:=Cells(1, lLastWriteColumn + 2) ''SALARY
    lFirstHSortColumn = lLastWriteColumn + 2
    lLastHSortColumn = Cells(1, Columns.Count).End(xlToLeft).Column
    
    Range(Cells(1, lFirstWriteColumn), Cells(lLastRow, lLastWriteColumn)).Copy Destination:=Cells(1, lLastHSortColumn + 1) ''PROJECTION
    lFirstHSortColumn2 = lLastHSortColumn + 1
    lLastHSortColumn2 = Cells(1, Columns.Count).End(xlToLeft).Column
     
    Range(Cells(1, lFirstWriteColumn), Cells(lLastRow, lLastWriteColumn)).Copy Destination:=Cells(1, lLastHSortColumn2 + 1) ''TEAM
    lFirstHTeamCol = lLastHSortColumn2 + 1
    lLastHTeamCol = Cells(1, Columns.Count).End(xlToLeft).Column
     
        
    
       'Assumes the 'Salary' worksheet has names in the column A and salaries in column B starting in row 2
    'Replace HSort names with salary
    With Worksheets("Salary") '''' SALARY
        lLastSalaryRow = .Cells(.Rows.Count, 1).End(xlUp).Row
    End With
    Set rngReplace = Range(Cells(2, lFirstHSortColumn), Cells(lLastRow, lLastHSortColumn))
    For lRowIndex = 2 To lLastSalaryRow
        rngReplace.Replace What:=Worksheets("Salary").Cells(lRowIndex, 1).Value, _
            Replacement:=Worksheets("Salary").Cells(lRowIndex, 2).Value, LookAt:=xlWhole, _
            SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, _
            ReplaceFormat:=False
     Next
     lLastRowDeDuped = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
     'Add Sum Column
   Cells(1, lLastHTeamCol + 1).Value = ChrW(931) & " Salary"
    With Range(Cells(2, lLastHTeamCol + 1), Cells(lLastRowDeDuped, lLastHTeamCol + 1))
        .FormulaR1C1 = "=SUM(RC" & lFirstHSortColumn & ":RC" & lLastHSortColumn & ")"
        Application.Calculate
        .Value = .Value
        End With
        
   lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
        
        With wksData
        .Range("A2:I26").Cut names.Range("G2")
        Application.CutCopyMode = False
      End With
        With wksData
        'Start from cell A1 (1, 1) and assign to the last row and last column
        Set rngDataBlock = .Range(.Cells(1, lLastHTeamCol + 1), .Cells(lLastRow, lLastHTeamCol + 1))
    End With
        x = 60000
        Application.DisplayAlerts = False
        With rngDataBlock
            .AutoFilter Field:=1, Criteria1:=">" & x
            On Error Resume Next
            .Range(Cells(2, lFirstWriteColumn), Cells(lLastRow, lLastHTeamCol + 9)).Delete Shift:=xlUp
        End With
    Application.DisplayAlerts = True
    
    With names
    .Range("G2:O26").Cut wksData.Range("A2")
    Application.CutCopyMode = False
    End With

     
    'Turn off the Autofilter safely
    With wksData
        .AutoFilterMode = False
        If .FilterMode = True Then
            .ShowAllData
        End If
    End With
      
     
    'Sort each row
    Application.ScreenUpdating = False
    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
    For lRowIndex = 2 To lLastRow
        Set rngSortRange = Range(Cells(lRowIndex, lFirstHSortColumn), Cells(lRowIndex, lLastHSortColumn))
        ActiveSheet.Sort.SortFields.Clear
        ActiveSheet.Sort.SortFields.Add Key:=rngSortRange, _
            SortOn:=xlSortOnValues, Order:=xlAscending, DataOption:=xlSortNormal
        With ActiveSheet.Sort
            .SetRange rngSortRange
            .Header = xlNo
            .MatchCase = False
            .Orientation = xlLeftToRight
            .SortMethod = xlPinYin
            .Apply
        End With
    Next
    
    'Check for duplicate rows in HSort Columns
    '  Can only happen if names are duplicated within an input column
    '  Build aryDeDupe  -- Array(1, 2, 3,...n)  -- to exclude iteration # column

    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
    ReDim aryDeDupe(0 To lLastHSortColumn - lFirstHSortColumn)
    lIndex = 0
    For lColumnIndex = lFirstHSortColumn To lLastHSortColumn
        aryDeDupe(lIndex) = CInt(lColumnIndex - lFirstWriteColumn + 1)
        lIndex = lIndex + 1
    Next
    ActiveSheet.Cells(1, lFirstWriteColumn).CurrentRegion.RemoveDuplicates Columns:=(aryDeDupe), Header:=xlYes
    'Above line won't work unless there are parens around the Columns argument ?????
    
    lLastRowDeDuped = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
    
    
     '''''''''''''''''''''''''''''''''''''PROJECTION
     With Worksheets("Salary")
        lLastSalaryRow = .Cells(.Rows.Count, 1).End(xlUp).Row
    End With
    Set rngReplace = Range(Cells(2, lFirstHSortColumn2), Cells(lLastRow, lLastHSortColumn2))
    For lRowIndex2 = 2 To lLastSalaryRow
        rngReplace.Replace What:=Worksheets("Salary").Cells(lRowIndex2, 1).Value, _
            Replacement:=Worksheets("Salary").Cells(lRowIndex2, 3).Value, LookAt:=xlWhole, _
            SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, _
            ReplaceFormat:=False
    Next '''''''''''''''''''''''''''
    
         '''''''''''''''''''''''''''''''''''''TEAM
     With Worksheets("Salary")
        lLastSalaryRow = .Cells(.Rows.Count, 1).End(xlUp).Row
    End With
    Set rngReplace = Range(Cells(2, lFirstHTeamCol), Cells(lLastRow, lLastHTeamCol))
    For lRowIndex2 = 2 To lLastSalaryRow
        rngReplace.Replace What:=Worksheets("Salary").Cells(lRowIndex2, 1).Value, _
            Replacement:=Worksheets("Salary").Cells(lRowIndex2, 4).Value, LookAt:=xlWhole, _
            SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, _
            ReplaceFormat:=False
    Next '''''''''''''''''''''''''''
    
    
    ''Add Projection Column
    Cells(1, lLastHTeamCol + 2).Value = ChrW(931) & " Projection"
    With Range(Cells(2, lLastHTeamCol + 2), Cells(lLastRowDeDuped, lLastHTeamCol + 2))
        .FormulaR1C1 = "=SUM(RC" & lFirstHSortColumn2 & ":RC" & lLastHSortColumn2 & ")"
        Application.Calculate
        .Value = .Value
    End With
    
     ''Add Team Stack Column
    Cells(1, lLastHTeamCol + 3).Value = ChrW(931) & " Stack"
    With Range(Cells(2, lLastHTeamCol + 3), Cells(lLastRowDeDuped, lLastHTeamCol + 3))
        .FormulaR1C1 = "=INDEX(RC" & lFirstHTeamCol & ":RC" & lLastHTeamCol & ",MODE(MATCH(RC" & lFirstHTeamCol & ":RC" & lLastHTeamCol & ",RC" & lFirstHTeamCol & ":RC" & lLastHTeamCol & ",0)))"
        Application.Calculate
        .Value = .Value
    End With
    
    ''Add Team Stack Pos
    Cells(1, lLastHTeamCol + 4).Value = ChrW(931) & " Stack POS"
    With Range(Cells(2, lLastHTeamCol + 4), Cells(lLastRowDeDuped, lLastHTeamCol + 4))
    
    .Formula2R1C1 = "=TEXTJOIN("","",1,IF(RC[-12]:RC[-4]=RC[-1],R1C[-12]:R1C[-4],""""))"
        Application.Calculate
        .Value = .Value
    End With
    
    ''Add 2nd Team Stack Column
    Cells(1, lLastHTeamCol + 5).Value = ChrW(931) & " Stack2"
    With Range(Cells(2, lLastHTeamCol + 5), Cells(lLastRowDeDuped, lLastHTeamCol + 5))
        .Formula2R1C1 = "=IFERROR(INDEX(RC[-13]:RC[-5],MODE(IF((RC[-13]:RC[-5]<>"""")*(RC[-13]:RC[-5]<>INDEX(RC[-13]:RC[-5],MODE(IF(RC[-13]:RC[-5]<>"""",MATCH(RC[-13]:RC[-5],RC[-13]:RC[-5],0))))),MATCH(RC[-13]:RC[-5],RC[-13]:RC[-5],0)))),"""")"
        Application.Calculate
        .Value = .Value
    End With
    
    ''Add 2nd Team Stack Pos
    Cells(1, lLastHTeamCol + 6).Value = ChrW(931) & " Stack2 POS"
    With Range(Cells(2, lLastHTeamCol + 6), Cells(lLastRowDeDuped, lLastHTeamCol + 6))
    
    .Formula2R1C1 = "=TEXTJOIN("","",1,IF(RC[-12]:RC[-4]=RC[-1],R1C[-12]:R1C[-4],""""))"
        Application.Calculate
        .Value = .Value
    End With
    
    'Filter 0-1
    Cells(1, lLastHTeamCol + 7).Value = ChrW(931) & " Filter"
    With Range(Cells(2, lLastHTeamCol + 7), Cells(lLastRowDeDuped, lLastHTeamCol + 7))
    
    End With
    
    'Player 1 Filter
    Cells(1, lLastHTeamCol + 8).Value = ChrW(931) & " Player1"
    With Range(Cells(2, lLastHTeamCol + 8), Cells(lLastRowDeDuped, lLastHTeamCol + 8))
    
    End With
    
    'Player 2 Filter
    Cells(1, lLastHTeamCol + 9).Value = ChrW(931) & " Player2"
    With Range(Cells(2, lLastHTeamCol + 9), Cells(lLastRowDeDuped, lLastHTeamCol + 9))
    
    End With
   
    
    'Remove Salary Columns
    Range(Cells(2, lFirstHSortColumn), Cells(lLastRowDeDuped, lLastHTeamCol)).EntireColumn.Delete

    
    
    sOutput = lLastIteration & vbTab & " possible combinations" & vbLf & _
        lLastRow - 1 & vbTab & " unique name combinations" & vbLf & _
        IIf(lLastRowDeDuped <> lLastRow, lLastRow - lLastRowDeDuped & vbTab & " duplicate rows removed." & vbLf, "") & _
        lLastRowDeDuped - 1 & vbTab & " printed." & vbLf & vbLf & _
        Format(Now() - dteStart, "hh:mm:ss") & " to process."
    
    ActiveSheet.UsedRange.Columns.AutoFit
    MsgBox sOutput, , "Output Report"
    Debug.Print sOutput
        
End_Sub:
    Call OptimizeCode_End
    Application.StatusBar = False
    
End Sub
 
So I redeclared varK As variant.

changed this:

VBA Code:
 If oSD.Count <> 0 Then
        For lIndex = LBound(oSD.keys) To UBound(oSD.keys)
            sMissingSalary = sMissingSalary & ", " & oSD.keys(lIndex)
        Next

Back to this

VBA Code:
If oSD.Count <> 0 Then
        varK = oSD.keys
        For lIndex = LBound(varK) To UBound(varK)
            sMissingSalary = sMissingSalary & ", " & varK(lIndex)
        Next

and the error goes away and popup box comes back.
 
Upvote 0

Excel Facts

Show numbers in thousands?
Use a custom number format of #,##0,K. Each comma after the final 0 will divide the displayed number by another thousand
I'll make a note of that, I don't understand the difference, but it is noted.
 
Upvote 0
I'll make a note of that, I don't understand the difference, but it is noted.
Well I also changed your call to Optimize end as it doesn't appear to direct to to End the sub.

Changed

VBA Code:
 MsgBox sOutput
        Debug.Print sOutput
Call OptimizeCode_End


To
VBA Code:
 MsgBox sOutput
        Debug.Print sOutput
'
        GoTo End_Sub


And re-added to the bottom
VBA Code:
End_Sub:
    Call OptimizeCode_End
   
End Sub

Maybe that did it. :unsure:
 
Upvote 0
No, that didn't do it, but I made a note of that also. Good catch! Anything else I messed up?
 
Upvote 0
The error you received there is probably from too many combinations ie. >1048576 trying to be written to the sheet.

I have an idea that may work, but I have to think about it.
Ok, I have most of it Pseudocoded, After I get some sleep I will try to see if it works when it is actually coded.
 
Upvote 0
To give you something to chew on while I mess with a lil bit more of the code:

VBA Code:
Option Explicit

Public EventState       As Boolean
Public PageBreakState   As Boolean
Public CalcState        As Long


Private Sub OptimizeCode_Begin()
'
    With Application
             CalcState = .Calculation
            EventState = .EnableEvents
        PageBreakState = ActiveSheet.DisplayPageBreaks
'
             .StatusBar = False
           .Calculation = xlManual
          .EnableEvents = False
        .ScreenUpdating = False
        ActiveSheet.DisplayPageBreaks = False
    End With
End Sub


Private Sub OptimizeCode_End()
'
    With Application
        ActiveSheet.DisplayPageBreaks = PageBreakState
                        .EnableEvents = EventState
                         .Calculation = CalcState
'
                      .ScreenUpdating = True
                           .StatusBar = False
    End With
End Sub


Sub NameCombosV11()
    'https://www.mrexcel.com/forum/excel-questions/1106189-all-combinations-multiple-columns-without-duplicates.html
'
    Dim bFoundSalary                    As Boolean
    Dim bShowError                      As Boolean
    Dim dteStart                        As Date
    Dim StartTime                       As Date
    Dim ArrayRow                        As Long, ArrayColumn                    As Long
    Dim ColumnA_Row                     As Long, ColumnB_Row                    As Long, ColumnC_Row                    As Long
    Dim ColumnD_Row                     As Long, ColumnE_Row                    As Long, ColumnF_Row                    As Long
    Dim ColumnG_Row                     As Long, ColumnH_Row                    As Long, ColumnI_Row                    As Long
    Dim ColumnNumber                    As Long
    Dim currow                          As Long
    Dim firstrow                        As Long, lLastRow                       As Long
    Dim lColumnIndex                    As Long
    Dim lFirstHSortColumn               As Long, lFirstHSortColumn2             As Long
    Dim lFirstHTeamCol                  As Long, lLastHTeamCol                  As Long
    Dim lFirstWriteColumn               As Long, lLastWriteColumn               As Long
    Dim lIndex                          As Long
    Dim lIterationCount                 As Long, lLastIteration                 As Long
    Dim lLastColumn                     As Long
    Dim lLastHSortColumn                As Long, lLastHSortColumn2              As Long
    Dim lLastRowDeDuped                 As Long
    Dim lLastSalaryRow                  As Long
    Dim lLastUsedColumn                 As Long
    Dim lRowIndex                       As Long
    Dim lWriteColumn                    As Long, lWriteRow                      As Long
    Dim MaxSalaryAllowed                As Long
    Dim SubArrayNumber                  As Long
    Dim SubArrayRow                     As Long
    Dim SubArrays                       As Long
    Dim UniqueArrayRow                  As Long
    Dim x                               As Long
    Dim oSD                             As Object
    Dim cel                             As Range
    Dim rngDataBlock                    As Range
    Dim rngReplace                      As Range, rngReplace2                   As Range, rngReplace3                   As Range
    Dim rngSortRange                    As Range
    Dim SortRowRange                    As Range
    Dim WorksheetNameRange              As Range
    Dim Delimiter                       As String
    Dim oSD_KeyString                   As String
    Dim sErrorMsg                       As String
    Dim sMissingSalary                  As String
    Dim sOutput                         As String
    Dim arrOut()                        As Variant
    Dim aryDeDupe                       As Variant
    Dim aryNames                        As Variant
    Dim JaggedArray()                   As Variant
    Dim keysArray                       As Variant
    Dim NoDupeRowArray()                As Variant, NoDupeRowShortenedArray()   As Variant
    Dim NoDupeSortedRowsArray()         As Variant
    Dim SalaryCalculationArray()        As Variant
    Dim SalarySheetFullArray            As Variant, SalarySheetShortenedArray() As Variant
    Dim TempArray                       As Variant
    Dim UniqueSortedRowsArray           As Variant, UniqueUnSortedRowsArray()   As Variant
    Dim UniqueWorksheetNamesArray       As Variant
    Dim varK                            As Variant
    Dim WorksheetArray                  As Variant
    Dim WorksheetColumnArray()          As Variant
    Dim names                           As Worksheet
    Dim wks                             As Worksheet
    Dim wksData                         As Worksheet
'
    Const MaxRowsPerSubArray            As Long = 500000                                                                        ' <--- Set the MaxRowsPerSubArray
'
'-------------------------------------------------------------------------------------------------------------------------------
'
    MaxSalaryAllowed = 60000                                                                                                    ' <--- set this value to what you want
'
    Call OptimizeCode_Begin
'
    Set wksData = ThisWorkbook.Sheets("Worksheet")
    Set names = Sheets("Salary")
'
'-------------------------------------------------------------------------------------------------------------------------------
'
' 1) Take all the names entered on the "Worksheet" (A2:Ix) sheet and check to see if all of those names also have a salary listed on the "Salary" sheet.
'    If any of the names from "Worksheet" are not on the "Salary" sheet, it ends Sub. If all the names are on the salary sheet and there are corresponding
'    salaries for each of those names, a pop up box will appear letting you know how many combinations to expect.
'
    'Check for salary worksheet
    For Each wks In ThisWorkbook.Worksheets
        If wks.Name = "Salary" Then bFoundSalary = True
    Next
'
    If Not bFoundSalary Then
        MsgBox "The workbook must contain a worksheet named 'Salary' with data starting in row 2 " & _
            "that consists of column A containing each name in the name/column layout worksheet " & _
            "and column B containng their salary."
'
        GoTo End_Sub
    End If
'
    'Make sure each name has a corresponding salary entry
    'Initialize the scripting dictionary
    Set oSD = CreateObject("Scripting.Dictionary")
    oSD.CompareMode = vbTextCompare
'
    'Inventory names on the main worksheet
    For Each cel In ActiveSheet.Range("A1").CurrentRegion.Offset(1, 0)
        cel.Value = Trim(cel.Value)
'
        If cel.Value <> vbNullString Then
            oSD.Item(cel.Value) = oSD.Item(cel.Value) + 1
        End If
    Next
'
    'Remove names on the Salary worksheet
    With Worksheets("Salary")
        For Each cel In .Range("A2:A" & .Cells(Rows.Count, 1).End(xlUp).Row)
            cel.Value = Trim(cel.Value)
'
            If oSD.Exists(cel.Value) Then
                oSD.Remove cel.Value
            End If
        Next
    End With
'
    'Any names not accounted for?
    If oSD.Count <> 0 Then
        varK = oSD.keys
'
        For lIndex = LBound(varK) To UBound(varK)
            sMissingSalary = sMissingSalary & ", " & varK(lIndex)
        Next
'
        sMissingSalary = Mid(sMissingSalary, 3)
'
        sOutput = "The following names on the main worksheet do not have a corresponding entry on the 'Salary' worksheet." & vbLf & vbLf & sMissingSalary
'
        MsgBox sOutput
        Debug.Print sOutput
'
        GoTo End_Sub
    End If
'
    sErrorMsg = "Ensure a Worksheet is active with a header row starting in A1" & "and names under each header entry."
'
    If TypeName(ActiveSheet) <> "Worksheet" Then
        bShowError = True
    End If
'
    If bShowError Then
        MsgBox sErrorMsg, , "Problems Found in Data"
'
        GoTo End_Sub
    End If
'
    lLastColumn = Range("A1").CurrentRegion.Columns.Count
    lLastUsedColumn = ActiveSheet.UsedRange.Columns.Count
    ReDim aryNames(1 To 2, 1 To lLastColumn)                '1 holds the in-use entry row
'
    'How many combinations? (Order does not matter)
    lLastIteration = 1
'
    For lColumnIndex = 1 To lLastColumn
        aryNames(1, lColumnIndex) = 2
        aryNames(2, lColumnIndex) = Cells(Rows.Count, lColumnIndex).End(xlUp).Row
        lLastIteration = lLastIteration * (aryNames(2, lColumnIndex) - 1)
    Next
'
    lFirstWriteColumn = lLastColumn + 2
    lLastWriteColumn = (2 * lLastColumn) + 1
'
    Select Case MsgBox("Process a " & lLastColumn & " column table with " & _
        lLastIteration & " possible combinations?" & vbLf & vbLf & _
        "WARNING: Columns right of the input range will be erased before continuing.", vbOKCancel + vbExclamation + _
        vbDefaultButton2, "Process table?")
'
        Case vbCancel
            GoTo End_Sub
    End Select
'
'-------------------------------------------------------------------------------------------------------------------------------
'
' 2) Clear all columns to the right of Column I on the "Worksheet" sheet. Copy headers from A1:I1 on the "Worksheet" sheet to K1:S1 on the "Worksheet" sheet.
'    Add header "ComboID" to T1 on the "Worksheet" sheet. Create the combinations & if there are no duplicate names in the same combination row then write the
'    combination to K row#:S row# on the "Worksheet" sheet & write lIterationCount to T row# on the "Worksheet" sheet.
'
    dteStart = Now()
    StartTime = Now()
'
    Application.StatusBar = "Step 1 of 4 Calculating name combinations & saving combinations with no duplicate names in same combination ..."
    DoEvents
'
    'Clear all columns right of input range
    If lLastUsedColumn > lLastColumn Then
        Range(Cells(1, lLastColumn + 1), Cells(1, lLastUsedColumn)).EntireColumn.ClearContents
    End If
'
' Save Worksheet data into 2D 1 based WorksheetArray
    Set WorksheetNameRange = wksData.Range("A2:" & Split(Cells(1, lLastColumn).Address, "$")(1) & wksData.Range("A1").CurrentRegion.Find("*", , xlFormulas, , xlByRows, xlPrevious).Row)
    WorksheetArray = WorksheetNameRange
'
    ReDim NoDupeRowArray(1 To lLastIteration, 1 To lLastColumn + 1)
'
    Cells(1, lLastWriteColumn + 1).Value = "ComboID"
'
    'Add Output Header
    Range(Cells(1, 1), Cells(1, lLastColumn)).Copy Destination:=Cells(1, lFirstWriteColumn)
'
' Load data from 'Worksheet', each column of data will be loaded into a separate array
    ReDim WorksheetColumnArray(1 To lLastColumn)                                                        ' Set the # of arrays in 'jagged' array WorksheetColumnArray
'
    For ColumnNumber = 1 To lLastColumn                                                                 ' Loop through the columns of 'Worksheet'
        lLastRow = Cells(Rows.Count, ColumnNumber).End(xlUp).Row                                        '   Get LastRow of the column
'
        ReDim TempArray(1 To lLastRow - 1, 1 To 1)                                                      '   Set the rows & columns of 2D 1 based TempArray
        WorksheetColumnArray(ColumnNumber) = TempArray                                                  '   Copy the empty 2D 1 based TempArray to WorksheetColumnArray()
'
        For ArrayRow = 1 To lLastRow - 1                                                                '   Loop through the rows of data in the column
            WorksheetColumnArray(ColumnNumber)(ArrayRow, 1) = WorksheetArray(ArrayRow, ColumnNumber)    '       Save the data to WorksheetColumnArray()
        Next                                                                                            '   Loop back
    Next                                                                                                ' Loop back
'
    'Start checking combinations
    lIterationCount = 0                                                                                 ' Reset lIterationCount
    lWriteRow = 0                                                                                       ' Reset lWriteRow
'
    For ColumnA_Row = 1 To UBound(WorksheetColumnArray(1), 1)                                           ' Loop through rows of WorksheetColumnArray(1) ... Column A
        For ColumnB_Row = 1 To UBound(WorksheetColumnArray(2), 1)                                       '   Loop through rows of WorksheetColumnArray(2) ... Column B
            For ColumnC_Row = 1 To UBound(WorksheetColumnArray(3), 1)                                   '       Loop through rows of WorksheetColumnArray(3) ... Column C
                For ColumnD_Row = 1 To UBound(WorksheetColumnArray(4), 1)                               '           Loop through rows of WorksheetColumnArray(4) ... Column D
                    For ColumnE_Row = 1 To UBound(WorksheetColumnArray(5), 1)                           '               Loop through rows of WorksheetColumnArray(5) ... Column E
                        For ColumnF_Row = 1 To UBound(WorksheetColumnArray(6), 1)                       '                   Loop through rows of WorksheetColumnArray(6) ... Column F
                            For ColumnG_Row = 1 To UBound(WorksheetColumnArray(7), 1)                   '                       Loop through rows of WorksheetColumnArray(7) ... Column G
                                For ColumnH_Row = 1 To UBound(WorksheetColumnArray(8), 1)               '                           Loop through rows of WorksheetColumnArray(8) ... Column H
                                    For ColumnI_Row = 1 To UBound(WorksheetColumnArray(9), 1)           '                               Loop through rows of WorksheetColumnArray(9) ... Column I
                                        lIterationCount = lIterationCount + 1                           '                                   Increment lIterationCount
'
' Initialize the scripting dictionary
                                        Set oSD = CreateObject("Scripting.Dictionary")
                                        oSD.CompareMode = vbTextCompare
'
' Check for duplicates in same row before saving to array
' Load names into scripting dictionary
                                        For x = 1 To 1                                                  '                                   Set up 'Fake loop' to allow exiting
                                            If Not oSD.Exists(WorksheetColumnArray(9)(ColumnI_Row, 1)) Then '                                   If name not previously seen in this row then ...
                                                oSD.Add WorksheetColumnArray(9)(ColumnI_Row, 1), ""     '                                           Save the name to the dictionary row
                                            Else                                                        '                                       Else ...
                                                Exit For                                                '                                           Exit this 'Fake loop'
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(8)(ColumnH_Row, 1)) Then '                                   Same as previous /\ /\ /\
                                                oSD.Add WorksheetColumnArray(8)(ColumnH_Row, 1), ""
                                            Else
                                                Exit For
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(7)(ColumnG_Row, 1)) Then '                                   Same as previous /\ /\ /\
                                                oSD.Add WorksheetColumnArray(7)(ColumnG_Row, 1), ""
                                            Else
                                                Exit For
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(6)(ColumnF_Row, 1)) Then '                                   Same as previous /\ /\ /\
                                                oSD.Add WorksheetColumnArray(6)(ColumnF_Row, 1), ""
                                            Else
                                                Exit For
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(5)(ColumnE_Row, 1)) Then '                                   Same as previous /\ /\ /\
                                                oSD.Add WorksheetColumnArray(5)(ColumnE_Row, 1), ""
                                            Else
                                                Exit For
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(4)(ColumnD_Row, 1)) Then '                                   Same as previous /\ /\ /\
                                                oSD.Add WorksheetColumnArray(4)(ColumnD_Row, 1), ""
                                            Else
                                                Exit For
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(3)(ColumnC_Row, 1)) Then '                                   Same as previous /\ /\ /\
                                                oSD.Add WorksheetColumnArray(3)(ColumnC_Row, 1), ""
                                            Else
                                                Exit For
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(2)(ColumnB_Row, 1)) Then '                                   Same as previous /\ /\ /\
                                                oSD.Add WorksheetColumnArray(2)(ColumnB_Row, 1), ""
                                            Else
                                                Exit For
                                            End If
'
                                            If Not oSD.Exists(WorksheetColumnArray(1)(ColumnA_Row, 1)) Then _
                                                    oSD.Add WorksheetColumnArray(1)(ColumnA_Row, 1), "" '                                       If name not previously seen in this row then ...
'                                                                                                       '                                               Save the name to the dictionary row
                                        Next                                                            '                                   Exit 'Fake loop'
'
                                        If UBound(oSD.keys) + 1 = lLastColumn Then                      '                                   If no duplicates found in row then ...
' The current row had names and no duplicates
'
' Point to the next blank row
                                            lWriteRow = lWriteRow + 1                                               '                           Increment lWriteRow
'
                                            NoDupeRowArray(lWriteRow, 1) = WorksheetColumnArray(1)(ColumnA_Row, 1)  '                           Save name from column A to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 2) = WorksheetColumnArray(2)(ColumnB_Row, 1)  '                           Save name from column B to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 3) = WorksheetColumnArray(3)(ColumnC_Row, 1)  '                           Save name from column C to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 4) = WorksheetColumnArray(4)(ColumnD_Row, 1)  '                           Save name from column D to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 5) = WorksheetColumnArray(5)(ColumnE_Row, 1)  '                           Save name from column E to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 6) = WorksheetColumnArray(6)(ColumnF_Row, 1)  '                           Save name from column F to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 7) = WorksheetColumnArray(7)(ColumnG_Row, 1)  '                           Save name from column G to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 8) = WorksheetColumnArray(8)(ColumnH_Row, 1)  '                           Save name from column H to NoDupeRowArray
                                            NoDupeRowArray(lWriteRow, 9) = WorksheetColumnArray(9)(ColumnI_Row, 1)  '                           Save name from column I to NoDupeRowArray
'
                                            NoDupeRowArray(lWriteRow, lLastColumn + 1) = lIterationCount    '                                   Save lIterationCount to NoDupeRowArray
                                        End If
                                    Next                                                                '                               Loop back
                                Next                                                                    '                           Loop back
                            Next                                                                        '                       Loop back
                        Next                                                                            '                   Loop back
                    Next                                                                                '               Loop back
                Next                                                                                    '           Loop back
            Next                                                                                        '       Loop back
        Next                                                                                            '   Loop back
    Next                                                                                                ' Loop back
'
    NoDupeRowArray = ReDimPreserve(NoDupeRowArray, lWriteRow, lLastColumn + 1)                          ' Resize NoDupeRowArray to correct the actual rows used in the array
'
' Write current combination rows to sheet if combinations don't exceed MaxRowsPerSubArray
    If UBound(NoDupeRowArray, 1) < MaxRowsPerSubArray Then                                              ' If the total # of combinations saved < MaxRowsPerSubArray then ...
        wksData.Cells(2, lLastColumn + 2).Resize(UBound(NoDupeRowArray, 1), _
                UBound(NoDupeRowArray, 2)) = NoDupeRowArray                                             '   Display NoDupeRowArray to 'Worksheet'
'
        Debug.Print "Create all combinations & remove rows with duplicate entries in the same row completed " & _
                "in " & Format(Now() - StartTime, "hh:mm:ss")                                           '   Display elapsed time for this process to the 'Immediate' window (CTRL+G) in VBE
'
        GoTo Continue                                                                                   '
    Else                                                                                                ' Else ...
        Application.StatusBar = "Step 2 of 4 Sorting all combinations by rows & removing rows with duplicate entries previously seen ..."
        DoEvents
'
        SubArrays = Int((UBound(NoDupeRowArray, 1) - 1) / MaxRowsPerSubArray) + 1                       ' number of SubArrays needed
'
        ReDim JaggedArray(1 To SubArrays)                                                               ' Set # of SubArrays in JaggedArray
'
        currow = 0                                                                                      ' Reset currow
'
        For SubArrayNumber = 1 To SubArrays                                                             ' Loop through SubArrays
            ReDim arrOut(1 To MaxRowsPerSubArray, 1 To UBound(NoDupeRowArray, 2))                       '   Reset the arrOut
'
            For SubArrayRow = 1 To MaxRowsPerSubArray                                                   '   Loop through rows of arrOut
                currow = currow + 1                                                                     '       Increment currow, this is the row of the NoDupeRowArray
'
                If currow > UBound(NoDupeRowArray, 1) Then Exit For                                     '       If all of the rows have been processed then exit this For loop
'
                For ArrayColumn = 1 To UBound(NoDupeRowArray, 2)                                        '       Loop through columns of NoDupeRowArray
                    arrOut(SubArrayRow, ArrayColumn) = NoDupeRowArray(currow, ArrayColumn)              '           Save column value into arrOut
                Next                                                                                    '       Loop back
            Next                                                                                        '   Loop back
'
            JaggedArray(SubArrayNumber) = arrOut                                                        '   Save the arrOut to the JaggedArray
        Next                                                                                            ' Loop back
'
' At this point, all of the MaxRowsPerSubArray row subArrays have been loaded into the JaggedArray
'
        For SubArrayNumber = 1 To SubArrays                                                             ' Loop through SubArrays
            ActiveSheet.Range("K2").Resize(UBound(JaggedArray(SubArrayNumber), 1), _
                    UBound(JaggedArray(SubArrayNumber), 2)) = JaggedArray(SubArrayNumber)               '   Write the subArray to the sheet for sorting
'
' Sort each row
            ActiveSheet.Sort.SortFields.Clear
'
            lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row                               '   Get lLastRow
'
            Set rngSortRange = Range(Cells(2, lFirstWriteColumn), _
                    Cells(lLastRow, lLastWriteColumn + 1))                                              '   Set the Range to be sorted
'
            For Each SortRowRange In rngSortRange.Rows                                                  '   Loop through each row of the range to be sorted
                SortRowRange.Sort Key1:=SortRowRange.Cells(1, 1), Order1:=xlAscending, _
                        Header:=xlNo, Orientation:=xlSortRows                                           '       Sort each row alphabetically
            Next                                                                                        '   Loop back
'
' Load the sorted data back into the subArray
            JaggedArray(SubArrayNumber) = ActiveSheet.Range("K2").Resize(UBound(JaggedArray(SubArrayNumber), 1), _
                    UBound(JaggedArray(SubArrayNumber), 2))                                         '
'
            ActiveSheet.Range("K2").Resize(UBound(JaggedArray(SubArrayNumber), 1), _
                    UBound(JaggedArray(SubArrayNumber), 2)).ClearContents                               '   Clear the sort range
        Next                                                                                            ' Loop back
'
' Join all of the sorted subArrays back into 1 large array
        ReDim NoDupeSortedRowsArray(1 To UBound(NoDupeRowArray, 1), 1 To UBound(NoDupeRowArray, 2) - 1) '
'
        currow = 0                                                                                      ' Reset currow
'
        For SubArrayNumber = 1 To SubArrays                                                             ' Loop through the SubArrays
            For SubArrayRow = 1 To UBound(JaggedArray(SubArrayNumber), 1)                               '   Loop through rows of each subArray in the JaggedArray
                currow = currow + 1                                                                     '       Increment currow, this is the row of the NoDupeSortedRowsArray
'
                If currow > UBound(NoDupeSortedRowsArray, 1) Then Exit For                              '       If all sorted rows have been written to NoDupeSortedRowsArray then exit this loop
'
                For ArrayColumn = 1 To UBound(NoDupeSortedRowsArray, 2)                                 '       Loop through columns of NoDupeSortedRowsArray
                    NoDupeSortedRowsArray(currow, ArrayColumn) = _
                            JaggedArray(SubArrayNumber)(SubArrayRow, ArrayColumn)                       '           Save column value into NoDupeSortedRowsArray
                Next                                                                                    '       Loop back
            Next                                                                                        '   Loop back
        Next                                                                                            ' Loop back
'
' At this point, all of the MaxRowsPerSubArray sorted row subArrays have been loaded into the NoDupeSortedRowsArray, last column is now first column though ;)
'
' Time to eliminate the duplicate rows in NoDupeSortedRowsArray
'
        ReDim keysArray(1 To UBound(NoDupeSortedRowsArray, 1), 1 To 1)                                  ' Set # of rows/columns of keysArray
'
' Combine each name in each row, separated by a Delimiter, to oSD_KeyString
        For ArrayRow = LBound(NoDupeSortedRowsArray, 1) To UBound(NoDupeSortedRowsArray, 1)             ' Loop through rows of NoDupeSortedRowsArray
            oSD_KeyString = ""                                                                          '   Erase 'oSD_KeyString'
            Delimiter = ""                                                                              '   Erase 'Delimiter' of NoDupeSortedRowsArray
'
            For ArrayColumn = LBound(NoDupeSortedRowsArray, 2) + 1 To UBound(NoDupeSortedRowsArray, 2)  '   Loop through name columns of NoDupeSortedRowsArray
                oSD_KeyString = oSD_KeyString & Delimiter & NoDupeSortedRowsArray(ArrayRow, ArrayColumn)    '       Save names from NoDupeSortedRowsArray row, separated by Delimiter, into oSD_KeyString
''            Delimiter = Chr(0)
                Delimiter = Chr(2)
            Next                                                                                        '   Loop back
'
            keysArray(ArrayRow, 1) = " " & Delimiter & oSD_KeyString                                    '   Save oSD_KeyString to keysArray
            oSD(oSD_KeyString) = True
        Next                                                                                            ' Loop back
'
        ReDim UniqueSortedRowsArray(LBound(NoDupeSortedRowsArray, 1) To oSD.Count + (LBound(NoDupeSortedRowsArray, 1) - 1), _
                LBound(NoDupeSortedRowsArray, 2) To UBound(NoDupeSortedRowsArray, 2) + 1)                 ' Set # of rows/columns of UniqueSortedRowsArray
'
'-------------------------------------------------------------------------------------------------------
'
' Copy each unique row to UniqueSortedRowsArray
        currow = LBound(NoDupeSortedRowsArray, 1) - 1                                                   ' Initialize currow
'
        For ArrayRow = LBound(NoDupeSortedRowsArray, 1) To UBound(NoDupeSortedRowsArray, 1)             ' Loop through rows of NoDupeSortedRowsArray
            If Not oSD.Exists(keysArray(ArrayRow, 1)) Then                                              '
                oSD.Add keysArray(ArrayRow, 1), ""                                                      '
'
                currow = currow + 1                                                                     '       Increment currow
'
                UniqueSortedRowsArray(currow, UBound(UniqueSortedRowsArray, 2)) = _
                        NoDupeSortedRowsArray(ArrayRow, 1)                                              '       Save the combination # to UniqueSortedRowsArray
'
                For ArrayColumn = LBound(NoDupeSortedRowsArray, 2) + 1 To UBound(NoDupeSortedRowsArray, 2)  '       Loop through columns of NoDupeSortedRowsArray
                    UniqueSortedRowsArray(currow, ArrayColumn - 1) = _
                            NoDupeSortedRowsArray(ArrayRow, ArrayColumn)                                '           Copy value to UniqueSortedRowsArray
                Next                                                                                    '       Loop back
'
                oSD(keysArray(ArrayRow, 1)) = False                                                     '       Flag this row as not unique      flag this key as copied
            End If
        Next                                                                                            ' Loop back
'
        UniqueSortedRowsArray = ReDimPreserve(UniqueSortedRowsArray, currow, UBound(UniqueSortedRowsArray, 2))  ' Correct the number of rows of UniqueSortedRowsArray
    End If
'
' At this point, NoDupeSortedRowsArrayUnique has been created with sorted rows with no duplicate rows & the ComboID has been added back
'
' Now we need to match the ComboID in UniqueSortedRowsArray to the ComboID in NoDupeRowArray so we can put the names for that row back to the original order
'
    ReDim UniqueUnSortedRowsArray(1 To UBound(UniqueSortedRowsArray, 1), 1 To UBound(UniqueSortedRowsArray, 2)) ' Set the # of rows/columns for UniqueUnSortedRowsArray
    ReDim SalaryCalculationArray(1 To UBound(UniqueSortedRowsArray, 1), 1 To UBound(UniqueSortedRowsArray, 2)) ' Set the # of rows/columns for SalaryArray
'
    currow = 1                                                                                          ' Increment currow
'
    For ArrayRow = LBound(NoDupeRowArray, 1) To UBound(NoDupeRowArray, 1)                               ' Loop through rows of NoDupeRowArray
        If currow > UBound(UniqueUnSortedRowsArray, 1) Then Exit For                                    '   If we have processed all rows then exit this For loop
'
        If UniqueSortedRowsArray(currow, UBound(UniqueSortedRowsArray, 2)) = _
                NoDupeRowArray(ArrayRow, UBound(NoDupeRowArray, 2)) Then                                '   If we found matching ComboID's then ...
'
''            For ArrayColumn = LBound(NoDupeRowArray, 2) To UBound(NoDupeRowArray, 2)                    '       Loop through the columns of NoDupeRowArray
''                UniqueUnSortedRowsArray(currow, ArrayColumn) = NoDupeRowArray(ArrayRow, ArrayColumn)    '           Save the value from the row/column to UniqueUnSortedRowsArray
''            Next                                                                                        '       Loop back
            For ArrayColumn = LBound(NoDupeRowArray, 2) To UBound(NoDupeRowArray, 2 - 1)                '       Loop through the columns of NoDupeRowArray except for the last column
                UniqueUnSortedRowsArray(currow, ArrayColumn) = NoDupeRowArray(ArrayRow, ArrayColumn)    '           Save the name from the row/column to UniqueUnSortedRowsArray
                SalaryCalculationArray(currow, ArrayColumn) = NoDupeRowArray(ArrayRow, ArrayColumn)     '           Save the name from the row/column to SalaryCalculationArray
            Next                                                                                        '       Loop back
'
            UniqueUnSortedRowsArray(currow, UBound(UniqueUnSortedRowsArray, 2)) = _
                    NoDupeRowArray(ArrayRow, UBound(NoDupeRowArray, 2))                                 '       Save the ComboID to UniqueUnSortedRowsArray
'
            currow = currow + 1                                                                         '       Increment currow
        End If
    Next                                                                                                ' Loop back
'
    wksData.Cells(2, lLastColumn + 2).Resize(UBound(UniqueUnSortedRowsArray, 1), _
            UBound(UniqueUnSortedRowsArray, 2)) = UniqueUnSortedRowsArray                               ' Display UniqueUnSortedRowsArray to 'Worksheet'
'
    Debug.Print "Create all combinations & remove rows with duplicate entries in the same row completed " & _
        "in " & Format(Now() - StartTime, "hh:mm:ss")                                                   ' Display elapsed time for this process to the 'Immediate' window (CTRL+G) in VBE
'






    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
'
    Range(Cells(1, lFirstWriteColumn), Cells(lLastRow, lLastWriteColumn)).Copy Destination:=Cells(1, lLastWriteColumn + 2) '' Rows for SALARY ... Copy K1:S & lLastRow to U1:AC & lLastRow
    lFirstHSortColumn = lLastWriteColumn + 2                                                                                ' 21 ie. column U
    lLastHSortColumn = Cells(1, Columns.Count).End(xlToLeft).Column                                                         ' 29 ie. column AC
'
    GoTo Salary_Code





'
'-------------------------------------------------------------------------------------------------------------------------------
'-------------------------------------------------------------------------------------------------------------------------------
'-------------------------------------------------------------------------------------------------------------------------------
'
' 4) Copy name combinations from columns K:S and pastes them in columns U:AC, AD:AL, AM:AU
'
Continue:
    StartTime = Now()
'
    Application.StatusBar = "Step 2 of 4 Sorting all combinations by rows & removing rows with duplicate entries previously seen ..."
    DoEvents
'
    'Copy row names to right so that each copied row can be sorted alphabetically left to right
    '  this will allow the Excel remove duplicate fuction to remove rows that have identical names
    '  in all of their sorted columns.
    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
'
    Range(Cells(1, lFirstWriteColumn), Cells(lLastRow, lLastWriteColumn)).Copy Destination:=Cells(1, lLastWriteColumn + 2) '' Rows for SALARY ... Copy K1:S & lLastRow to U1:AC & lLastRow
    lFirstHSortColumn = lLastWriteColumn + 2                                                                                ' 21 ie. column U
    lLastHSortColumn = Cells(1, Columns.Count).End(xlToLeft).Column                                                         ' 29 ie. column AC
'
'-------------------------------------------------------------------------------------------------------------------------------
'





' 6) Build an array from the combination names in columns K:S. States it excludes iteration # column. I am not sure what that is referencing.
'    May be the ComboID in column T. The duplicate combinations are then removed. Keep in mind Duplicates in ANY order are removed.
'    If the same players are used in a lineup, regardless of column, they are removed.
'
' Sort each row
    ActiveSheet.Sort.SortFields.Clear
'
    Set rngSortRange = Range(Cells(2, lFirstHSortColumn), Cells(lLastRow, lLastHSortColumn))
'
    For Each SortRowRange In rngSortRange.Rows
        SortRowRange.Sort Key1:=SortRowRange.Cells(1, 1), Order1:=xlAscending, Header:=xlNo, Orientation:=xlSortRows
    Next
'
' Check for duplicate rows in HSort Columns
'
' Can only happen if names are duplicated within an input column
' Build aryDeDupe  -- Array(1, 2, 3,...n)  -- to exclude iteration # column
'
    ReDim aryDeDupe(0 To lLastHSortColumn - lFirstHSortColumn)
'
    For lColumnIndex = lFirstHSortColumn To lLastHSortColumn
        aryDeDupe(lIndex) = CInt(lColumnIndex - lFirstWriteColumn + 1)
        lIndex = lIndex + 1
    Next
'
    ActiveSheet.Cells(1, lFirstWriteColumn).CurrentRegion.RemoveDuplicates Columns:=(aryDeDupe), Header:=xlYes  ' *** This line reduces lines of data
    'Above line won't work unless there are parens around the Columns argument ????? ... This is normal behavior :)
'
Debug.Print "Sort all combinations by rows & remove rows with duplicate entries previously seen completed " & _
        "in " & Format(Now() - StartTime, "hh:mm:ss")                                                   ' Display elapsed time for this process to the 'Immediate' window (CTRL+G) in VBE
'
'-------------------------------------------------------------------------------------------------------------------------------
'
' 5) Replace copied names in column U:AC with the players respective salary data on "Salary" sheet. Column AV becomes "Salary" column and
'    the sum of columns U:AC is calculated. Max salary is declared at 60000. The data in A2:I26 is copied to the "Salary" sheet in cell G2:O26
'    before filter is applied. Autofilter is then applied to the range AV. If the value in AV is greater than 60000, the range K:BE for that row will be deleted.
'    The data copied to G2:O26 is then cut and pasted back to A2:I26 and autofilter is turned off.
'
       'Assumes the 'Salary' worksheet has names in the column A and salaries in column B starting in row 2
    'Replace HSort names with salary
'
Salary_Code:
'
    StartTime = Now()
'
    Application.StatusBar = "Step 3 of 4 Removing all combination rows with salaries > " & MaxSalaryAllowed & " ..."
    DoEvents
'
    With Worksheets("Salary") '''' SALARY
        lLastSalaryRow = .Cells(.Rows.Count, 1).End(xlUp).Row
    End With
'
    With CreateObject("scripting.dictionary")
        .CompareMode = vbTextCompare
'
        For Each cel In WorksheetNameRange                                                                          '   Loop through each cell in the WorksheetNameRange
            If cel <> "" Then                                                                                       '       If the cell is not blank then ...
                If Not .Exists(cel.Value) Then                                                                      '           If the value has not already been saved then ...
                    .Add cel.Value, cel.Value                                                                       '               Save the value
                End If
            End If
'
            UniqueWorksheetNamesArray = Application.Transpose(Array(.keys))                                         '       Transpose results to 2D 1 based UniqueWorksheetNamesArray
        Next                                                                                                        '   Loop back
    End With
'
    SalarySheetFullArray = names.Range("A2:" & _
            Split(Cells(names.Cells.Find("*", , xlFormulas, , xlByColumns, xlPrevious).Column).Address, "$")(1) & lLastSalaryRow)   '   Save all of the data from the 'Salary' aheet into 2D 1 based SalarySheetFullArray
'
    ReDim SalarySheetShortenedArray(1 To UBound(SalarySheetFullArray, 1), 1 To UBound(SalarySheetFullArray, 2)) ' Set 2D 1 based SalarySheetShortenedArray to the same size as SalarySheetFullArray
'
    currow = 0                                                                                                      ' Initialize currow
'
    For UniqueArrayRow = 1 To UBound(UniqueWorksheetNamesArray, 1)                                                  ' Loop through the rows of UniqueWorksheetNamesArray
        For ArrayRow = 1 To UBound(SalarySheetFullArray, 1)                                                         '   Loop through the rows of SalarySheetFullArray
            If UniqueWorksheetNamesArray(UniqueArrayRow, 1) = SalarySheetFullArray(ArrayRow, 1) Then                '       If the name from UniqueWorksheetNamesArray is found in SalarySheetFullArray then ...
                currow = currow + 1                                                                                 '           Increment currow
'
                For lColumnIndex = 1 To UBound(SalarySheetFullArray, 2)                                             '           Loop through the columns of SalarySheetFullArray
                    SalarySheetShortenedArray(currow, lColumnIndex) = SalarySheetFullArray(ArrayRow, lColumnIndex)  '               Save the values to SalarySheetShortenedArray
                Next                                                                                                '           Loop back
            End If
        Next                                                                                                        '   Loop back
    Next                                                                                                            ' Loop back
'
    SalarySheetShortenedArray = Application.Transpose(SalarySheetShortenedArray)                                    ' Transpose SalarySheetShortenedArray so we can correct the size (row count)
'
    ReDim Preserve SalarySheetShortenedArray(1 To UBound(SalarySheetFullArray, 2), 1 To currow)                     ' Set the row count to actual used rows
'
    SalarySheetShortenedArray = Application.Transpose(SalarySheetShortenedArray)                                    ' Transpose back the SalarySheetShortenedArray
'
    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
'
    Set rngReplace = Range(Cells(2, lFirstHSortColumn), Cells(lLastRow, lLastHSortColumn))
'
    For lRowIndex = 1 To UBound(SalarySheetShortenedArray, 1)
        rngReplace.Replace What:=SalarySheetShortenedArray(lRowIndex, 1), _
                Replacement:=SalarySheetShortenedArray(lRowIndex, 2), LookAt:=xlWhole, _
                SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, ReplaceFormat:=False
    Next
'
    lLastRowDeDuped = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
'
    lLastHTeamCol = Cells(1, Columns.Count).End(xlToLeft).Column
'
' Add Sum Column
    Cells(1, lLastHTeamCol + 1).Value = ChrW(931) & " Salary"
'
    With Range(Cells(2, lLastHTeamCol + 1), Cells(lLastRowDeDuped, lLastHTeamCol + 1))
        .FormulaR1C1 = "=SUM(RC" & lFirstHSortColumn & ":RC" & lLastHSortColumn & ")"
        Application.Calculate
        .Value = .Value
    End With
'
''    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
'
    With wksData
        Set rngDataBlock = .Range(.Cells(1, lLastHTeamCol + 1), .Cells(lLastRow, lLastHTeamCol + 1))
    End With
'
    With rngDataBlock
        .AutoFilter Field:=1, Criteria1:=">" & MaxSalaryAllowed
'
        On Error Resume Next
        .Range(Cells(2, lFirstWriteColumn), Cells(lLastRow, lLastHTeamCol + 9)).Delete Shift:=xlUp      '   This took almost 6 minutes :(
        On Error GoTo 0
    End With
'
' Turn off the Autofilter safely
    With wksData
        .AutoFilterMode = False
'
        If .FilterMode = True Then .ShowAllData
   End With
'
    wksData.Range("A2").Resize(UBound(WorksheetArray, 1), UBound(WorksheetArray, 2)) = WorksheetArray   ' Write original data back to wksData just in case it was deleted
'
Debug.Print "Remove all combinations with salaries > " & MaxSalaryAllowed & " completed " & _
        "in " & Format(Now() - StartTime, "hh:mm:ss")                                                   ' Display elapsed time for this process to the 'Immediate' window (CTRL+G) in VBE
'
'-------------------------------------------------------------------------------------------------------------------------------
'
' 7) The names copied over to AD:AL are replaced with the corresponding players projection on the "Salary" sheet. The names copied over to AM:AU are replaced
'    with the corresponding players team located on the "Salary" Sheet. A projection column is added to column AW. The projections from columns AD:AL are
'    calculated(summed) and entered into column AW. A "Stack" column is added to column AX and the most used team in the combinations are calculated using the
'    MODE function. A "Stack POS" column is added to column AY. The players position - who consisted of the most used team are added to column AY by pulling the
'    column headers associated to the corresponding player using the TEXTJOIN function. A "" Stack2" column is added to the AZ column and a "Stack2 POS" column
'    is added to the BA column - Both using the similar method as first stack column.
'
    Application.StatusBar = "Step 4 of 4 Wrapping up ..."
    DoEvents
'
    lLastRow = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
'
    If lLastRow > 1 Then
        Range(Cells(1, lFirstWriteColumn), Cells(lLastRow, lLastWriteColumn)).Copy Destination:=Cells(1, lLastHSortColumn + 2) '' Rows for PROJECTION
'
        lLastHSortColumn2 = Cells(1, Columns.Count).End(xlToLeft).Column
'
        Range(Cells(1, lFirstWriteColumn), Cells(lLastRow, lLastWriteColumn)).Copy Destination:=Cells(1, lLastHSortColumn2 + 1) '' Rows for TEAM
'
        lLastRowDeDuped = Cells(Rows.Count, lFirstWriteColumn).End(xlUp).Row
'
        lFirstHSortColumn2 = lLastHSortColumn + 2
'
        lFirstHTeamCol = lLastHSortColumn2 + 1
'
        lLastHTeamCol = Cells(1, Columns.Count).End(xlToLeft).Column
'
        Set rngReplace2 = Range(Cells(2, lFirstHSortColumn2), Cells(lLastRow, lLastHSortColumn2))
        Set rngReplace3 = Range(Cells(2, lFirstHTeamCol), Cells(lLastRow, lLastHTeamCol))
'
        For lRowIndex = 1 To UBound(SalarySheetShortenedArray, 1)
'
'''''''''''''''''''''''''''''''''''''PROJECTION
            rngReplace2.Replace What:=SalarySheetShortenedArray(lRowIndex, 1), _
                Replacement:=SalarySheetShortenedArray(lRowIndex, 3), LookAt:=xlWhole, _
                SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, ReplaceFormat:=False
'
'
         '''''''''''''''''''''''''''''''''''''TEAM
            rngReplace3.Replace What:=SalarySheetShortenedArray(lRowIndex, 1), _
                Replacement:=SalarySheetShortenedArray(lRowIndex, 4), LookAt:=xlWhole, _
                SearchOrder:=xlByRows, MatchCase:=False, SearchFormat:=False, ReplaceFormat:=False
        Next
'
' Add Projection Column
        Cells(1, lLastHTeamCol + 2).Value = ChrW(931) & " Projection"
' Add Team Stack Column
        Cells(1, lLastHTeamCol + 3).Value = ChrW(931) & " Stack"
' Add Team Stack Pos
        Cells(1, lLastHTeamCol + 4).Value = ChrW(931) & " Stack POS"
' Add 2nd Team Stack Column
        Cells(1, lLastHTeamCol + 5).Value = ChrW(931) & " Stack2"
' Add 2nd Team Stack Pos
        Cells(1, lLastHTeamCol + 6).Value = ChrW(931) & " Stack2 POS"
' Filter 0-1
        Cells(1, lLastHTeamCol + 7).Value = ChrW(931) & " Filter"
' Player 1 Filter
        Cells(1, lLastHTeamCol + 8).Value = ChrW(931) & " Player1"
' Player 2 Filter
        Cells(1, lLastHTeamCol + 9).Value = ChrW(931) & " Player2"
'
        With Range(Cells(2, lLastHTeamCol + 2), Cells(lLastRowDeDuped, lLastHTeamCol + 2))
            .FormulaR1C1 = "=SUM(RC" & lFirstHSortColumn2 & ":RC" & lLastHSortColumn2 & ")"
            Application.Calculate
            .Value = .Value
        End With
'
        With Range(Cells(2, lLastHTeamCol + 3), Cells(lLastRowDeDuped, lLastHTeamCol + 3))
            .FormulaR1C1 = "=INDEX(RC" & lFirstHTeamCol & ":RC" & lLastHTeamCol & ",MODE(MATCH(RC" & lFirstHTeamCol & ":RC" & lLastHTeamCol & ",RC" & lFirstHTeamCol & ":RC" & lLastHTeamCol & ",0)))"
            Application.Calculate
            .Value = .Value
        End With
'
        With Range(Cells(2, lLastHTeamCol + 4), Cells(lLastRowDeDuped, lLastHTeamCol + 4))
            .Formula2R1C1 = "=TEXTJOIN("","",1,IF(RC[-12]:RC[-4]=RC[-1],R1C[-12]:R1C[-4],""""))"
            Application.Calculate
            .Value = .Value
        End With
'
        With Range(Cells(2, lLastHTeamCol + 5), Cells(lLastRowDeDuped, lLastHTeamCol + 5))
            .Formula2R1C1 = "=IFERROR(INDEX(RC[-13]:RC[-5],MODE(IF((RC[-13]:RC[-5]<>"""")*(RC[-13]:RC[-5]<>INDEX(RC[-13]:RC[-5],MODE(IF(RC[-13]:RC[-5]<>"""",MATCH(RC[-13]:RC[-5],RC[-13]:RC[-5],0))))),MATCH(RC[-13]:RC[-5],RC[-13]:RC[-5],0)))),"""")"
            Application.Calculate
            .Value = .Value
        End With
'
        With Range(Cells(2, lLastHTeamCol + 6), Cells(lLastRowDeDuped, lLastHTeamCol + 6))
            .Formula2R1C1 = "=TEXTJOIN("","",1,IF(RC[-12]:RC[-4]=RC[-1],R1C[-12]:R1C[-4],""""))"
            Application.Calculate
            .Value = .Value
        End With
'
'-------------------------------------------------------------------------------------------------------------------------------
'
' 8) "Filter" column added to column BB, "Player1" column added to column BC, "Player2" column added to column BD. Nothing is calculated in these
'    columns. Only Headers added. Currently not a used function for this project.
'
        With Range(Cells(2, lLastHTeamCol + 7), Cells(lLastRowDeDuped, lLastHTeamCol + 7))
        End With
'
        With Range(Cells(2, lLastHTeamCol + 8), Cells(lLastRowDeDuped, lLastHTeamCol + 8))
        End With
'
        With Range(Cells(2, lLastHTeamCol + 9), Cells(lLastRowDeDuped, lLastHTeamCol + 9))
        End With
    Else
        MsgBox "No rows qualified for further testing."
        lFirstHTeamCol = Cells(1, Columns.Count).End(xlToLeft).Column
    End If
'
'-------------------------------------------------------------------------------------------------------------------------------
'
' 9) Removes all helper columns - U:AU. "Salary" column becomes column U. "Projection" column becomes column V. "Stack" column becomes column W. "Stack POS"
'    column becomes column X. "Stack 2" column becomes column Y. "Stack 2 POS" column becomes column Z. Filter column becomes column AA. "Player1" Column
'    becomes column AB. "Player2" column becomes column AC.. A Dialogue Box then pops open and provides combination info: Possible combinations,
'    unique combinations, duplicates removed, and the time to process. Data is then autofitted to the used range and printed to the "Worksheet".
'    OptimizeCode_End is then called, which is just turning back on screen updating and whatnot.
'
' Remove Salary Columns
    Range(Cells(2, lFirstHSortColumn), Cells(lLastRowDeDuped, lLastHSortColumn)).EntireColumn.Delete
    Range(Cells(2, lFirstHSortColumn + 1), Cells(lLastRowDeDuped, lFirstHTeamCol)).EntireColumn.Delete
'
    ActiveSheet.UsedRange.Columns.AutoFit
'
    sOutput = lLastIteration & vbTab & " possible combinations" & vbLf & _
        lLastRow - 1 & vbTab & " unique name combinations" & vbLf & _
        IIf(lLastRowDeDuped < lLastRow, lLastRow - lLastRowDeDuped & vbTab & " duplicate rows removed." & vbLf, "") & _
        lLastRowDeDuped - 1 & vbTab & " printed." & vbLf & vbLf & _
        Format(Now() - dteStart, "hh:mm:ss") & " to process."
'
End_Sub:
    Call OptimizeCode_End
'
    Debug.Print sOutput
    MsgBox sOutput, , "Output Report"
End Sub



Public Function ReDimPreserve(ArrayNameToResize, NewRowUbound, NewColumnUbound)
'
' Code inspired by Control Freak
'
' Redim & preserve both dimensions for a 2D array
'
' example usage of the function:
' ArrayName = ReDimPreserve(ArrayName,NewRowSize,NewColumnSize)
' ie.
' InputArray = ReDimPreserve(InputArray,10,20)
'
    Dim NewColumn                   As Long, NewRow                      As Long
    Dim OldColumnLbound             As Long, OldRowLbound                As Long
    Dim OldColumnUbound             As Long, OldRowUbound                As Long
    Dim NewResizedArray()           As Variant
'
    ReDimPreserve = False
'
    If IsArray(ArrayNameToResize) Then                                                                      ' If the variable is an array then ...
           OldRowLbound = LBound(ArrayNameToResize, 1)
        OldColumnLbound = LBound(ArrayNameToResize, 2)
'
        ReDim NewResizedArray(OldRowLbound To NewRowUbound, OldColumnLbound To NewColumnUbound)             '   Create a New 2D Array
'
        OldRowUbound = UBound(ArrayNameToResize, 1)                                                         '   Save row Ubound of original array
        OldColumnUbound = UBound(ArrayNameToResize, 2)                                                      '   Save column Ubound of original array
'
''        For NewRow = LBound(ArrayNameToResize, 1) To NewRowUbound                                         '   Loop through rows of original array
''            For NewColumn = LBound(ArrayNameToResize, 2) To NewColumnUbound                               '       Loop through columns of original array
        For NewRow = OldRowLbound To NewRowUbound                                                           '   Loop through rows of original array
            For NewColumn = OldColumnLbound To NewColumnUbound                                              '       Loop through columns of original array
                If OldRowUbound >= NewRow And OldColumnUbound >= NewColumn Then                             '           If more data to copy then ...
                    NewResizedArray(NewRow, NewColumn) = ArrayNameToResize(NewRow, NewColumn)               '               Append rows/columns to NewResizedArray
                End If
            Next                                                                                            '       Loop back
        Next                                                                                                '   Loop back
'
        If IsArray(NewResizedArray) Then ReDimPreserve = NewResizedArray
    End If
End Function

That code should allow for more combinations.

I still am not done messing with the code, but that code should allow you to run more combinations than the previous versions.

Let me know how that version works for you.
 
Upvote 0
I have 2 areas that I still want to look into, the total combination creation section & the deletion of rows after the 'Sum' formula is applied for the salary section.
 
Upvote 0
I have 2 areas that I still want to look into, the total combination creation section & the deletion of rows after the 'Sum' formula is applied for the salary section.
Thanks for your work on this! I will give the newest code you supplied some tests tomorrow. 🙂
 
Upvote 0

Forum statistics

Threads
1,224,823
Messages
6,181,176
Members
453,021
Latest member
Justyna P

We've detected that you are using an adblocker.

We have a great community of people providing Excel help here, but the hosting costs are enormous. You can help keep this site running by allowing ads on MrExcel.com.
Allow Ads at MrExcel

Which adblocker are you using?

Disable AdBlock

Follow these easy steps to disable AdBlock

1)Click on the icon in the browser’s toolbar.
2)Click on the icon in the browser’s toolbar.
2)Click on the "Pause on this site" option.
Go back

Disable AdBlock Plus

Follow these easy steps to disable AdBlock Plus

1)Click on the icon in the browser’s toolbar.
2)Click on the toggle to disable it for "mrexcel.com".
Go back

Disable uBlock Origin

Follow these easy steps to disable uBlock Origin

1)Click on the icon in the browser’s toolbar.
2)Click on the "Power" button.
3)Click on the "Refresh" button.
Go back

Disable uBlock

Follow these easy steps to disable uBlock

1)Click on the icon in the browser’s toolbar.
2)Click on the "Power" button.
3)Click on the "Refresh" button.
Go back
Back
Top