```json
{
  "sym_variables": [
    ("x0", "hours worked by Peggy"),
    ("x1", "hours worked by Mary"),
    ("x2", "hours worked by John"),
    ("x3", "hours worked by Laura"),
    ("x4", "hours worked by Bobby"),
    ("x5", "hours worked by George"),
    ("x6", "hours worked by Bill")
  ],
  "objective_function": "2*x0 + 1*x1 + 5*x2 + 9*x3 + 4*x4 + 9*x5 + 8*x6",
  "constraints": [
    "8*x0 + 9*x6 >= 68",
    "8*x3 + 4*x4 >= 55",
    "8*x3 + 1*x5 >= 58",
    "8*x0 + 7*x2 >= 41",
    "3*x1 + 7*x2 >= 43",
    "7*x2 + 1*x5 >= 40",
    "8*x0 + 4*x4 >= 33",
    "3*x1 + 1*x5 >= 37",
    "8*x0 + 8*x3 >= 45",
    "7*x2 + 8*x3 >= 38",
    "8*x3 + 4*x4 + 9*x6 >= 52",
    "8*x0 + 3*x1 + 4*x4 >= 52",
    "7*x2 + 1*x5 + 9*x6 >= 52",
    "8*x0 + 7*x2 + 1*x5 >= 52",
    "4*x4 + 1*x5 + 9*x6 >= 52",
    "9*x3 + 6*x6 >= 26",
    "2*x2 + 10*x4 >= 52",
    "3*x1 + 5*x5 + 6*x6 >= 41",
    "9*x1 + 2*x6 >= 32",
    "4*x5 + 2*x6 >= 29",
    "9*x1 + 8*x2 >= 40",
    "5*x0 + 1*x4 >= 19",
    "9*x1 + 1*x4 >= 35",
    "8*x2 + 1*x4 >= 39",
    "7*x3 + 4*x5 >= 27",
    "7*x3 + 2*x6 >= 31",
    "8*x0 + 9*x6 <= 81",
    "8*x0 + 1*x5 <= 353",
    "8*x0 + 7*x2 <= 274",
    "8*x0 + 9*x6 <= 242",
    "3*x1 + 4*x4 <= 374",
    "8*x3 + 9*x6 <= 469",
    "7*x2 + 9*x6 <= 153",
    "7*x2 + 8*x3 <= 166",
    "3*x1 + 8*x3 <= 331",
    "9*x3 + 6*x6 <= 96",
    "3*x1 + 10*x4 <= 421",
    "5*x0 + 9*x5 <= 473",
    "10*x4 + 5*x5 <= 217",
    "9*x1 + 5*x5 <= 288",
    "7*x3 + 1*x5 <= 101",
    "9*x1 + 9*x5 <= 517",
    "10*x4 + 4*x6 <= 445",
    "7*x0 + 2*x5 <= 78",
    "x0, x1, x2, x3, x4, x5, x6 >= 0",
    "x0, x1, x2, x3, x4, x5, x6 are integers"

  ]
}
```

```python
from gurobipy import Model, GRB

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

# Create variables
peggy = model.addVar(vtype=GRB.INTEGER, name="peggy")
mary = model.addVar(vtype=GRB.INTEGER, name="mary")
john = model.addVar(vtype=GRB.INTEGER, name="john")
laura = model.addVar(vtype=GRB.INTEGER, name="laura")
bobby = model.addVar(vtype=GRB.INTEGER, name="bobby")
george = model.addVar(vtype=GRB.INTEGER, name="george")
bill = model.addVar(vtype=GRB.INTEGER, name="bill")


# Set objective function
model.setObjective(2 * peggy + 1 * mary + 5 * john + 9 * laura + 4 * bobby + 9 * george + 8 * bill, GRB.MAXIMIZE)

# Add constraints

model.addConstr(8*peggy + 9*bill >= 68)
model.addConstr(8*laura + 4*bobby >= 55)
model.addConstr(8*laura + 1*george >= 58)
model.addConstr(8*peggy + 7*john >= 41)
model.addConstr(3*mary + 7*john >= 43)
model.addConstr(7*john + 1*george >= 40)
model.addConstr(8*peggy + 4*bobby >= 33)
model.addConstr(3*mary + 1*george >= 37)
model.addConstr(8*peggy + 8*laura >= 45)
model.addConstr(7*john + 8*laura >= 38)
model.addConstr(8*laura + 4*bobby + 9*bill >= 52)
model.addConstr(8*peggy + 3*mary + 4*bobby >= 52)
model.addConstr(7*john + 1*george + 9*bill >= 52)
model.addConstr(8*peggy + 7*john + 1*george >= 52)
model.addConstr(4*bobby + 1*george + 9*bill >= 52)
model.addConstr(9*laura + 6*bill >= 26)
model.addConstr(2*john + 10*bobby >= 52)
model.addConstr(3*mary + 5*george + 6*bill >= 41)
model.addConstr(9*mary + 2*bill >= 32)
model.addConstr(4*george + 2*bill >= 29)
model.addConstr(9*mary + 8*john >= 40)
model.addConstr(5*peggy + 1*bobby >= 19)
model.addConstr(9*mary + 1*bobby >= 35)
model.addConstr(8*john + 1*bobby >= 39)
model.addConstr(7*laura + 4*george >= 27)
model.addConstr(7*laura + 2*bill >= 31)


#Resource Constraints
r = {}
r[0] = {'ub': 476, 'peggy': 8, 'mary': 3, 'john': 7, 'laura': 8, 'bobby': 4, 'george': 1, 'bill': 9}
r[1] = {'ub': 474, 'peggy': 11, 'mary': 3, 'john': 2, 'laura': 9, 'bobby': 10, 'george': 5, 'bill': 6}
r[2] = {'ub': 290, 'peggy': 5, 'mary': 9, 'john': 8, 'laura': 7, 'bobby': 1, 'george': 4, 'bill': 2}
r[3] = {'ub': 521, 'peggy': 7, 'mary': 9, 'john': 6, 'laura': 3, 'bobby': 10, 'george': 2, 'bill': 4}

for i in range(4):
    model.addConstr(r[i]['peggy']*peggy + r[i]['mary']*mary + r[i]['john']*john + r[i]['laura']*laura + r[i]['bobby']*bobby + r[i]['george']*george + r[i]['bill']*bill <= r[i]['ub'])


# Optimize model
model.optimize()

# Print results
if model.status == GRB.OPTIMAL:
    print("Optimal solution found:")
    print("Objective value:", model.objVal)
    for v in model.getVars():
        print(f"{v.varName}: {v.x}")
elif model.status == GRB.INFEASIBLE:
    print("Model is infeasible.")
else:
    print(f"Optimization ended with status {model.status}")

```