```json
{
  "sym_variables": [
    ("x0", "hours worked by George"),
    ("x1", "hours worked by Paul"),
    ("x2", "hours worked by Laura"),
    ("x3", "hours worked by Ringo"),
    ("x4", "hours worked by Hank")
  ],
  "objective_function": "8.72 * x0 + 6.37 * x1 + 8.49 * x2 + 2.59 * x3 + 1.75 * x4",
  "constraints": [
    "5 * x0 + 8 * x1 >= 34",
    "5 * x0 + 1 * x4 >= 50",
    "5 * x0 + 6 * x3 >= 64",
    "6 * x3 + 1 * x4 >= 72",
    "8 * x1 + 6 * x3 >= 59",
    "5 * x0 + 8 * x1 + 1 * x4 >= 52",
    "5 * x0 + 8 * x1 + 11 * x2 + 6 * x3 + 1 * x4 >= 52",
    "4 * x2 + 14 * x4 >= 81",
    "10 * x0 + 4 * x2 >= 82",
    "10 * x0 + 6 * x1 >= 78",
    "7 * x3 + 14 * x4 >= 84",
    "6 * x1 + 4 * x2 >= 75",
    "10 * x0 + 6 * x1 + 4 * x2 + 7 * x3 + 14 * x4 >= 75",
    "17 * x2 + 6 * x3 >= 21",
    "3 * x0 + 2 * x1 >= 20",
    "3 * x0 + 12 * x4 >= 11",
    "17 * x2 + 6 * x3 + 12 * x4 >= 28",
    "3 * x0 + 2 * x1 + 17 * x2 + 6 * x3 + 12 * x4 >= 28",
    "-10 * x0 + 6 * x2 >= 0",
    "-5 * x1 + 3 * x4 >= 0",
    "8 * x1 + 11 * x2 <= 117",
    "5 * x0 + 6 * x3 <= 272",
    "8 * x1 + 6 * x3 <= 232",
    "11 * x2 + 6 * x3 <= 371",
    "8 * x1 + 1 * x4 <= 369",
    "5 * x0 + 11 * x2 + 1 * x4 <= 196",
    "5 * x0 + 11 * x2 + 6 * x3 <= 334",
    "6 * x1 + 4 * x2 <= 284",
    "4 * x2 + 7 * x3 <= 218",
    "10 * x0 + 14 * x4 <= 102",
    "10 * x0 + 6 * x1 <= 135",
    "10 * x0 + 4 * x2 <= 264",
    "10 * x0 + 7 * x3 <= 280",
    "10 * x0 + 6 * x1 + 4 * x2 <= 278",
    "10 * x0 + 4 * x2 + 14 * x4 <= 318",
    "6 * x1 + 4 * x2 + 14 * x4 <= 364",
    "2 * x1 + 17 * x2 <= 50",
    "3 * x0 + 6 * x3 <= 98",
    "2 * x1 + 12 * x4 <= 83",
    "6 * x3 + 12 * x4 <= 51",
    "2 * x1 + 6 * x3 <= 102",
    "2 * x1 + 17 * x2 + 12 * x4 <= 67"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
george = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="George")
paul = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="Paul")
laura = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="Laura")
ringo = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="Ringo")
hank = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="Hank")


# Set objective function
m.setObjective(8.72 * george + 6.37 * paul + 8.49 * laura + 2.59 * ringo + 1.75 * hank, gp.GRB.MINIMIZE)

# Add constraints
m.addConstr(5 * george + 8 * paul >= 34)
m.addConstr(5 * george + 1 * hank >= 50)
m.addConstr(5 * george + 6 * ringo >= 64)
m.addConstr(6 * ringo + 1 * hank >= 72)
m.addConstr(8 * paul + 6 * ringo >= 59)
m.addConstr(5 * george + 8 * paul + 1 * hank >= 52)
m.addConstr(5 * george + 8 * paul + 11 * laura + 6 * ringo + 1 * hank >= 52)
m.addConstr(4 * laura + 14 * hank >= 81)
m.addConstr(10 * george + 4 * laura >= 82)
m.addConstr(10 * george + 6 * paul >= 78)
m.addConstr(7 * ringo + 14 * hank >= 84)
m.addConstr(6 * paul + 4 * laura >= 75)
m.addConstr(10 * george + 6 * paul + 4 * laura + 7 * ringo + 14 * hank >= 75)
m.addConstr(17 * laura + 6 * ringo >= 21)
m.addConstr(3 * george + 2 * paul >= 20)
m.addConstr(3 * george + 12 * hank >= 11)
m.addConstr(17 * laura + 6 * ringo + 12 * hank >= 28)
m.addConstr(3 * george + 2 * paul + 17 * laura + 6 * ringo + 12 * hank >= 28)
m.addConstr(-10 * george + 6 * laura >= 0)
m.addConstr(-5 * paul + 3 * hank >= 0)
m.addConstr(8 * paul + 11 * laura <= 117)
m.addConstr(5 * george + 6 * ringo <= 272)
m.addConstr(8 * paul + 6 * ringo <= 232)
m.addConstr(11 * laura + 6 * ringo <= 371)
m.addConstr(8 * paul + 1 * hank <= 369)
m.addConstr(5 * george + 11 * laura + 1 * hank <= 196)
m.addConstr(5 * george + 11 * laura + 6 * ringo <= 334)
m.addConstr(6 * paul + 4 * laura <= 284)
m.addConstr(4 * laura + 7 * ringo <= 218)
m.addConstr(10 * george + 14 * hank <= 102)
m.addConstr(10 * george + 6 * paul <= 135)
m.addConstr(10 * george + 4 * laura <= 264)
m.addConstr(10 * george + 7 * ringo <= 280)
m.addConstr(10 * george + 6 * paul + 4 * laura <= 278)
m.addConstr(10 * george + 4 * laura + 14 * hank <= 318)
m.addConstr(6 * paul + 4 * laura + 14 * hank <= 364)
m.addConstr(2 * paul + 17 * laura <= 50)
m.addConstr(3 * george + 6 * ringo <= 98)
m.addConstr(2 * paul + 12 * hank <= 83)
m.addConstr(6 * ringo + 12 * hank <= 51)
m.addConstr(2 * paul + 6 * ringo <= 102)
m.addConstr(2 * paul + 17 * laura + 12 * hank <= 67)


# 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("The problem is infeasible.")
else:
    print("The problem could not be solved to optimality.")

```
