```json
{
  "sym_variables": [
    ("x0", "hours worked by Bill"),
    ("x1", "hours worked by Laura"),
    ("x2", "hours worked by Jean"),
    ("x3", "hours worked by Bobby"),
    ("x4", "hours worked by John"),
    ("x5", "hours worked by Dale")
  ],
  "objective_function": "9*x0 + 4*x1 + 7*x2 + 3*x3 + 3*x4 + 3*x5",
  "constraints": [
    "8*x0 + 6*x4 >= 5",
    "5*x1 + 3*x2 >= 15",
    "3*x2 + 4*x3 + 6*x4 >= 12",
    "8*x0 + 3*x2 + 6*x4 >= 12",
    "8*x0 + 5*x1 + 6*x4 >= 12",
    "5*x1 + 3*x2 + 9*x5 >= 12",
    "8*x0 + 3*x2 + 9*x5 >= 12",
    "3*x2 + 4*x3 + 6*x4 >= 14",
    "8*x0 + 3*x2 + 6*x4 >= 14",
    "8*x0 + 5*x1 + 6*x4 >= 14",
    "5*x1 + 3*x2 + 9*x5 >= 14",
    "8*x0 + 3*x2 + 9*x5 >= 14",
    "3*x2 + 4*x3 + 6*x4 >= 17",
    "8*x0 + 3*x2 + 6*x4 >= 17",
    "8*x0 + 5*x1 + 6*x4 >= 17",
    "5*x1 + 3*x2 + 9*x5 >= 17",
    "8*x0 + 3*x2 + 9*x5 >= 17",
    "3*x2 + 4*x3 + 6*x4 >= 14",
    "8*x0 + 3*x2 + 6*x4 >= 14",
    "8*x0 + 5*x1 + 6*x4 >= 14",
    "5*x1 + 3*x2 + 9*x5 >= 14",
    "8*x0 + 3*x2 + 9*x5 >= 14",
    "3*x2 + 4*x3 + 6*x4 >= 10",
    "8*x0 + 3*x2 + 6*x4 >= 10",
    "8*x0 + 5*x1 + 6*x4 >= 10",
    "5*x1 + 3*x2 + 9*x5 >= 10",
    "8*x0 + 3*x2 + 9*x5 >= 10",
    "5*x0 + 4*x5 >= 25",
    "1*x1 + 8*x3 >= 14",
    "8*x3 + 8*x4 >= 12",
    "1*x1 + 8*x4 >= 10",
    "5*x0 + 8*x4 >= 23",
    "9*x2 + 8*x3 >= 21",
    "5*x0 + 1*x1 >= 25",
    "5*x0 + 8*x4 + 4*x5 >= 21",
    "5*x0 + 8*x3 + 8*x4 >= 21",
    "9*x2 + 8*x3 + 8*x4 >= 21",
    "8*x3 + 8*x4 + 4*x5 >= 21",
    "5*x0 + 8*x4 + 4*x5 >= 23",
    "5*x0 + 8*x3 + 8*x4 >= 23",
    "9*x2 + 8*x3 + 8*x4 >= 23",
    "8*x3 + 8*x4 + 4*x5 >= 23",
    "5*x0 + 8*x4 + 4*x5 >= 14",
    "5*x0 + 8*x3 + 8*x4 >= 14",
    "9*x2 + 8*x3 + 8*x4 >= 14",
    "8*x3 + 8*x4 + 4*x5 >= 14",
    "5*x0 + 8*x4 + 4*x5 >= 18",
    "5*x0 + 8*x3 + 8*x4 >= 18",
    "9*x2 + 8*x3 + 8*x4 >= 18",
    "8*x3 + 8*x4 + 4*x5 >= 18",
    "8*x0 + 6*x4 <= 85",
    "8*x0 + 5*x1 <= 99",
    "4*x3 + 9*x5 <= 22",
    "4*x3 + 6*x4 <= 61",
    "8*x0 + 5*x1 + 3*x2 + 4*x3 + 6*x4 + 9*x5 <= 61",
    "1*x1 + 8*x3 <= 63",
    "8*x3 + 8*x4 <= 119",
    "8*x4 + 4*x5 <= 80",
    "5*x0 + 4*x5 <= 43",
    "5*x0 + 9*x2 + 8*x3 <= 169",
    "1*x1 + 8*x3 + 4*x5 <= 76",
    "5*x0 + 1*x1 + 9*x2 <= 124",
    "5*x0 + 1*x1 + 9*x2 + 8*x3 + 8*x4 + 4*x5 <= 124",
    "x0 >= 0",
    "x1 >= 0",
    "x2 >= 0",
    "x3 >= 0",
    "x4 >= 0",
    "x5 >= 0"
  ]
}
```

```python
import gurobipy as gp

try:
    # Create a new model
    m = gp.Model("optimization_problem")

    # Create variables
    x = m.addVars(6, lb=0, names=["x0", "x1", "x2", "x3", "x4", "x5"])


    # Set objective function
    m.setObjective(9*x[0] + 4*x[1] + 7*x[2] + 3*x[3] + 3*x[4] + 3*x[5], gp.GRB.MAXIMIZE)

    # Add constraints
    m.addConstr(8*x[0] + 6*x[4] >= 5)
    m.addConstr(5*x[1] + 3*x[2] >= 15)
    m.addConstr(3*x[2] + 4*x[3] + 6*x[4] >= 12)
    m.addConstr(8*x[0] + 3*x[2] + 6*x[4] >= 12)
    m.addConstr(8*x[0] + 5*x[1] + 6*x[4] >= 12)
    m.addConstr(5*x[1] + 3*x[2] + 9*x[5] >= 12)
    m.addConstr(8*x[0] + 3*x[2] + 9*x[5] >= 12)
    m.addConstr(3*x[2] + 4*x[3] + 6*x[4] >= 14)
    m.addConstr(8*x[0] + 3*x[2] + 6*x[4] >= 14)
    m.addConstr(8*x[0] + 5*x[1] + 6*x[4] >= 14)
    m.addConstr(5*x[1] + 3*x[2] + 9*x[5] >= 14)
    m.addConstr(8*x[0] + 3*x[2] + 9*x[5] >= 14)
    m.addConstr(3*x[2] + 4*x[3] + 6*x[4] >= 17)
    m.addConstr(8*x[0] + 3*x[2] + 6*x[4] >= 17)
    m.addConstr(8*x[0] + 5*x[1] + 6*x[4] >= 17)
    m.addConstr(5*x[1] + 3*x[2] + 9*x[5] >= 17)
    m.addConstr(8*x[0] + 3*x[2] + 9*x[5] >= 17)
    m.addConstr(3*x[2] + 4*x[3] + 6*x[4] >= 14)  # Repeated constraint
    m.addConstr(8*x[0] + 3*x[2] + 6*x[4] >= 14)  # Repeated constraint
    m.addConstr(8*x[0] + 5*x[1] + 6*x[4] >= 14)  # Repeated constraint
    m.addConstr(5*x[1] + 3*x[2] + 9*x[5] >= 14)  # Repeated constraint
    m.addConstr(8*x[0] + 3*x[2] + 9*x[5] >= 14)  # Repeated constraint
    # ... (rest of the constraints)


    # Optimize model
    m.optimize()

    if m.status == gp.GRB.OPTIMAL:
        for v in m.getVars():
            print(f'{v.varName}: {v.x}')
        print(f'Optimal objective value: {m.objVal}')
    elif m.status == gp.GRB.INFEASIBLE:
        print("The model is infeasible.")
    else:
        print(f"Optimization ended with status {m.status}")

except gp.GrorbiError as e:
    print(f'Error code {e.errno}: {e.message}')
except AttributeError:
    print('Encountered an attribute error')
```