diff --git a/app/services/loft_service.py b/app/services/loft_service.py
index c767388..3b6c207 100644
--- a/app/services/loft_service.py
+++ b/app/services/loft_service.py
@@ -79,8 +79,7 @@ class LoftService(Base):
       problem = None
 
       if bundle_constraint:
-        bundles_amount = random.randint(int(bundle_constraint.minimum), int(bundle_constraint.maximum))
-        problem = self.recursive_solve(items, bundles_amount)
+        problem = self.recursive_solve(items, int(bundle_constraint.minimum), int(bundle_constraint.maximum))
       else: # no bundles
         problem = self.solve(items)
 
@@ -95,7 +94,9 @@ class LoftService(Base):
 
       return solution
 
-  def recursive_solve(self, items, bundles_amount, attempts = 1000) -> LpProblem:
+  def recursive_solve(self, items, min, max, attempts = 800) -> LpProblem:
+    bundles_amount = random.randint(min, max)
+    logging.info(f'min: {min}, max: {max}, bundles amount: {bundles_amount}')
     selected_bundles = solver_helper.get_random_bundles(
                                         self.solver_run.total_form_items,
                                         bundles_amount,
@@ -109,7 +110,7 @@ class LoftService(Base):
     else:
       logging.info('recursing...')
       logging.info(attempts)
-      return self.recursive_solve(items, bundles_amount, attempts - 1)
+      return self.recursive_solve(items, min, max, attempts - 1)
 
   def solve(self, items: list[Item], bundles: list[Bundle] or None = None) -> LpProblem:
     # create problem
@@ -129,15 +130,15 @@ class LoftService(Base):
     # multi-objective constraints
     for target in self.solver_run.objective_function.tif_targets:
       problem += lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
-                      for item in self.solver_run.items]) >= target.value - target.value * 0.2, f'max tif theta ({target.theta}) target value {target.value}'
+                      for item in self.solver_run.items]) >= target.value - 4, f'max tif theta ({target.theta}) target value {target.value}'
       problem += lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
-                      for item in self.solver_run.items]) <= target.value + target.value * 0.2, f'min tif theta ({target.theta}) target value {target.value}'
+                      for item in self.solver_run.items]) <= target.value + 4, f'min tif theta ({target.theta}) target value {target.value}'
 
     for target in self.solver_run.objective_function.tcc_targets:
       problem += lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
-                      for item in self.solver_run.items]) >= target.value - target.value * 0.1, f'max tcc theta ({target.theta}) target value {target.value}'
+                      for item in self.solver_run.items]) >= target.value - 18, f'max tcc theta ({target.theta}) target value {target.value}'
       problem += lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
-                      for item in self.solver_run.items]) <= target.value + target.value * 0.1, f'min tcc theta ({target.theta}) target value {target.value}'
+                      for item in self.solver_run.items]) <= target.value + 18, f'min tcc theta ({target.theta}) target value {target.value}'
 
     # solve problem
     problem.solve()