```json
{
  "sym_variables": [
    ("x0", "hours worked by Bobby"),
    ("x1", "hours worked by Laura"),
    ("x2", "hours worked by George"),
    ("x3", "hours worked by Peggy"),
    ("x4", "hours worked by Hank")
  ],
  "objective_function": "8.2 * x0 + 6.37 * x1 + 1.82 * x2 + 2.51 * x3 + 7.39 * x4",
  "constraints": [
    "10 * x1 + 18 * x2 >= 33",
    "1 * x3 + 12 * x4 >= 49",
    "10 * x1 + 1 * x3 + 12 * x4 >= 45",
    "22 * x0 + 10 * x1 + 18 * x2 >= 45",
    "10 * x1 + 1 * x3 + 12 * x4 >= 45",
    "22 * x0 + 10 * x1 + 18 * x2 >= 45",
    "4 * x1 + 23 * x2 + 20 * x4 >= 57",
    "11 * x0 + 4 * x1 + 20 * x4 >= 57",
    "11 * x0 + 23 * x2 + 20 * x4 >= 57",
    "4 * x1 + 23 * x2 + 12 * x3 >= 57",
    "11 * x0 + 4 * x1 + 23 * x2 >= 57",
    "4 * x1 + 12 * x3 + 20 * x4 >= 57",
    "11 * x0 + 12 * x3 + 20 * x4 >= 57",
    "4 * x1 + 23 * x2 + 20 * x4 >= 58",
    "11 * x0 + 4 * x1 + 20 * x4 >= 58",
    "11 * x0 + 23 * x2 + 20 * x4 >= 58",
    "4 * x1 + 23 * x2 + 12 * x3 >= 58",
    "11 * x0 + 4 * x1 + 23 * x2 >= 58",
    "4 * x1 + 12 * x3 + 20 * x4 >= 58",
    "11 * x0 + 12 * x3 + 20 * x4 >= 58",
    "4 * x1 + 23 * x2 + 20 * x4 >= 72",
    "11 * x0 + 4 * x1 + 20 * x4 >= 72",
    "11 * x0 + 23 * x2 + 20 * x4 >= 72",
    "4 * x1 + 23 * x2 + 12 * x3 >= 72",
    "11 * x0 + 4 * x1 + 23 * x2 >= 72",
    "4 * x1 + 12 * x3 + 20 * x4 >= 72",
    "11 * x0 + 12 * x3 + 20 * x4 >= 72",
    "4 * x1 + 23 * x2 + 20 * x4 >= 60",
    "11 * x0 + 4 * x1 + 20 * x4 >= 60",
    "11 * x0 + 23 * x2 + 20 * x4 >= 60",
    "4 * x1 + 23 * x2 + 12 * x3 >= 60",
    "11 * x0 + 4 * x1 + 23 * x2 >= 60",
    "4 * x1 + 12 * x3 + 20 * x4 >= 60",
    "11 * x0 + 12 * x3 + 20 * x4 >= 60",
    "4 * x1 + 23 * x2 + 20 * x4 >= 56",
    "11 * x0 + 4 * x1 + 20 * x4 >= 56",
    "11 * x0 + 23 * x2 + 20 * x4 >= 56",
    "4 * x1 + 23 * x2 + 12 * x3 >= 56",
    "11 * x0 + 4 * x1 + 23 * x2 >= 56",
    "4 * x1 + 12 * x3 + 20 * x4 >= 56",
    "11 * x0 + 12 * x3 + 20 * x4 >= 56",
    "4 * x1 + 23 * x2 + 20 * x4 >= 82",
    "11 * x0 + 4 * x1 + 20 * x4 >= 82",
    "11 * x0 + 23 * x2 + 20 * x4 >= 82",
    "4 * x1 + 23 * x2 + 12 * x3 >= 82",
    "11 * x0 + 4 * x1 + 23 * x2 >= 82",
    "4 * x1 + 12 * x3 + 20 * x4 >= 82",
    "11 * x0 + 12 * x3 + 20 * x4 >= 82",
    "4 * x1 + 23 * x2 + 20 * x4 >= 54",
    "11 * x0 + 4 * x1 + 20 * x4 >= 54",
    "11 * x0 + 23 * x2 + 20 * x4 >= 54",
    "4 * x1 + 23 * x2 + 12 * x3 >= 54",
    "11 * x0 + 4 * x1 + 23 * x2 >= 54",
    "4 * x1 + 12 * x3 + 20 * x4 >= 54",
    "11 * x0 + 12 * x3 + 20 * x4 >= 54",
    "17 * x0 + 7 * x3 >= 90",
    "17 * x0 + 20 * x1 + 23 * x4 >= 62",
    "17 * x0 + 7 * x3 + 23 * x4 >= 62",
    "5 * x2 + 7 * x3 + 23 * x4 >= 62",
    "20 * x1 + 7 * x3 + 23 * x4 >= 62",
    "20 * x1 + 5 * x2 + 23 * x4 >= 62",
    "20 * x1 + 5 * x2 + 7 * x3 >= 62",
    "17 * x0 + 20 * x1 + 7 * x3 >= 62",
    "17 * x0 + 20 * x1 + 23 * x4 >= 84",
    "17 * x0 + 7 * x3 + 23 * x4 >= 84",
    "5 * x2 + 7 * x3 + 23 * x4 >= 84",
    "20 * x1 + 7 * x3 + 23 * x4 >= 84",
    "20 * x1 + 5 * x2 + 23 * x4 >= 84",
    "20 * x1 + 5 * x2 + 7 * x3 >= 84",
    "17 * x0 + 20 * x1 + 7 * x3 >= 84",
    "17 * x0 + 20 * x1 + 23 * x4 >= 69",
    "17 * x0 + 7 * x3 + 23 * x4 >= 69",
    "5 * x2 + 7 * x3 + 23 * x4 >= 69",
    "20 * x1 + 7 * x3 + 23 * x4 >= 69",
    "20 * x1 + 5 * x2 + 23 * x4 >= 69",
    "20 * x1 + 5 * x2 + 7 * x3 >= 69",
    "17 * x0 + 20 * x1 + 7 * x3 >= 69",
    "17 * x0 + 20 * x1 + 23 * x4 >= 112",
    "17 * x0 + 7 * x3 + 23 * x4 >= 112",
    "5 * x2 + 7 * x3 + 23 * x4 >= 112",
    "20 * x1 + 7 * x3 + 23 * x4 >= 112",
    "20 * x1 + 5 * x2 + 23 * x4 >= 112",
    "20 * x1 + 5 * x2 + 7 * x3 >= 112",
    "17 * x0 + 20 * x1 + 7 * x3 >= 112",
    "17 * x0 + 20 * x1 + 23 * x4 >= 72",
    "17 * x0 + 7 * x3 + 23 * x4 >= 72",
    "5 * x2 + 7 * x3 + 23 * x4 >= 72",
    "20 * x1 + 7 * x3 + 23 * x4 >= 72",
    "20 * x1 + 5 * x2 + 23 * x4 >= 72",
    "20 * x1 + 5 * x2 + 7 * x3 >= 72",
    "17 * x0 + 20 * x1 + 7 * x3 >= 72",
    "17 * x0 + 20 * x1 + 23 * x4 >= 104",
    "17 * x0 + 7 * x3 + 23 * x4 >= 104",
    "5 * x2 + 7 * x3 + 23 * x4 >= 104",
    "20 * x1 + 7 * x3 + 23 * x4 >= 104",
    "20 * x1 + 5 * x2 + 23 * x4 >= 104",
    "20 * x1 + 5 * x2 + 7 * x3 >= 104",
    "17 * x0 + 20 * x1 + 7 * x3 >= 104",
    "17 * x0 + 20 * x1 + 23 * x4 >= 72",
    "17 * x0 + 7 * x3 + 23 * x4 >= 72",
    "5 * x2 + 7 * x3 + 23 * x4 >= 72",
    "20 * x1 + 7 * x3 + 23 * x4 >= 72",
    "20 * x1 + 5 * x2 + 23 * x4 >= 72",
    "20 * x1 + 5 * x2 + 7 * x3 >= 72",
    "17 * x0 + 20 * x1 + 7 * x3 >= 72",
    "10 * x1 + 12 * x4 <= 131",
    "1 * x3 + 12 * x4 <= 89",
    "22 * x0 + 18 * x2 <= 193",
    "22 * x0 + 10 * x1 + 18 * x2 + 1 * x3 + 12 * x4 <= 193",
    "23 * x2 + 12 * x3 <= 310",
    "12 * x3 + 20 * x4 <= 265",
    "23 * x2 + 20 * x4 <= 296",
    "11 * x0 + 4 * x1 <= 111",
    "11 * x0 + 23 * x2 <= 124",
    "4 * x1 + 12 * x3 <= 221",
    "11 * x0 + 4 * x1 + 23 * x2 + 12 * x3 + 20 * x4 <= 221",
    "5 * x2 + 7 * x3 <= 204",
    "7 * x3 + 23 * x4 <= 490",
    "17 * x0 + 20 * x1 <= 256",
    "17 * x0 + 20 * x1 + 5 * x2 + 7 * x3 + 23 * x4 <= 256"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
bobby = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="bobby")
laura = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="laura")
george = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="george")
peggy = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="peggy")
hank = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="hank")

# Set objective function
m.setObjective(8.2 * bobby + 6.37 * laura + 1.82 * george + 2.51 * peggy + 7.39 * hank, gp.GRB.MAXIMIZE)

# Add constraints

# likelihood to quit index constraints
m.addConstr(10 * laura + 18 * george >= 33)
m.addConstr(1 * peggy + 12 * hank >= 49)
m.addConstr(10 * laura + 1 * peggy + 12 * hank >= 45)
m.addConstr(22 * bobby + 10 * laura + 18 * george >= 45)
m.addConstr(10 * laura + 12 * hank <= 131)
m.addConstr(peggy + 12 * hank <= 89)
m.addConstr(22 * bobby + 18 * george <= 193)
m.addConstr(22 * bobby + 10 * laura + 18 * george + peggy + 12 * hank <= 193)


# work quality rating constraints
m.addConstr(4 * laura + 23 * george + 20 * hank >= 72) # Dominant constraint
m.addConstr(11 * bobby + 4 * laura + 20 * hank >= 72) # Dominant constraint
m.addConstr(11 * bobby + 23 * george + 20 * hank >= 72) # Dominant constraint
m.addConstr(4 * laura + 23 * george + 12 * peggy >= 72) # Dominant constraint
m.addConstr(11 * bobby + 4 * laura + 23 * george >= 72) # Dominant constraint
m.addConstr(4 * laura + 12 * peggy + 20 * hank >= 72) # Dominant constraint
m.addConstr(11 * bobby + 12 * peggy + 20 * hank >= 72) # Dominant constraint

m.addConstr(23 * george + 12 * peggy <= 310)
m.addConstr(12 * peggy + 20 * hank <= 265)
m.addConstr(23 * george + 20 * hank <= 296)
m.addConstr(11 * bobby + 4 * laura <= 111)
m.addConstr(11 * bobby + 23 * george <= 124)
m.addConstr(4 * laura + 12 * peggy <= 221)
m.addConstr(11 * bobby + 4 * laura + 23 * george + 12 * peggy + 20 * hank <= 221)


# computer competence rating constraints
m.addConstr(17 * bobby + 7 * peggy >= 90)
m.addConstr(17 * bobby + 20 * laura + 23 * hank >= 112) # Dominant constraint
m.addConstr(17 * bobby + 7 * peggy + 23 * hank >= 112) # Dominant constraint
m.addConstr(5 * george + 7 * peggy + 23 * hank >= 112) # Dominant constraint
m.addConstr(20 * laura + 7 * peggy + 23 * hank >= 112) # Dominant constraint
m.addConstr(20 * laura + 5 * george + 23 * hank >= 112) # Dominant constraint
m.addConstr(20 * laura + 5 * george + 7 * peggy >= 112) # Dominant constraint
m.addConstr(17 * bobby + 20 * laura + 7 * peggy >= 112) # Dominant constraint

m.addConstr(5 * george + 7 * peggy <= 204)
m.addConstr(7 * peggy + 23 * hank <= 490)
m.addConstr(17 * bobby + 20 * laura <= 256)
m.addConstr(17 * bobby + 20 * laura + 5 * george + 7 * peggy + 23 * hank <= 256)


# Optimize model
m.optimize()

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

```
