diff --git "a/database_queries.py" "b/database_queries.py"
--- "a/database_queries.py"
+++ "b/database_queries.py"
@@ -15,21 +15,21 @@ right_nfl_name_teams = ['Broncos', 'Commanders', 'Bengals', 'Cardinals', 'Rams',
 'Chiefs', 'Chargers', 'Ravens', 'Bills', 'Vikings', 'Bears']
 
 
-def _showdown_seed_filter(salary_min, salary_max):
+def _showdown_seed_filter(salary_min, salary_max, team_count_min=None, team_count_max=None):
     """Mongo filter for Showdown seed collections: salary band and at least one team."""
     return {
         'salary': {'$gte': salary_min, '$lte': salary_max},
-        'Team_count': {'$gte': 1},
+        'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999},
     }
 
 
-def _showdown_seed_filter_with_players(filter_query, salary_min, salary_max):
+def _showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min=None, team_count_max=None):
     """AND player filter (e.g. {'$or': [...]}) with salary and Team_count constraints."""
     return {
         '$and': [
             filter_query,
-            {'salary': {'$gte': salary_min, '$lte': salary_max}},
-            {'Team_count': {'$gte': 1}},
+            {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}},
+            {'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}},
         ],
     }
 
@@ -122,7 +122,7 @@ def init_nfl_baselines(type_var: str, site_var: str, slate_var: str):
 
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
 
-def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -149,18 +149,18 @@ def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
@@ -190,18 +190,18 @@ def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
@@ -231,18 +231,18 @@ def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
@@ -266,18 +266,18 @@ def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -290,7 +290,7 @@ def init_DK_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
 
     return DK_seed
 
-def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -318,18 +318,18 @@ def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
@@ -359,18 +359,18 @@ def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
@@ -400,18 +400,18 @@ def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
@@ -436,18 +436,18 @@ def init_FD_NFL_lineups(type_var, slate_var, prio_var, prio_mix, nfl_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -548,7 +548,7 @@ def init_nba_baselines(type_var: str, site_var: str, slate_var: str):
     
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map, minutes_map, locked_teams_list
 
-def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -574,18 +574,18 @@ def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])
@@ -614,18 +614,18 @@ def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])
@@ -654,18 +654,18 @@ def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'FLEX'])
@@ -689,18 +689,18 @@ def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -711,7 +711,7 @@ def init_DK_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
 
     return DK_seed
 
-def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -738,18 +738,18 @@ def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])
@@ -778,18 +778,18 @@ def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])
@@ -818,18 +818,18 @@ def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 1
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['PG1', 'PG2', 'SG1', 'SG2', 'SF1', 'SF2', 'PF1', 'PF2', 'C'])
@@ -854,18 +854,18 @@ def init_FD_NBA_lineups(type_var, slate_var, prio_var, prio_mix, nba_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -944,7 +944,7 @@ def init_nhl_baselines(type_var: str, site_var: str, slate_var: str):
     
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
 
-def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -970,18 +970,18 @@ def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'])
@@ -1010,18 +1010,18 @@ def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'])
@@ -1050,18 +1050,18 @@ def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'W3', 'D1', 'D2', 'G', 'FLEX'])
@@ -1085,18 +1085,18 @@ def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -1107,7 +1107,7 @@ def init_DK_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
 
     return DK_seed
 
-def init_FD_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_FD_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1134,18 +1134,18 @@ def init_FD_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'])
@@ -1174,18 +1174,18 @@ def init_FD_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'])
@@ -1214,18 +1214,18 @@ def init_FD_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['C1', 'C2', 'W1', 'W2', 'D1', 'D2', 'FLEX1', 'FLEX2', 'G'])
@@ -1250,18 +1250,18 @@ def init_FD_NHL_lineups(type_var, slate_var, prio_var, prio_mix, nhl_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -1340,7 +1340,7 @@ def init_mlb_baselines(type_var: str, site_var: str, slate_var: str):
     
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
 
-def init_DK_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_DK_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1366,18 +1366,18 @@ def init_DK_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3'])
@@ -1406,18 +1406,18 @@ def init_DK_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3'])
@@ -1446,18 +1446,18 @@ def init_DK_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3'])
@@ -1481,18 +1481,18 @@ def init_DK_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -1503,7 +1503,7 @@ def init_DK_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
 
     return DK_seed
 
-def init_FD_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translation, lineup_num, salary_min, salary_max, player_var2):
+def init_FD_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translation, lineup_num, salary_min, salary_max, team_count_min, team_count_max, player_var2):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1530,18 +1530,18 @@ def init_FD_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL'])
@@ -1570,18 +1570,18 @@ def init_FD_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL'])
@@ -1610,18 +1610,18 @@ def init_FD_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL'])
@@ -1646,18 +1646,18 @@ def init_FD_MLB_lineups(type_var, slate_var, prio_var, prio_mix, mlb_db_translat
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -1738,7 +1738,7 @@ def init_mma_baselines(type_var: str, site_var: str, slate_var: str):
     
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map, opp_map
 
-def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
+def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2, team_count_min=None, team_count_max=None):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1764,18 +1764,18 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -1804,18 +1804,18 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -1844,18 +1844,18 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -1879,18 +1879,18 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -1901,7 +1901,7 @@ def init_DK_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
 
     return DK_seed
 
-def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
+def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2, team_count_min=None, team_count_max=None):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -1928,18 +1928,18 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -1968,18 +1968,18 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2008,18 +2008,18 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num = ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2044,18 +2044,18 @@ def init_FD_MMA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'])
@@ -2134,7 +2134,7 @@ def init_pga_baselines(type_var: str, site_var: str, slate_var: str):
     
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map
 
-def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
+def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2, team_count_min=None, team_count_max=None):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -2160,18 +2160,18 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2200,18 +2200,18 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2240,18 +2240,18 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2280,18 +2280,18 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2305,7 +2305,7 @@ def init_DK_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
 
     return DK_seed
 
-def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
+def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2, team_count_min=None, team_count_max=None):
     
     if prio_var == 'Mix':
         prio_var = None
@@ -2331,18 +2331,18 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2371,18 +2371,18 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2411,18 +2411,18 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2451,18 +2451,18 @@ def init_FD_PGA_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, sal
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2550,7 +2550,7 @@ def init_nascar_baselines(type_var: str, site_var: str, slate_var: str):
     
     return dk_roo_raw, fd_roo_raw, dk_sd_roo_raw, fd_sd_roo_raw, dk_id_map, fd_id_map, dk_sd_id_map, fd_sd_id_map, grid_map
 
-def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
+def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2, team_count_min=None, team_count_max=None):
 
     if prio_var == 'Mix':
         prio_var = None
@@ -2576,18 +2576,18 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2615,18 +2615,18 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2654,18 +2654,18 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2694,18 +2694,18 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2719,7 +2719,7 @@ def init_DK_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
 
     return DK_seed
 
-def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2):
+def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num, salary_min, salary_max, player_var2, team_count_min=None, team_count_max=None):
     
     if prio_var == 'Mix':
         prio_var = None
@@ -2745,18 +2745,18 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
             
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2785,18 +2785,18 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2825,18 +2825,18 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                     # Combine all player conditions with $or
                     if query_conditions:
                         filter_query = {'$or': query_conditions}
-                        cursor1 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find(filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'$and': [filter_query, {'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}]}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     else:
-                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                        cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                        cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
                 else:
-                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                     raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}}).sort(prio_var, -1).limit(lineup_num)
+                cursor = collection.find({'salary': {'$gte': salary_min, '$lte': salary_max}, 'Team_count': {'$gte': team_count_min if team_count_min is not None else 1, '$lte': team_count_max if team_count_max is not None else 999}}).sort(prio_var, -1).limit(lineup_num)
                 raw_display = pd.DataFrame(list(cursor))
 
             raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])
@@ -2865,18 +2865,18 @@ def init_FD_NASCAR_lineups(type_var, slate_var, prio_var, prio_mix, lineup_num,
                 # Combine all player conditions with $or
                 if query_conditions:
                     filter_query = {'$or': query_conditions}
-                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter_with_players(filter_query, salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 else:
-                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                    cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                    cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
             else:
-                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
-                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
+                cursor1 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).limit(math.ceil(lineup_num * (prio_mix / 100)))
+                cursor2 = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort('Own', -1).limit(math.ceil(lineup_num * ((100 - prio_mix) / 100)))
                 raw_display = pd.concat([pd.DataFrame(list(cursor1)), pd.DataFrame(list(cursor2))])
         else:
-            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max)).sort(prio_var, -1).limit(lineup_num)
+            cursor = collection.find(_showdown_seed_filter(salary_min, salary_max, team_count_min, team_count_max)).sort(prio_var, -1).limit(lineup_num)
             raw_display = pd.DataFrame(list(cursor))
 
         raw_display = raw_display.drop_duplicates(subset=['FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'FLEX6'])