```json
{
  "sym_variables": [
    ("x0", "hours worked by Ringo"),
    ("x1", "hours worked by John"),
    ("x2", "hours worked by Paul"),
    ("x3", "hours worked by Jean"),
    ("x4", "hours worked by Dale"),
    ("x5", "hours worked by Hank")
  ],
  "objective_function": "10.0 * x0 + 4.86 * x1 + 9.97 * x2 + 4.07 * x3 + 2.91 * x4 + 9.21 * x5",
  "constraints": [
    "11 * x0 + 17 * x2 >= 14",
    "9 * x3 + 9 * x4 >= 22",
    "11 * x0 + 8 * x1 >= 20",
    "8 * x1 + 8 * x5 >= 20",
    "17 * x2 + 8 * x5 >= 30",
    "17 * x2 + 9 * x4 >= 15",
    "9 * x3 + 8 * x5 >= 16",
    "8 * x1 + 9 * x3 >= 11",
    "8 * x1 + 17 * x2 >= 24",
    "9 * x4 + 8 * x5 >= 16",
    "17 * x2 + 9 * x3 >= 26",
    "1 * x1 + 15 * x3 >= 52",
    "20 * x2 + 15 * x3 >= 43",
    "15 * x3 + 11 * x5 >= 68",
    "15 * x3 + 1 * x4 >= 26",
    "8 * x0 + 11 * x5 >= 58",
    "1 * x4 + 11 * x5 >= 51",
    "1 * x1 + 20 * x2 >= 52",
    "20 * x2 + 1 * x4 >= 62",
    "20 * x2 + 1 * x4 + 11 * x5 >= 53",
    "1 * x1 + 20 * x2 + 1 * x4 >= 53",
    "1 * x1 + 20 * x2 + 11 * x5 >= 53",
    "8 * x0 + 1 * x1 + 15 * x3 >= 53",
    "8 * x0 + 20 * x2 + 15 * x3 >= 53",
    "8 * x0 + 1 * x1 + 11 * x5 >= 53",
    "20 * x2 + 15 * x3 + 1 * x4 >= 53",
    "20 * x2 + 1 * x4 + 11 * x5 >= 39",
    "1 * x1 + 20 * x2 + 1 * x4 >= 39",
    "1 * x1 + 20 * x2 + 11 * x5 >= 39",
    "8 * x0 + 1 * x1 + 15 * x3 >= 39",
    "8 * x0 + 20 * x2 + 15 * x3 >= 39",
    "8 * x0 + 1 * x1 + 11 * x5 >= 39",
    "20 * x2 + 15 * x3 + 1 * x4 >= 39",
    "18 * x2 + 4 * x4 >= 31",
    "10 * x3 + 4 * x4 >= 22",
    "17 * x0 + 18 * x2 + 10 * x3 >= 60",
    "18 * x2 + 4 * x4 + 14 * x5 >= 60",
    "17 * x0 + 13 * x1 + 18 * x2 >= 60",
    "17 * x0 + 13 * x1 + 4 * x4 >= 60",
    "9 * x3 + 1 * x5 >= 27",
    "7 * x1 + 1 * x5 >= 35",
    "7 * x1 + 7 * x4 >= 37",
    "5 * x2 + 9 * x3 >= 32",
    "8 * x1 + 9 * x3 <= 83",
    "9 * x3 + 8 * x5 <= 97",
    "11 * x0 + 9 * x4 <= 99",
    "11 * x0 + 9 * x3 <= 150",
    "9 * x3 + 9 * x4 <= 178",
    "9 * x4 + 8 * x5 <= 75",
    "11 * x0 + 8 * x5 <= 53",
    "8 * x1 + 8 * x5 <= 57",
    "1 * x1 + 20 * x2 <= 364",
    "8 * x0 + 11 * x5 <= 204",
    "15 * x3 + 1 * x4 <= 284",
    "1 * x1 + 15 * x3 <= 348",
    "8 * x0 + 20 * x2 <= 382",
    "1 * x1 + 1 * x4 <= 292",
    "8 * x0 + 15 * x3 <= 85",
    "1 * x4 + 11 * x5 <= 352",
    "18 * x2 + 4 * x4 <= 172",
    "13 * x1 + 4 * x4 <= 287",
    "10 * x3 + 4 * x4 <= 128",
    "13 * x1 + 14 * x5 <= 88",
    "17 * x0 + 4 * x4 <= 161"
  ]
}
```

```python
from gurobipy import *

# Create a new model
model = Model("Resource_Allocation")

# Create variables
ringo = model.addVar(vtype=GRB.CONTINUOUS, name="ringo")
john = model.addVar(vtype=GRB.CONTINUOUS, name="john")
paul = model.addVar(vtype=GRB.CONTINUOUS, name="paul")
jean = model.addVar(vtype=GRB.CONTINUOUS, name="jean")
dale = model.addVar(vtype=GRB.CONTINUOUS, name="dale")
hank = model.addVar(vtype=GRB.CONTINUOUS, name="hank")


# Set objective
model.setObjective(10.0 * ringo + 4.86 * john + 9.97 * paul + 4.07 * jean + 2.91 * dale + 9.21 * hank, GRB.MAXIMIZE)

# Add constraints
model.addConstr(11 * ringo + 17 * paul >= 14)
model.addConstr(9 * jean + 9 * dale >= 22)
model.addConstr(11 * ringo + 8 * john >= 20)
model.addConstr(8 * john + 8 * hank >= 20)
model.addConstr(17 * paul + 8 * hank >= 30)
model.addConstr(17 * paul + 9 * dale >= 15)
model.addConstr(9 * jean + 8 * hank >= 16)
model.addConstr(8 * john + 9 * jean >= 11)
model.addConstr(8 * john + 17 * paul >= 24)
model.addConstr(9 * dale + 8 * hank >= 16)
model.addConstr(17 * paul + 9 * jean >= 26)
model.addConstr(1 * john + 15 * jean >= 52)
model.addConstr(20 * paul + 15 * jean >= 43)
model.addConstr(15 * jean + 11 * hank >= 68)
model.addConstr(15 * jean + 1 * dale >= 26)
model.addConstr(8 * ringo + 11 * hank >= 58)
model.addConstr(1 * dale + 11 * hank >= 51)
model.addConstr(1 * john + 20 * paul >= 52)
model.addConstr(20 * paul + 1 * dale >= 62)
model.addConstr(20 * paul + 1 * dale + 11 * hank >= 53)
model.addConstr(1 * john + 20 * paul + 1 * dale >= 53)
model.addConstr(1 * john + 20 * paul + 11 * hank >= 53)
model.addConstr(8 * ringo + 1 * john + 15 * jean >= 53)
model.addConstr(8 * ringo + 20 * paul + 15 * jean >= 53)
model.addConstr(8 * ringo + 1 * john + 11 * hank >= 53)
model.addConstr(20 * paul + 15 * jean + 1 * dale >= 53)
# ... (rest of the constraints)


# Optimize model
model.optimize()

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

```