Update app.py

app.py

@@ -116,8 +116,17 @@ def create_stack_options(player_data, wr_var):
     
         return correl_dict
 
-def create_overall_dfs(pos_players, table_name, dict_name, pos):
-    if pos == "FLEX":
+def create_overall_dfs(s_pos_players, pos_players, table_name, dict_name, pos):
+    if pos == "S_FLEX":
+        table_name_raw = s_pos_players.reset_index(drop=True)
+        overall_table_name = table_name_raw.head(round(len(table_name_raw)))
+        overall_table_name = overall_table_name.assign(Var = range(0,len(overall_table_name)))
+        overall_dict_name = pd.Series(overall_table_name.Player.values, index=overall_table_name.Var).to_dict()
+        
+        del pos_players
+        del table_name_raw
+        
+    elif pos == "FLEX":
         pos_players = pos_players.sort_values(by='Value', ascending=False)
         table_name_raw = pos_players.reset_index(drop=True)
         overall_table_name = table_name_raw.head(round(len(table_name_raw)))
@@ -126,6 +135,7 @@ def create_overall_dfs(pos_players, table_name, dict_name, pos):
         
         del pos_players
         del table_name_raw
+        
     elif pos != "FLEX":
         table_name_raw = pos_players[pos_players['Position'].str.contains(pos)].reset_index(drop=True)
         overall_table_name = table_name_raw.head(round(len(table_name_raw)))
@@ -140,14 +150,14 @@ def create_overall_dfs(pos_players, table_name, dict_name, pos):
 
 def get_overall_merged_df():
     ref_dict = {
-        'pos':['RB', 'WR', 'FLEX'],
-        'pos_dfs':['RB_Table', 'WR_Table', 'FLEX_Table'],
-        'pos_dicts':['rb_dict', 'wr_dict', 'flex_dict']
+        'pos':['RB', 'WR', 'FLEX', 'S_FLEX'],
+        'pos_dfs':['RB_Table', 'WR_Table', 'FLEX_Table', 'S_FLEX_Table'],
+        'pos_dicts':['rb_dict', 'wr_dict', 'flex_dict', 's_flex_dict']
         }
     
-    for i in range(0,3):
+    for i in range(0,4):
         ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i] =\
-            create_overall_dfs(pos_players, ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i], ref_dict['pos'][i])
+            create_overall_dfs(s_pos_players, pos_players, ref_dict['pos_dfs'][i], ref_dict['pos_dicts'][i], ref_dict['pos'][i])
         
     df_out = pd.concat(ref_dict['pos_dfs'], ignore_index=True)
     
@@ -168,29 +178,26 @@ def create_random_portfolio(Total_Sample_Size, raw_baselines):
             ranges_dict = {}
             
             # Calculate ranges
-            for df, dict_val, min_val, key in zip(ref_dict['pos_dfs'], ref_dict['pos_dicts'], [10, 20, 30], ['RB', 'WR', 'FLEX']):
-                count = create_overall_dfs(pos_players, df, dict_val, key)
+            for df, dict_val, min_val, key in zip(ref_dict['pos_dfs'], ref_dict['pos_dicts'], [10, 20, 30, 30], ['RB', 'WR', 'FLEX', 'S_FLEX']):
+                count = create_overall_dfs(s_pos_players, pos_players, df, dict_val, key)
                 ranges_dict[f"{key.lower()}_range"] = calculate_range_var(count, min_val, FieldStrength, field_growth_rounded)
             if max_var <= 10:
                 ranges_dict['qb_range'] = round(max_var)
-                ranges_dict['dst_range'] = round(max_var)
             elif max_var > 10 and max_var <= 16:
                 ranges_dict['qb_range'] = round(max_var / 1.5)
-                ranges_dict['dst_range'] = round(max_var)
             elif max_var > 16:
                 ranges_dict['qb_range'] = round(max_var / 2)
-                ranges_dict['dst_range'] = round(max_var)
             # Generate unique ranges
             # for key, value in ranges_dict.items():
             #     ranges_dict[f"{key}_Uniques"] = list(range(0, value, 1))
             
             # Generate random portfolios
             rng = np.random.default_rng()
-            total_elements = [1, 1, 2, 2, 1]
-            keys = ['qb', 'rb', 'wr', 'flex', 'dst']
+            total_elements = [1, 2, 3, 1, 1]
+            keys = ['qb', 'rb', 'wr', 'flex', 's_flex']
             
             all_choices = [rng.choice(ranges_dict[f"{key}_range"], size=(Total_Sample_Size, elem)) for key, elem in zip(keys, total_elements)]
-            RandomPortfolio = pd.DataFrame(np.hstack(all_choices), columns=['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST'])
+            RandomPortfolio = pd.DataFrame(np.hstack(all_choices), columns=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX'])
             RandomPortfolio['User/Field'] = 0
             
             del O_merge
@@ -207,14 +214,15 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     
     RandomPortfolio['QB'] = pd.Series(list(RandomPortfolio['QB'].map(qb_dict)), dtype="string[pyarrow]")
     RandomPortfolio['RB1'] = pd.Series(list(RandomPortfolio['RB1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
+    RandomPortfolio['RB2'] = pd.Series(list(RandomPortfolio['RB2'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
     RandomPortfolio['WR1'] = pd.Series(list(RandomPortfolio['QB'].map(stacking_dict)), dtype="string[pyarrow]")
     RandomPortfolio['WR2'] = pd.Series(list(RandomPortfolio['WR2'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
-    RandomPortfolio['FLEX1'] = pd.Series(list(RandomPortfolio['FLEX1'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
-    RandomPortfolio['FLEX2'] = pd.Series(list(RandomPortfolio['FLEX2'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
-    RandomPortfolio['DST'] = pd.Series(list(RandomPortfolio['DST'].map(def_dict)), dtype="string[pyarrow]")
+    RandomPortfolio['WR3'] = pd.Series(list(RandomPortfolio['WR3'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX'] = pd.Series(list(RandomPortfolio['FLEX'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
+    RandomPortfolio['S_FLEX'] = pd.Series(list(RandomPortfolio['S_FLEX'].map(full_pos_player_dict['pos_dicts'][3])), dtype="string[pyarrow]")
     RandomPortfolio['plyr_list'] = RandomPortfolio[RandomPortfolio.columns.values.tolist()].values.tolist()
     RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
-    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 8].drop(columns=['plyr_list','plyr_count']).\
+    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 9].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
     
     del sizesplit
@@ -225,38 +233,41 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
 
     RandomPortfolio['QBs'] = RandomPortfolio['QB'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['RB1s'] = RandomPortfolio['RB1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['RB2s'] = RandomPortfolio['RB2'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['WR1s'] = RandomPortfolio['WR1'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['WR2s'] = RandomPortfolio['WR2'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['FLEX1s'] = RandomPortfolio['FLEX1'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['FLEX2s'] = RandomPortfolio['FLEX2'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['DSTs'] = RandomPortfolio['DST'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR3s'] = RandomPortfolio['WR3'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEXs'] = RandomPortfolio['FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['S_FLEXs'] = RandomPortfolio['S_FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
     
     RandomPortfolio['QBp'] = RandomPortfolio['QB'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['RB1p'] = RandomPortfolio['RB1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['RB2p'] = RandomPortfolio['RB2'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR1p'] = RandomPortfolio['WR1'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR2p'] = RandomPortfolio['WR2'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['FLEX1p'] = RandomPortfolio['FLEX1'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['FLEX2p'] = RandomPortfolio['FLEX2'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['DSTp'] = RandomPortfolio['DST'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR3p'] = RandomPortfolio['WR3'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEXp'] = RandomPortfolio['FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['S_FLEXp'] = RandomPortfolio['S_FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
     
     RandomPortfolio['QBo'] = RandomPortfolio['QB'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['RB1o'] = RandomPortfolio['RB1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['RB2o'] = RandomPortfolio['RB2'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR1o'] = RandomPortfolio['WR1'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR2o'] = RandomPortfolio['WR2'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['FLEX1o'] = RandomPortfolio['FLEX1'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['FLEX2o'] = RandomPortfolio['FLEX2'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['DSTo'] = RandomPortfolio['DST'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR3o'] = RandomPortfolio['WR3'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEXo'] = RandomPortfolio['FLEX'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['S_FLEXo'] = RandomPortfolio['S_FLEX'].map(maps_dict['Own_map']).astype(np.float16)
     
     RandomPortArray = RandomPortfolio.to_numpy()
     del RandomPortfolio
     
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,8:15].astype(int))]
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,15:22].astype(np.double))]
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,22:29].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,9:17].astype(int))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,17:25].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,25:33].astype(np.double))]
     # st.write(RandomPortArray[:,:100])
-    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[8:29], axis=1)
+    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[9:33], axis=1)
     # st.write(RandomPortArrayOut[:,:100])
-    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
+    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'User/Field', 'Salary', 'Projection', 'Own'])
     RandomPortfolioDF = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     del RandomPortArray
     del RandomPortArrayOut
@@ -264,29 +275,32 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     if insert_port == 1:
         CleanPortfolio['Salary'] = sum([CleanPortfolio['QB'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['RB1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['RB2'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR1'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR2'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['FLEX1'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['FLEX2'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['DST'].map(maps_dict['Salary_map'])
+                                        CleanPortfolio['WR3'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['S_FLEX'].map(maps_dict['Salary_map'])
                                         ]).astype(np.int16)
     if insert_port == 1:
         CleanPortfolio['Projection'] = sum([CleanPortfolio['QB'].map(up_dict['Projection_map']),
                                             CleanPortfolio['RB1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['RB2'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR1'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR2'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['FLEX1'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['FLEX2'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['DST'].map(up_dict['Projection_map'])
+                                            CleanPortfolio['WR3'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['S_FLEX'].map(up_dict['Projection_map'])
                                             ]).astype(np.float16)
     if insert_port == 1:
         CleanPortfolio['Own'] = sum([CleanPortfolio['QB'].map(maps_dict['Own_map']),
                                     CleanPortfolio['RB1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['RB2'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR1'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR2'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['FLEX1'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['FLEX2'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['DST'].map(maps_dict['Own_map'])
+                                    CleanPortfolio['WR3'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['S_FLEX'].map(maps_dict['Own_map'])
                                     ]).astype(np.float16)
     
     if site_var1 == 'Draftkings':
@@ -295,7 +309,7 @@ def get_correlated_portfolio_for_sim(Total_Sample_Size):
     
     RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     
-    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
+    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'User/Field', 'Salary', 'Projection', 'Own']]
     
     return RandomPortfolio, maps_dict
           
@@ -307,54 +321,58 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
           
     RandomPortfolio['QB'] = pd.Series(list(RandomPortfolio['QB'].map(qb_dict)), dtype="string[pyarrow]")
     RandomPortfolio['RB1'] = pd.Series(list(RandomPortfolio['RB1'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
+    RandomPortfolio['RB2'] = pd.Series(list(RandomPortfolio['RB2'].map(full_pos_player_dict['pos_dicts'][0])), dtype="string[pyarrow]")
     RandomPortfolio['WR1'] = pd.Series(list(RandomPortfolio['WR1'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
     RandomPortfolio['WR2'] = pd.Series(list(RandomPortfolio['WR2'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
-    RandomPortfolio['FLEX1'] = pd.Series(list(RandomPortfolio['FLEX1'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
-    RandomPortfolio['FLEX2'] = pd.Series(list(RandomPortfolio['FLEX2'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
-    RandomPortfolio['DST'] = pd.Series(list(RandomPortfolio['DST'].map(def_dict)), dtype="string[pyarrow]")
+    RandomPortfolio['WR3'] = pd.Series(list(RandomPortfolio['WR3'].map(full_pos_player_dict['pos_dicts'][1])), dtype="string[pyarrow]")
+    RandomPortfolio['FLEX'] = pd.Series(list(RandomPortfolio['FLEX'].map(full_pos_player_dict['pos_dicts'][2])), dtype="string[pyarrow]")
+    RandomPortfolio['S_FLEX'] = pd.Series(list(RandomPortfolio['S_FLEX'].map(full_pos_player_dict['pos_dicts'][3])), dtype="string[pyarrow]")
     RandomPortfolio['plyr_list'] = RandomPortfolio[RandomPortfolio.columns.values.tolist()].values.tolist()
     RandomPortfolio['plyr_count'] = RandomPortfolio['plyr_list'].apply(lambda x: len(set(x)))
-    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 8].drop(columns=['plyr_list','plyr_count']).\
+    RandomPortfolio = RandomPortfolio[RandomPortfolio['plyr_count'] == 9].drop(columns=['plyr_list','plyr_count']).\
         reset_index(drop=True)
     
     del sizesplit
     del full_pos_player_dict
-    del ranges_dict 
+    del ranges_dict
 
     RandomPortfolio['QBs'] = RandomPortfolio['QB'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['RB1s'] = RandomPortfolio['RB1'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['RB2s'] = RandomPortfolio['RB2'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['WR1s'] = RandomPortfolio['WR1'].map(maps_dict['Salary_map']).astype(np.int32)
     RandomPortfolio['WR2s'] = RandomPortfolio['WR2'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['FLEX1s'] = RandomPortfolio['FLEX1'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['FLEX2s'] = RandomPortfolio['FLEX2'].map(maps_dict['Salary_map']).astype(np.int32)
-    RandomPortfolio['DSTs'] = RandomPortfolio['DST'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['WR3s'] = RandomPortfolio['WR3'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['FLEXs'] = RandomPortfolio['FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
+    RandomPortfolio['S_FLEXs'] = RandomPortfolio['S_FLEX'].map(maps_dict['Salary_map']).astype(np.int32)
     
     RandomPortfolio['QBp'] = RandomPortfolio['QB'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['RB1p'] = RandomPortfolio['RB1'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['RB2p'] = RandomPortfolio['RB2'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR1p'] = RandomPortfolio['WR1'].map(maps_dict['Projection_map']).astype(np.float16)
     RandomPortfolio['WR2p'] = RandomPortfolio['WR2'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['FLEX1p'] = RandomPortfolio['FLEX1'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['FLEX2p'] = RandomPortfolio['FLEX2'].map(maps_dict['Projection_map']).astype(np.float16)
-    RandomPortfolio['DSTp'] = RandomPortfolio['DST'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['WR3p'] = RandomPortfolio['WR3'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['FLEXp'] = RandomPortfolio['FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
+    RandomPortfolio['S_FLEXp'] = RandomPortfolio['S_FLEX'].map(maps_dict['Projection_map']).astype(np.float16)
     
     RandomPortfolio['QBo'] = RandomPortfolio['QB'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['RB1o'] = RandomPortfolio['RB1'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['RB2o'] = RandomPortfolio['RB2'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR1o'] = RandomPortfolio['WR1'].map(maps_dict['Own_map']).astype(np.float16)
     RandomPortfolio['WR2o'] = RandomPortfolio['WR2'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['FLEX1o'] = RandomPortfolio['FLEX1'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['FLEX2o'] = RandomPortfolio['FLEX2'].map(maps_dict['Own_map']).astype(np.float16)
-    RandomPortfolio['DSTo'] = RandomPortfolio['DST'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['WR3o'] = RandomPortfolio['WR3'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['FLEXo'] = RandomPortfolio['FLEX'].map(maps_dict['Own_map']).astype(np.float16)
+    RandomPortfolio['S_FLEXo'] = RandomPortfolio['S_FLEX'].map(maps_dict['Own_map']).astype(np.float16)
     
     RandomPortArray = RandomPortfolio.to_numpy()
     del RandomPortfolio
     
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,8:15].astype(int))]
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,15:22].astype(np.double))]
-    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,22:29].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,9:17].astype(int))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,17:25].astype(np.double))]
+    RandomPortArray = np.c_[RandomPortArray, np.einsum('ij->i',RandomPortArray[:,25:33].astype(np.double))]
     # st.write(RandomPortArray[:,:100])
-    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[8:29], axis=1)
+    RandomPortArrayOut = np.delete(RandomPortArray, np.s_[9:33], axis=1)
     # st.write(RandomPortArrayOut[:,:100])
-    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'User/Field', 'Salary', 'Projection', 'Own'])
+    RandomPortfolioDF = pd.DataFrame(RandomPortArrayOut, columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'User/Field', 'Salary', 'Projection', 'Own'])
     RandomPortfolioDF = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     del RandomPortArray
     del RandomPortArrayOut
@@ -362,29 +380,32 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     if insert_port == 1:
         CleanPortfolio['Salary'] = sum([CleanPortfolio['QB'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['RB1'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['RB2'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR1'].map(maps_dict['Salary_map']),
                                         CleanPortfolio['WR2'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['FLEX1'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['FLEX2'].map(maps_dict['Salary_map']),
-                                        CleanPortfolio['DST'].map(maps_dict['Salary_map'])
+                                        CleanPortfolio['WR3'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['FLEX'].map(maps_dict['Salary_map']),
+                                        CleanPortfolio['S_FLEX'].map(maps_dict['Salary_map'])
                                         ]).astype(np.int16)
     if insert_port == 1:
         CleanPortfolio['Projection'] = sum([CleanPortfolio['QB'].map(up_dict['Projection_map']),
                                             CleanPortfolio['RB1'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['RB2'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR1'].map(up_dict['Projection_map']),
                                             CleanPortfolio['WR2'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['FLEX1'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['FLEX2'].map(up_dict['Projection_map']),
-                                            CleanPortfolio['DST'].map(up_dict['Projection_map'])
+                                            CleanPortfolio['WR3'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['FLEX'].map(up_dict['Projection_map']),
+                                            CleanPortfolio['S_FLEX'].map(up_dict['Projection_map'])
                                             ]).astype(np.float16)
     if insert_port == 1:
         CleanPortfolio['Own'] = sum([CleanPortfolio['QB'].map(maps_dict['Own_map']),
                                     CleanPortfolio['RB1'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['RB2'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR1'].map(maps_dict['Own_map']),
                                     CleanPortfolio['WR2'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['FLEX1'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['FLEX2'].map(maps_dict['Own_map']),
-                                    CleanPortfolio['DST'].map(maps_dict['Own_map'])
+                                    CleanPortfolio['WR3'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['FLEX'].map(maps_dict['Own_map']),
+                                    CleanPortfolio['S_FLEX'].map(maps_dict['Own_map'])
                                     ]).astype(np.float16)
     
     if site_var1 == 'Draftkings':
@@ -393,7 +414,7 @@ def get_uncorrelated_portfolio_for_sim(Total_Sample_Size):
     
     RandomPortfolio = RandomPortfolioDF.sort_values(by=Sim_function, ascending=False)
     
-    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'User/Field', 'Salary', 'Projection', 'Own']]
+    RandomPortfolio = RandomPortfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'User/Field', 'Salary', 'Projection', 'Own']]
     
     return RandomPortfolio, maps_dict
 
@@ -435,7 +456,7 @@ with tab1:
                               player_team_dict = dict(zip(proj_dataframe.Player, proj_dataframe.Team))
                               
           with col2:
-                    st.info("The Portfolio file must contain only columns in order and explicitly named: 'QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', and 'DST'. Upload your projections first to avoid an error message.")
+                    st.info("The Portfolio file must contain only columns in order and explicitly named: 'QB', 'RB1', RB2, 'WR1', 'WR2', 'WR3', 'FLEX', and 'S_FLEX'. Upload your projections first to avoid an error message.")
                     portfolio_file = st.file_uploader("Upload Portfolio File", key = 'portfolio_uploader')
 
                     if portfolio_file is not None:
@@ -447,158 +468,173 @@ with tab1:
                               
                             try:
                                 try:
-                                    portfolio_dataframe.columns=["QB", "RB1", "WR1", "WR2", "FLEX1", "FLEX2", "DST"]
+                                    portfolio_dataframe.columns=["QB", "RB1", "RB2", "WR1", "WR2", "WR3", "FLEX", "S_FLEX"]
                                     split_portfolio = portfolio_dataframe
                                     split_portfolio[['QB', 'QB_ID']] = split_portfolio.QB.str.split("(", n=1, expand = True)
                                     split_portfolio[['RB1', 'RB1_ID']] = split_portfolio.RB1.str.split("(", n=1, expand = True)
+                                    split_portfolio[['RB2', 'RB2_ID']] = split_portfolio.RB2.str.split("(", n=1, expand = True)
                                     split_portfolio[['WR1', 'WR1_ID']] = split_portfolio.WR1.str.split("(", n=1, expand = True)
                                     split_portfolio[['WR2', 'WR2_ID']] = split_portfolio.WR2.str.split("(", n=1, expand = True)
-                                    split_portfolio[['FLEX1', 'FLEX1_ID']] = split_portfolio.FLEX1.str.split("(", n=1, expand = True)
-                                    split_portfolio[['FLEX2', 'FLEX2_ID']] = split_portfolio.FLEX2.str.split("(", n=1, expand = True)
-                                    split_portfolio[['DST', 'DST_ID']] = split_portfolio.DST.str.split("(", n=1, expand = True)
+                                    split_portfolio[['WR3', 'WR3_ID']] = split_portfolio.WR3.str.split("(", n=1, expand = True)
+                                    split_portfolio[['FLEX', 'FLEX_ID']] = split_portfolio.FLEX.str.split("(", n=1, expand = True)
+                                    split_portfolio[['S_FLEX', 'S_FLEX_ID']] = split_portfolio.S_FLEX.str.split("(", n=1, expand = True)
       
                                     split_portfolio['QB'] = split_portfolio['QB'].str.strip()
                                     split_portfolio['RB1'] = split_portfolio['RB1'].str.strip()
+                                    split_portfolio['RB2'] = split_portfolio['RB2'].str.strip()
                                     split_portfolio['WR1'] = split_portfolio['WR1'].str.strip()
                                     split_portfolio['WR2'] = split_portfolio['WR2'].str.strip()
-                                    split_portfolio['FLEX1'] = split_portfolio['FLEX1'].str.strip()
-                                    split_portfolio['FLEX2'] = split_portfolio['FLEX2'].str.strip()
-                                    split_portfolio['DST'] = split_portfolio['DST'].str.strip()
+                                    split_portfolio['WR3'] = split_portfolio['WR3'].str.strip()
+                                    split_portfolio['FLEX'] = split_portfolio['FLEX'].str.strip()
+                                    split_portfolio['S_FLEX'] = split_portfolio['S_FLEX'].str.strip()
                                     
                                     st.table(split_portfolio.head(10))
       
                                     split_portfolio['Salary'] = sum([split_portfolio['QB'].map(player_salary_dict),
                                               split_portfolio['RB1'].map(player_salary_dict),
+                                              split_portfolio['RB2'].map(player_salary_dict),
                                               split_portfolio['WR1'].map(player_salary_dict),
                                               split_portfolio['WR2'].map(player_salary_dict),
-                                              split_portfolio['FLEX1'].map(player_salary_dict),
-                                              split_portfolio['FLEX2'].map(player_salary_dict),
-                                              split_portfolio['DST'].map(player_salary_dict)])
+                                              split_portfolio['WR3'].map(player_salary_dict),
+                                              split_portfolio['FLEX'].map(player_salary_dict),
+                                              split_portfolio['S_FLEX'].map(player_salary_dict)])
                                     
                                     split_portfolio['Projection'] = sum([split_portfolio['QB'].map(player_proj_dict),
                                               split_portfolio['RB1'].map(player_proj_dict),
+                                              split_portfolio['RB2'].map(player_proj_dict),
                                               split_portfolio['WR1'].map(player_proj_dict),
                                               split_portfolio['WR2'].map(player_proj_dict),
-                                              split_portfolio['FLEX1'].map(player_proj_dict),
-                                              split_portfolio['FLEX2'].map(player_proj_dict),
-                                              split_portfolio['DST'].map(player_proj_dict)])
+                                              split_portfolio['WR3'].map(player_proj_dict),
+                                              split_portfolio['FLEX'].map(player_proj_dict),
+                                              split_portfolio['S_FLEX'].map(player_proj_dict)])
                                     
                                     split_portfolio['Ownership'] = sum([split_portfolio['QB'].map(player_own_dict),
                                               split_portfolio['RB1'].map(player_own_dict),
+                                              split_portfolio['RB2'].map(player_own_dict),
                                               split_portfolio['WR1'].map(player_own_dict),
                                               split_portfolio['WR2'].map(player_own_dict),
-                                              split_portfolio['FLEX1'].map(player_own_dict),
-                                              split_portfolio['FLEX2'].map(player_own_dict),
-                                              split_portfolio['DST'].map(player_own_dict)])
+                                              split_portfolio['WR3'].map(player_own_dict),
+                                              split_portfolio['FLEX'].map(player_own_dict),
+                                              split_portfolio['S_FLEX'].map(player_own_dict)])
                                     
                                     split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
                                     split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
+                                    split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
                                     split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
                                     split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                                    split_portfolio['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
-                                    split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].map(player_team_dict)
-                                    split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
+                                    split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
+                                    split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
+                                    split_portfolio['S_FLEX_team'] = split_portfolio['S_FLEX'].map(player_team_dict)
       
-                                    split_portfolio = split_portfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                        'RB1_team', 'WR1_team', 'WR2_team', 'FLEX1_team', 'FLEX2_team', 'DST_team']]
+                                    split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'Salary', 'Projection', 'Ownership', 'QB_team',
+                                                                        'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'W32_team', 'FLEX_team', 'S_FLEX_team']]
                                 
                                 
                                 except:
-                                    portfolio_dataframe.columns=["QB", "RB1", "WR1", "WR2", "FLEX1", "FLEX2", "DST"]
+                                    portfolio_dataframe.columns=["QB", "RB1", "RB2", "WR1", "WR2", "WR3", "FLEX", "S_FLEX"]
                                     
                                     split_portfolio = portfolio_dataframe
                                     split_portfolio[['QB_ID', 'QB']] = split_portfolio.QB.str.split(":", n=1, expand = True)
                                     split_portfolio[['RB1_ID', 'RB1']] = split_portfolio.RB1.str.split(":", n=1, expand = True)
+                                    split_portfolio[['RB2_ID', 'RB2']] = split_portfolio.RB2.str.split(":", n=1, expand = True)
                                     split_portfolio[['WR1_ID', 'WR1']] = split_portfolio.WR1.str.split(":", n=1, expand = True)
                                     split_portfolio[['WR2_ID', 'WR2']] = split_portfolio.WR2.str.split(":", n=1, expand = True)
-                                    split_portfolio[['FLEX1_ID', 'TE']] = split_portfolio.FLEX1.str.split(":", n=1, expand = True)
-                                    split_portfolio[['FLEX2_ID', 'FLEX']] = split_portfolio.FLEX2.str.split(":", n=1, expand = True)
-                                    split_portfolio[['DST_ID', 'DST']] = split_portfolio.DST.str.split(":", n=1, expand = True)
+                                    split_portfolio[['WR3_ID', 'WR3']] = split_portfolio.WR3.str.split(":", n=1, expand = True)
+                                    split_portfolio[['FLEX_ID', 'FLEX']] = split_portfolio.FLEX.str.split(":", n=1, expand = True)
+                                    split_portfolio[['S_FLEX_ID', 'S_FLEX']] = split_portfolio.S_FLEX.str.split(":", n=1, expand = True)
                                     
                                     split_portfolio['QB'] = split_portfolio['QB'].str.strip()
                                     split_portfolio['RB1'] = split_portfolio['RB1'].str.strip()
+                                    split_portfolio['RB2'] = split_portfolio['RB2'].str.strip()
                                     split_portfolio['WR1'] = split_portfolio['WR1'].str.strip()
                                     split_portfolio['WR2'] = split_portfolio['WR2'].str.strip()
-                                    split_portfolio['FLEX1'] = split_portfolio['FLEX1'].str.strip()
-                                    split_portfolio['FLEX2'] = split_portfolio['FLEX2'].str.strip()
-                                    split_portfolio['DST'] = split_portfolio['DST'].str.strip()
+                                    split_portfolio['WR3'] = split_portfolio['WR3'].str.strip()
+                                    split_portfolio['FLEX'] = split_portfolio['FLEX'].str.strip()
+                                    split_portfolio['S_FLEX'] = split_portfolio['S_FLEX'].str.strip()
       
                                     split_portfolio['Salary'] = sum([split_portfolio['QB'].map(player_salary_dict),
                                               split_portfolio['RB1'].map(player_salary_dict),
+                                              split_portfolio['RB2'].map(player_salary_dict),
                                               split_portfolio['WR1'].map(player_salary_dict),
                                               split_portfolio['WR2'].map(player_salary_dict),
-                                              split_portfolio['FLEX1'].map(player_salary_dict),
-                                              split_portfolio['FLEX2'].map(player_salary_dict),
-                                              split_portfolio['DST'].map(player_salary_dict)])
+                                              split_portfolio['WR3'].map(player_salary_dict),
+                                              split_portfolio['FLEX'].map(player_salary_dict),
+                                              split_portfolio['S_FLEX'].map(player_salary_dict)])
                                     
                                     split_portfolio['Projection'] = sum([split_portfolio['QB'].map(player_proj_dict),
                                               split_portfolio['RB1'].map(player_proj_dict),
+                                              split_portfolio['RB2'].map(player_proj_dict),
                                               split_portfolio['WR1'].map(player_proj_dict),
                                               split_portfolio['WR2'].map(player_proj_dict),
-                                              split_portfolio['FLEX1'].map(player_proj_dict),
-                                              split_portfolio['FLEX2'].map(player_proj_dict),
-                                              split_portfolio['DST'].map(player_proj_dict)])
+                                              split_portfolio['WR3'].map(player_proj_dict),
+                                              split_portfolio['FLEX'].map(player_proj_dict),
+                                              split_portfolio['S_FLEX'].map(player_proj_dict)])
                                                                     
                                     st.table(split_portfolio.head(10))
                                     split_portfolio['Ownership'] = sum([split_portfolio['QB'].map(player_own_dict),
                                               split_portfolio['RB1'].map(player_own_dict),
+                                              split_portfolio['RB2'].map(player_own_dict),
                                               split_portfolio['WR1'].map(player_own_dict),
                                               split_portfolio['WR2'].map(player_own_dict),
-                                              split_portfolio['FLEX1'].map(player_own_dict),
-                                              split_portfolio['FLEX2'].map(player_own_dict),
-                                              split_portfolio['DST'].map(player_own_dict)])
+                                              split_portfolio['WR3'].map(player_own_dict),
+                                              split_portfolio['FLEX'].map(player_own_dict),
+                                              split_portfolio['S_FLEX'].map(player_own_dict)])
                                     
                                     split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
                                     split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
+                                    split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
                                     split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
                                     split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
-                                    split_portfolio['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
-                                    split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].map(player_team_dict)
-                                    split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
+                                    split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
+                                    split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
+                                    split_portfolio['S_FLEX_team'] = split_portfolio['S_FLEX'].map(player_team_dict)
       
-                                    split_portfolio = split_portfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                        'RB1_team', 'WR1_team', 'WR2_team', 'FLEX1_team', 'FLEX2_team', 'DST_team']]
+                                    split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'Salary', 'Projection', 'Ownership', 'QB_team',
+                                                                        'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'FLEX_team', 'S_FLEX_team']]
                                   
                             except:
                                  split_portfolio = portfolio_dataframe
                                 
                                  split_portfolio['Salary'] = sum([split_portfolio['QB'].map(player_salary_dict),
                                            split_portfolio['RB1'].map(player_salary_dict),
+                                           split_portfolio['RB2'].map(player_salary_dict),
                                            split_portfolio['WR1'].map(player_salary_dict),
                                            split_portfolio['WR2'].map(player_salary_dict),
-                                           split_portfolio['FLEX1'].map(player_salary_dict),
-                                           split_portfolio['FLEX2'].map(player_salary_dict),
-                                           split_portfolio['DST'].map(player_salary_dict)])
+                                           split_portfolio['WR3'].map(player_salary_dict),
+                                           split_portfolio['FLEX'].map(player_salary_dict),
+                                           split_portfolio['S_FLEX'].map(player_salary_dict)])
                                 
                                  split_portfolio['Projection'] = sum([split_portfolio['QB'].map(player_proj_dict),
                                            split_portfolio['RB1'].map(player_proj_dict),
+                                           split_portfolio['RB2'].map(player_proj_dict),
                                            split_portfolio['WR1'].map(player_proj_dict),
                                            split_portfolio['WR2'].map(player_proj_dict),
-                                           split_portfolio['FLEX1'].map(player_proj_dict),
-                                           split_portfolio['FLEX2'].map(player_proj_dict),
-                                           split_portfolio['DST'].map(player_proj_dict)])
+                                           split_portfolio['WR3'].map(player_proj_dict),
+                                           split_portfolio['FLEX'].map(player_proj_dict),
+                                           split_portfolio['S_FLEX'].map(player_proj_dict)])
                                 
                                  split_portfolio['Ownership'] = sum([split_portfolio['QB'].map(player_own_dict),
                                            split_portfolio['RB1'].map(player_own_dict),
+                                           split_portfolio['RB2'].map(player_own_dict),
                                            split_portfolio['WR1'].map(player_own_dict),
                                            split_portfolio['WR2'].map(player_own_dict),
-                                           split_portfolio['FLEX1'].map(player_own_dict),
-                                           split_portfolio['FLEX2'].map(player_own_dict),
-                                           split_portfolio['DST'].map(player_own_dict)])
+                                           split_portfolio['WR3'].map(player_own_dict),
+                                           split_portfolio['FLEX'].map(player_own_dict),
+                                           split_portfolio['S_FLEX'].map(player_own_dict)])
  
                             split_portfolio['QB_team'] = split_portfolio['QB'].map(player_team_dict)
                             split_portfolio['RB1_team'] = split_portfolio['RB1'].map(player_team_dict)
+                            split_portfolio['RB2_team'] = split_portfolio['RB2'].map(player_team_dict)
                             split_portfolio['WR1_team'] = split_portfolio['WR1'].map(player_team_dict)
                             split_portfolio['WR2_team'] = split_portfolio['WR2'].map(player_team_dict)
                             split_portfolio['WR3_team'] = split_portfolio['WR3'].map(player_team_dict)
-                            split_portfolio['FLEX1_team'] = split_portfolio['FLEX1'].map(player_team_dict)
-                            split_portfolio['FLEX2_team'] = split_portfolio['FLEX2'].map(player_team_dict)
-                            split_portfolio['DST_team'] = split_portfolio['DST'].map(player_team_dict)
+                            split_portfolio['FLEX_team'] = split_portfolio['FLEX'].map(player_team_dict)
+                            split_portfolio['S_FLEX_team'] = split_portfolio['S_FLEX'].map(player_team_dict)
   
-                            split_portfolio = split_portfolio[['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', 'Projection', 'Ownership', 'QB_team',
-                                                                'RB1_team', 'WR1_team', 'WR2_team', 'FLEX1_team', 'FLEX2_team', 'DST_team']]
+                            split_portfolio = split_portfolio[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'Salary', 'Projection', 'Ownership', 'QB_team',
+                                                                'RB1_team', 'RB2_team', 'WR1_team', 'WR2_team', 'WR3_team', 'FLEX_team', 'S_FLEX_team']]
                               
-                            for player_cols in split_portfolio.iloc[:, :7]:
+                            for player_cols in split_portfolio.iloc[:, :8]:
                                       static_col_raw = split_portfolio[player_cols].value_counts()
                                       static_col = static_col_raw.to_frame()
                                       static_col.reset_index(inplace=True)
@@ -619,7 +655,7 @@ with tab1:
           if portfolio_file is not None:
                     split_portfolio = split_portfolio
 
-                    for player_cols in split_portfolio.iloc[:, :7]:
+                    for player_cols in split_portfolio.iloc[:, :8]:
                               exposure_col_raw = split_portfolio[player_cols].value_counts()
                               exposure_col = exposure_col_raw.to_frame()
                               exposure_col.reset_index(inplace=True)
@@ -646,7 +682,7 @@ with tab1:
                               st.header('Portfolio View')
                               split_portfolio = split_portfolio.reset_index()
                               split_portfolio['Lineup'] = split_portfolio['index'] + 1
-                              display_portfolio = split_portfolio[['Lineup', 'QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST', 'Salary', 'Projection', 'Ownership']]
+                              display_portfolio = split_portfolio[['Lineup', 'QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX', 'Salary', 'Projection', 'Ownership']]
                               display_portfolio = display_portfolio.set_index('Lineup')
                               st.dataframe(display_portfolio.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Ownership']).format(precision=2))
                               del split_portfolio
@@ -731,25 +767,25 @@ with tab2:
                         OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (10 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
                         OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
                         OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                        OwnFrame['Own'] = OwnFrame['Own%'] * (700 / OwnFrame['Own%'].sum())
+                        OwnFrame['Own'] = OwnFrame['Own%'] * (800 / OwnFrame['Own%'].sum())
                     if contest_var1 == 'Medium':
                         OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (6 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
                         OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
                         OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                        OwnFrame['Own'] = OwnFrame['Own%'] * (700 / OwnFrame['Own%'].sum())
+                        OwnFrame['Own'] = OwnFrame['Own%'] * (800 / OwnFrame['Own%'].sum())
                     if contest_var1 == 'Large':
                         OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
                         OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (1.5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
                         OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
-                        OwnFrame['Own'] = OwnFrame['Own%'] * (700 / OwnFrame['Own%'].sum())
+                        OwnFrame['Own'] = OwnFrame['Own%'] * (800 / OwnFrame['Own%'].sum())
                     Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
                     
                     del OwnFrame
                 
                 if insert_port == 1:
-                    UserPortfolio = portfolio_dataframe[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
+                    UserPortfolio = portfolio_dataframe[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX']]
                 elif insert_port == 0:
-                    UserPortfolio = pd.DataFrame(columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
+                    UserPortfolio = pd.DataFrame(columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX'])
         
                 Overall_Proj.replace('', np.nan, inplace=True)
                 Overall_Proj = Overall_Proj.dropna(subset=['Median'])
@@ -819,6 +855,10 @@ with tab2:
                 pos_players.dropna(subset=['Median']).reset_index(drop=True)
                 pos_players = pos_players.reset_index(drop=True)
                 
+                s_pos_players = pd.concat([qbs_raw, rbs_raw, wrs_raw])
+                pos_players.dropna(subset=['Median']).reset_index(drop=True)
+                pos_players = pos_players.reset_index(drop=True)
+                
                 del qbs_raw
                 del defs_raw
                 del rbs_raw
@@ -830,7 +870,7 @@ with tab2:
                         Raw_Portfolio = pd.DataFrame()
                         
                         # Loop through each position and split the data accordingly
-                        positions = ['QB', 'RB1', 'WR1', 'WR2', 'FLEX1', 'FLEX2', 'DST']
+                        positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX']
                         for pos in positions:
                             temp_df = UserPortfolio[pos].str.split("(", n=1, expand=True)
                             temp_df.columns = [pos, 'Drop']
@@ -847,7 +887,7 @@ with tab2:
                         
                         # Create frequency table for players
                         cleaport_players = pd.DataFrame(
-                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:7].values, return_counts=True)),
+                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:8].values, return_counts=True)),
                             columns=['Player', 'Freq']
                         ).sort_values('Freq', ascending=False).reset_index(drop=True)
                         cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
@@ -868,7 +908,7 @@ with tab2:
                         
                         # Create frequency table for players
                         cleaport_players = pd.DataFrame(
-                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:7].values, return_counts=True)),
+                            np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:8].values, return_counts=True)),
                             columns=['Player', 'Freq']
                         ).sort_values('Freq', ascending=False).reset_index(drop=True)
                         cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
@@ -880,15 +920,15 @@ with tab2:
 
                 elif insert_port == 0:
                     CleanPortfolio = UserPortfolio
-                    cleaport_players = pd.DataFrame(np.column_stack(np.unique(CleanPortfolio.iloc[:,0:7].values, return_counts=True)),
+                    cleaport_players = pd.DataFrame(np.column_stack(np.unique(CleanPortfolio.iloc[:,0:8].values, return_counts=True)),
                                                columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                     cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
                     nerf_frame = Overall_Proj
                     
                 ref_dict = {
-                    'pos':['RB', 'WR', 'FLEX'],
-                    'pos_dfs':['RB_Table', 'WR_Table', 'FLEX_Table'],
-                    'pos_dicts':['rb_dict', 'wr_dict', 'flex_dict']
+                    'pos':['RB', 'WR', 'FLEX', 'S_FLEX'],
+                    'pos_dfs':['RB_Table', 'WR_Table', 'FLEX_Table', 'S_FLEX_Table'],
+                    'pos_dicts':['rb_dict', 'wr_dict', 'flex_dict', 's_flex_table']
                     }
         
                 maps_dict = {
@@ -966,7 +1006,7 @@ with tab2:
                     else:
                         sample_arrays = sample_arrays1
             
-                    final_array = sample_arrays[sample_arrays[:, 8].argsort()[::-1]]
+                    final_array = sample_arrays[sample_arrays[:, 9].argsort()[::-1]]
                     best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
                     Sim_Winners.append(best_lineup)
                     SimVar += 1
@@ -993,9 +1033,9 @@ with tab2:
                 Sim_Winner_Export = Sim_Winner_Frame.copy()
                 
                 # Conditional Replacement
-                columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
+                columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'FLEX', 'S_FLEX']
                 
-                player_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:7].values, return_counts=True)),
+                player_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:8].values, return_counts=True)),
                                             columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                 player_freq['Freq'] = player_freq['Freq'].astype(int)
                 player_freq['Position'] = player_freq['Player'].map(maps_dict['Pos_map'])
@@ -1023,7 +1063,7 @@ with tab2:
 
                 qb_freq = qb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
 
-                rb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,1:2].values, return_counts=True)),
+                rb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,1:3].values, return_counts=True)),
                                            columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                 rb_freq['Freq'] = rb_freq['Freq'].astype(int)
                 rb_freq['Position'] = rb_freq['Player'].map(maps_dict['Pos_map'])
@@ -1037,7 +1077,7 @@ with tab2:
 
                 rb_freq = rb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
                 
-                wr_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[2, 3]].values, return_counts=True)),
+                wr_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
                                            columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                 wr_freq['Freq'] = wr_freq['Freq'].astype(int)
                 wr_freq['Position'] = wr_freq['Player'].map(maps_dict['Pos_map'])
@@ -1051,7 +1091,7 @@ with tab2:
 
                 wr_freq = wr_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
                 
-                flex_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[4, 5]].values, return_counts=True)),
+                flex_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,5:6].values, return_counts=True)),
                                            columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                 flex_freq['Freq'] = flex_freq['Freq'].astype(int)
                 flex_freq['Position'] = flex_freq['Player'].map(maps_dict['Pos_map'])
@@ -1065,7 +1105,7 @@ with tab2:
 
                 flex_freq = flex_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
                 
-                dst_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,5:6].values, return_counts=True)),
+                dst_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,6:7].values, return_counts=True)),
                                            columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
                 dst_freq['Freq'] = dst_freq['Freq'].astype(int)
                 dst_freq['Position'] = dst_freq['Player'].map(maps_dict['Pos_map'])
@@ -1092,7 +1132,7 @@ with tab2:
             
             with st.container():
                 freq_container = st.empty()
-                tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB Exposures', 'WR Exposures', 'FLEX Exposures', 'DST Exposures'])
+                tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB Exposures', 'WR Exposures', 'FLEX Exposures', 'S_FLEX Exposures'])
                 with tab1:
                     st.dataframe(player_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
                     st.download_button(
@@ -1138,6 +1178,6 @@ with tab2:
                     st.download_button(
                         label="Export Exposures",
                         data=convert_df_to_csv(dst_freq),
-                        file_name='dst_freq_export.csv',
+                        file_name='s_flex_freq_export.csv',
                         mime='text/csv',
                     )