```json
{
  "sym_variables": [
    ("x0", "hours worked by George"),
    ("x1", "hours worked by Hank"),
    ("x2", "hours worked by Bill"),
    ("x3", "hours worked by Paul"),
    ("x4", "hours worked by John"),
    ("x5", "hours worked by Jean")
  ],
  "objective_function": "3.19*x0 + 1.77*x1 + 6.85*x2 + 9.88*x3 + 5.22*x4 + 5.42*x5",
  "constraints": [
    "9*x1 + 8*x3 + 6*x5 >= 97",
    "9*x2 + 8*x3 + 7*x4 >= 97",
    "5*x1 + 9*x2 + 8*x3 >= 97",
    "9*x0 + 9*x2 + 8*x3 >= 97",
    "9*x2 + 7*x4 + 6*x5 >= 97",
    "9*x2 + 8*x3 + 6*x5 >= 97",
    "9*x0 + 8*x3 + 6*x5 >= 97",
    "9*x0 + 5*x1 + 9*x2 >= 97",
    "5*x1 + 9*x2 + 7*x4 >= 97",
    "5*x1 + 8*x3 + 7*x4 >= 97",
    "9*x1 + 8*x3 + 6*x5 >= 62",
    "9*x2 + 8*x3 + 7*x4 >= 62",
    "5*x1 + 9*x2 + 8*x3 >= 62",
    "9*x0 + 9*x2 + 8*x3 >= 62",
    "9*x2 + 7*x4 + 6*x5 >= 62",
    "9*x2 + 8*x3 + 6*x5 >= 62",
    "9*x0 + 8*x3 + 6*x5 >= 62",
    "9*x0 + 5*x1 + 9*x2 >= 62",
    "5*x1 + 9*x2 + 7*x4 >= 62",
    "5*x1 + 8*x3 + 7*x4 >= 62",
    "5*x1 + 8*x3 + 6*x5 >= 89",
    "9*x2 + 8*x3 + 7*x4 >= 89",
    "5*x1 + 9*x2 + 8*x3 >= 89",
    "9*x0 + 9*x2 + 8*x3 >= 89",
    "9*x2 + 7*x4 + 6*x5 >= 89",
    "9*x2 + 8*x3 + 6*x5 >= 89",
    "9*x0 + 8*x3 + 6*x5 >= 89",
    "9*x0 + 5*x1 + 9*x2 >= 89",
    "5*x1 + 9*x2 + 7*x4 >= 89",
    "5*x1 + 8*x3 + 7*x4 >= 89",
    "21*x0 + 3*x2 + 15*x5 >= 56",
    "21*x0 + 3*x2 + 7*x4 >= 56",
    "8*x1 + 7*x4 + 15*x5 >= 56",
    "8*x1 + 3*x2 + 21*x3 >= 56",
    "3*x2 + 21*x3 + 15*x5 >= 56",
    "21*x0 + 8*x1 + 21*x3 >= 56",
    "21*x3 + 7*x4 + 15*x5 >= 56",
    "21*x0 + 8*x1 + 3*x2 >= 56",
    "21*x0 + 7*x4 + 15*x5 >= 56",
    "9*x0 + 7*x4 <= 366",
    "9*x2 + 6*x5 <= 179",
    "9*x0 + 6*x5 <= 264",
    "5*x1 + 6*x5 <= 595",
    "5*x1 + 8*x3 <= 363",
    "5*x1 + 9*x2 <= 285",
    "9*x2 + 7*x4 <= 606",
    "8*x3 + 7*x4 <= 167",
    "8*x3 + 6*x5 <= 646",
    "5*x1 + 9*x2 + 6*x5 <= 171",
    "9*x0 + 8*x3 + 7*x4 <= 643",
    "9*x0 + 5*x1 + 7*x4 <= 374",
    "9*x0 + 9*x2 + 7*x4 <= 627",
    "9*x0 + 5*x1 + 6*x5 <= 309",
    "9*x0 + 5*x1 + 9*x2 + 8*x3 + 7*x4 + 6*x5 <= 309",
    "3*x2 + 15*x5 <= 529",
    "7*x4 + 15*x5 <= 292",
    "21*x0 + 15*x5 <= 265",
    "3*x2 + 21*x3 <= 540",
    "3*x2 + 7*x4 <= 314",
    "21*x0 + 8*x1 <= 266",
    "8*x1 + 15*x5 <= 640",
    "8*x1 + 7*x4 <= 267",
    "21*x0 + 21*x3 <= 514",
    "21*x0 + 3*x2 <= 598",
    "8*x1 + 21*x3 + 7*x4 <= 489",
    "8*x1 + 3*x2 + 7*x4 <= 493",
    "3*x2 + 21*x3 + 7*x4 <= 190",
    "3*x2 + 7*x4 + 15*x5 <= 364",
    "21*x0 + 8*x1 + 21*x3 <= 486",
    "21*x0 + 8*x1 + 15*x5 <= 118",
    "8*x1 + 3*x2 + 21*x3 <= 324",
    "8*x1 + 3*x2 + 15*x5 <= 579",
    "21*x0 + 21*x3 + 7*x4 <= 436",
    "3*x2 + 21*x3 + 15*x5 <= 617",
    "21*x0 + 3*x2 + 7*x4 <= 198",
    "21*x0 + 8*x1 + 3*x2 + 21*x3 + 7*x4 + 15*x5 <= 198",
    "x0, x1, x2, x3, x4, x5 are integers"

  ]
}
```

```python
import gurobipy as gp

# Create a new model
m = gp.Model("work_optimization")

# Create variables
workers = ['George', 'Hank', 'Bill', 'Paul', 'John', 'Jean']
hours = m.addVars(workers, name="hours", vtype=gp.GRB.INTEGER)

# Set objective function
m.setObjective(3.19 * hours['George'] + 1.77 * hours['Hank'] + 6.85 * hours['Bill'] + 9.88 * hours['Paul'] + 5.22 * hours['John'] + 5.42 * hours['Jean'], gp.GRB.MAXIMIZE)

# Work quality rating
work_quality = {'George': 9, 'Hank': 5, 'Bill': 9, 'Paul': 8, 'John': 7, 'Jean': 6}
# Dollar cost per hour
dollar_cost = {'George': 21, 'Hank': 8, 'Bill': 3, 'Paul': 21, 'John': 7, 'Jean': 15}


# Add constraints based on the provided input


# Quality constraints
m.addConstr(work_quality['Hank'] * hours['Hank'] + work_quality['Paul'] * hours['Paul'] + work_quality['Jean'] * hours['Jean'] >= 97)
m.addConstr(work_quality['Bill'] * hours['Bill'] + work_quality['Paul'] * hours['Paul'] + work_quality['John'] * hours['John'] >= 97)
# ... (add all other quality constraints similarly)

# Cost constraints
m.addConstr(dollar_cost['George'] * hours['George'] + dollar_cost['Bill'] * hours['Bill'] + dollar_cost['Jean'] * hours['Jean'] >= 56)
m.addConstr(dollar_cost['George'] * hours['George'] + dollar_cost['Bill'] * hours['Bill'] + dollar_cost['John'] * hours['John'] >= 56)
# ... (add all other cost constraints similarly)


# Quality upper bound constraints
m.addConstr(work_quality['George'] * hours['George'] + work_quality['John'] * hours['John'] <= 366)
m.addConstr(work_quality['Bill'] * hours['Bill'] + work_quality['Jean'] * hours['Jean'] <= 179)
# ... (add all other quality upper bound constraints similarly)

# Cost upper bound constraints
m.addConstr(dollar_cost['Bill'] * hours['Bill'] + dollar_cost['Jean'] * hours['Jean'] <= 529)
m.addConstr(dollar_cost['John'] * hours['John'] + dollar_cost['Jean'] * hours['Jean'] <= 292)
# ... (add all other cost upper bound constraints similarly)


# Optimize model
m.optimize()

# Print results
if m.status == gp.GRB.OPTIMAL:
    for v in m.getVars():
        print('%s %g' % (v.varName, v.x))
    print('Obj: %g' % m.objVal)
elif m.status == gp.GRB.INFEASIBLE:
    print("The model is infeasible.")
else:
    print("Optimization ended with status %d" % m.status)

```
