```json
{
  "sym_variables": [
    ("x0", "hours worked by Paul"),
    ("x1", "hours worked by Bill"),
    ("x2", "hours worked by Laura"),
    ("x3", "hours worked by Mary"),
    ("x4", "hours worked by Jean"),
    ("x5", "hours worked by George"),
    ("x6", "hours worked by John")
  ],
  "objective_function": "4*x0 + 6*x1 + 1*x2 + 3*x3 + 3*x4 + 2*x5 + 3*x6",
  "constraints": [
    "6*x2 + 3*x4 >= 86",
    "28*x5 + 26*x6 >= 40",
    "2*x3 + 26*x6 >= 44",
    "6*x2 + 2*x3 >= 37",
    "23*x0 + 2*x3 + 28*x5 >= 63",
    "23*x0 + 11*x1 + 6*x2 + 2*x3 + 3*x4 + 28*x5 + 26*x6 >= 63",
    "2*x0 + 22*x2 >= 65",
    "16*x4 + 10*x6 >= 56",
    "22*x2 + 10*x6 >= 84",
    "13*x1 + 4*x5 >= 72",
    "2*x0 + 24*x3 >= 71",
    "13*x1 + 24*x3 >= 43",
    "22*x2 + 4*x5 >= 51",
    "22*x2 + 24*x3 >= 76",
    "24*x3 + 4*x5 >= 65",
    "2*x0 + 16*x4 >= 99",
    "13*x1 + 22*x2 >= 90",
    "2*x0 + 10*x6 >= 37",
    "2*x0 + 13*x1 >= 53",
    "13*x1 + 16*x4 + 4*x5 >= 75",
    "13*x1 + 24*x3 + 16*x4 >= 75",
    "13*x1 + 16*x4 + 4*x5 >= 91",
    "13*x1 + 24*x3 + 16*x4 >= 91",
    "2*x0 + 13*x1 + 22*x2 + 24*x3 + 16*x4 + 4*x5 + 10*x6 >= 91",
    "15*x1 + 6*x5 >= 70",
    "15*x1 + 11*x4 >= 93",
    "28*x2 + 6*x5 >= 76",
    "11*x4 + 20*x6 >= 88",
    "10*x3 + 20*x6 >= 45",
    "23*x0 + 6*x5 >= 62",
    "28*x2 + 11*x4 >= 63",
    "28*x2 + 10*x3 >= 73",
    "15*x1 + 28*x2 + 6*x5 >= 80",
    "23*x0 + 28*x2 + 11*x4 >= 80",
    "23*x0 + 28*x2 + 10*x3 >= 80",
    "23*x0 + 11*x4 + 6*x5 >= 80",
    "15*x1 + 28*x2 + 20*x6 >= 80",
    "10*x3 + 6*x5 + 20*x6 >= 80",
    "23*x0 + 15*x1 + 6*x5 >= 80",
    "10*x3 + 11*x4 + 6*x5 >= 80",
    "15*x1 + 10*x3 + 6*x5 >= 80",
    "15*x1 + 11*x4 + 20*x6 >= 80",
    "28*x2 + 10*x3 + 11*x4 >= 80",
    "23*x0 + 15*x1 + 11*x4 >= 80",
    "23*x0 + 10*x3 + 6*x5 >= 80",
    "23*x0 + 6*x5 + 20*x6 >= 80",
    "15*x1 + 28*x2 + 10*x3 >= 80",
    "28*x2 + 11*x4 + 20*x6 >= 80",
    "23*x0 + 28*x2 + 20*x6 >= 80",
    "23*x0 + 15*x1 + 20*x6 >= 80",
    "11*x4 + 6*x5 + 20*x6 >= 80",
    "15*x1 + 28*x2 + 11*x4 >= 80",
    "23*x0 + 15*x1 + 28*x2 >= 80",
    "23*x0 + 11*x4 + 20*x6 >= 80",
    "15*x1 + 6*x5 + 20*x6 >= 80",
    "28*x2 + 6*x5 + 20*x6 >= 80",
    "23*x0 + 28*x2 + 6*x5 >= 80",
    "23*x0 + 10*x3 + 20*x6 >= 80",

    "26*x1 + 1*x5 >= 51",
    "26*x1 + 29*x3 >= 30",
    "21*x4 + 1*x5 >= 41",
    "29*x3 + 16*x6 >= 31",
    "21*x4 + 16*x6 >= 38",
    "21*x0 + 26*x1 >= 28",
    "29*x3 + 1*x5 >= 19",
    "21*x0 + 29*x3 >= 48",
    "26*x1 + 20*x2 >= 48",
    "21*x0 + 16*x6 >= 27",
    "26*x1 + 16*x6 >= 36",
    "20*x2 + 1*x5 >= 55",
    "1*x5 + 16*x6 >= 43",
    "29*x3 + 21*x4 >= 30",
    "26*x1 + 21*x4 >= 22",
    "20*x2 + 29*x3 >= 18",
    "21*x0 + 26*x1 + 20*x2 + 29*x3 + 21*x4 + 1*x5 + 16*x6 >= 18",
    "8*x1 - 8*x2 >= 0",
    "-8*x2 + 5*x6 >= 0",
    "9*x4 - 10*x5 >= 0",
    "2*x0 + 24*x3 <= 642",
    "24*x3 + 10*x6 <= 348",
    "2*x0 + 22*x2 <= 523",
    "2*x0 + 13*x1 <= 692",
    "13*x1 + 24*x3 <= 175",
    "2*x0 + 16*x4 <= 310",
    "4*x5 + 10*x6 <= 164",
    "16*x4 + 4*x5 <= 449",
    "22*x2 + 24*x3 <= 716",
    "16*x4 + 10*x6 <= 432",
    "13*x1 + 16*x4 <= 333",
    "24*x3 + 16*x4 <= 175",
    "22*x2 + 4*x5 <= 346",
    "13*x1 + 10*x6 <= 298",
    "22*x2 + 16*x4 + 10*x6 <= 179",
    "28*x2 + 10*x3 + 11*x4 <= 531",
    "10*x3 + 11*x4 + 20*x6 <= 450",
    "23*x0 + 15*x1 + 11*x4 <= 533",
    "23*x0 + 10*x3 + 20*x6 <= 639",
    "15*x1 + 10*x3 + 20*x6 <= 120",
    "15*x1 + 28*x2 + 10*x3 <= 186",
    "28*x2 + 10*x3 + 20*x6 <= 426",
    "1*x5 + 16*x6 <= 249",
    "20*x2 + 16*x6 <= 367",
    "29*x3 + 16*x6 <= 167",
    "21*x0 + 26*x1 <= 244",
    "26*x1 + 1*x5 <= 235",
    "20*x2 + 29*x3 <= 321",
    "26*x1 + 16*x6 <= 295",
    "21*x0 + 1*x5 <= 111",
    "26*x1 + 20*x2 <= 320",
    "21*x0 + 29*x3 <= 304",
    "26*x1 + 21*x4 <= 321",
    "29*x3 + 1*x5 <= 73",
    "26*x1 + 1*x5 + 16*x6 <= 162",
    "21*x0 + 1*x5 + 16*x6 <= 210",
    "21*x0 + 20*x2 + 21*x4 <= 282",
    "x0 >= 0",
    "x1 >= 0",
    "x2 >= 0",
    "x3 >= 0",
    "x4 >= 0",
    "x5 >= 0",
    "x6 >= 0"


  ]
}
```

```python
import gurobipy as gp

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

# Create variables
paul = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="paul")
bill = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="bill")
laura = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="laura")
mary = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="mary")
jean = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="jean")
george = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="george")
john = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="john")


# Set objective function
m.setObjective(4*paul + 6*bill + 1*laura + 3*mary + 3*jean + 2*george + 3*john, gp.GRB.MINIMIZE)

# Add constraints

m.addConstr(6 * laura + 3 * jean >= 86)
m.addConstr(28 * george + 26 * john >= 40)
# ... (add all other constraints similarly)

#Resource constraints
r = {}
r[0] = {'ub': 738, 'vars': [23, 11, 6, 2, 3, 28, 26]}
r[1] = {'ub': 728, 'vars': [2, 13, 22, 24, 16, 4, 10]}
r[2] = {'ub': 660, 'vars': [23, 15, 28, 10, 11, 6, 20]}
r[3] = {'ub': 391, 'vars': [21, 26, 20, 29, 21, 1, 16]}

vars = [paul, bill, laura, mary, jean, george, john]

for i in range(4):
    m.addConstr(sum(r[i]['vars'][j] * vars[j] for j in range(7)) <= r[i]['ub'])


# 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)

```