```json
{
  "sym_variables": [
    ("x0", "hours worked by Jean"),
    ("x1", "hours worked by Laura"),
    ("x2", "hours worked by Ringo"),
    ("x3", "hours worked by Paul"),
    ("x4", "hours worked by Dale")
  ],
  "objective_function": "9.23 * x0 + 5.09 * x1 + 8.47 * x2 + 4.47 * x3 + 2.96 * x4",
  "constraints": [
    "20 * x0 + 29 * x1 >= 50",
    "20 * x0 + 27 * x2 >= 37",
    "27 * x2 + 19 * x3 >= 53",
    "29 * x1 + 27 * x2 >= 25",
    "20 * x0 + 27 * x2 + 3 * x4 >= 40",
    "22 * x2 + 25 * x3 + 21 * x4 >= 50",
    "22 * x0 + 2 * x1 + 21 * x4 >= 50",
    "2 * x1 + 22 * x2 + 21 * x4 >= 50",
    "2 * x1 + 22 * x2 + 25 * x3 >= 50",
    "22 * x2 + 25 * x3 + 21 * x4 >= 88",
    "22 * x0 + 2 * x1 + 21 * x4 >= 88",
    "2 * x1 + 22 * x2 + 21 * x4 >= 88",
    "2 * x1 + 22 * x2 + 25 * x3 >= 88",
    "22 * x2 + 25 * x3 + 21 * x4 >= 73",
    "22 * x0 + 2 * x1 + 21 * x4 >= 73",
    "2 * x1 + 22 * x2 + 21 * x4 >= 73",
    "2 * x1 + 22 * x2 + 25 * x3 >= 73",
    "22 * x2 + 25 * x3 + 21 * x4 >= 57",
    "22 * x0 + 2 * x1 + 21 * x4 >= 57",
    "2 * x1 + 22 * x2 + 21 * x4 >= 57",
    "2 * x1 + 22 * x2 + 25 * x3 >= 57",
    "18 * x1 + 12 * x3 >= 105",
    "3 * x1 - 8 * x2 >= 0",
    "27 * x2 + 3 * x4 <= 145",
    "29 * x1 + 19 * x3 <= 282",
    "27 * x2 + 19 * x3 <= 180",
    "20 * x0 + 3 * x4 <= 202",
    "20 * x0 + 27 * x2 + 3 * x4 <= 153",
    "20 * x0 + 29 * x1 + 3 * x4 <= 215",
    "20 * x0 + 19 * x3 + 3 * x4 <= 123",
    "20 * x0 + 29 * x1 + 19 * x3 <= 87",
    "29 * x1 + 27 * x2 + 3 * x4 <= 173",
    "20 * x0 + 29 * x1 + 27 * x2 + 19 * x3 + 3 * x4 <= 173",
    "22 * x0 + 2 * x1 <= 390",
    "2 * x1 + 25 * x3 <= 485",
    "22 * x0 + 2 * x1 + 22 * x2 + 25 * x3 + 21 * x4 <= 485",
    "15 * x0 + 27 * x4 <= 165",
    "15 * x0 + 12 * x3 <= 244",
    "12 * x3 + 27 * x4 <= 159",
    "28 * x2 + 12 * x3 <= 575",
    "15 * x0 + 28 * x2 <= 460",
    "28 * x2 + 27 * x4 <= 128",
    "15 * x0 + 18 * x1 <= 339",
    "18 * x1 + 28 * x2 <= 403",
    "18 * x1 + 12 * x3 <= 320",
    "15 * x0 + 12 * x3 + 27 * x4 <= 541",
    "15 * x0 + 28 * x2 + 12 * x3 <= 321",
    "15 * x0 + 18 * x1 + 28 * x2 <= 563",
    "15 * x0 + 18 * x1 + 12 * x3 <= 396",
    "15 * x0 + 28 * x2 + 27 * x4 <= 485",
    "18 * x1 + 28 * x2 + 12 * x3 <= 229",
    "15 * x0 + 18 * x1 + 28 * x2 + 12 * x3 + 27 * x4 <= 229",
    "x0, x1, x2, x3, x4 are integers",
    "x0, x1, x2, x3, x4 >= 0"  
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
jean = model.addVar(vtype=gp.GRB.INTEGER, name="jean")
laura = model.addVar(vtype=gp.GRB.INTEGER, name="laura")
ringo = model.addVar(vtype=gp.GRB.INTEGER, name="ringo")
paul = model.addVar(vtype=gp.GRB.INTEGER, name="paul")
dale = model.addVar(vtype=gp.GRB.INTEGER, name="dale")


# Set objective function
model.setObjective(9.23 * jean + 5.09 * laura + 8.47 * ringo + 4.47 * paul + 2.96 * dale, gp.GRB.MAXIMIZE)

# Add constraints
model.addConstr(20 * jean + 29 * laura >= 50)
model.addConstr(20 * jean + 27 * ringo >= 37)
model.addConstr(27 * ringo + 19 * paul >= 53)
model.addConstr(29 * laura + 27 * ringo >= 25)
model.addConstr(20 * jean + 27 * ringo + 3 * dale >= 40)

model.addConstr(22 * ringo + 25 * paul + 21 * dale >= 50)
model.addConstr(22 * jean + 2 * laura + 21 * dale >= 50)
model.addConstr(2 * laura + 22 * ringo + 21 * dale >= 50)
model.addConstr(2 * laura + 22 * ringo + 25 * paul >= 50)

model.addConstr(22 * ringo + 25 * paul + 21 * dale >= 88)
model.addConstr(22 * jean + 2 * laura + 21 * dale >= 88)
model.addConstr(2 * laura + 22 * ringo + 21 * dale >= 88)
model.addConstr(2 * laura + 22 * ringo + 25 * paul >= 88)

model.addConstr(22 * ringo + 25 * paul + 21 * dale >= 73)
model.addConstr(22 * jean + 2 * laura + 21 * dale >= 73)
model.addConstr(2 * laura + 22 * ringo + 21 * dale >= 73)
model.addConstr(2 * laura + 22 * ringo + 25 * paul >= 73)

model.addConstr(22 * ringo + 25 * paul + 21 * dale >= 57)
model.addConstr(22 * jean + 2 * laura + 21 * dale >= 57)
model.addConstr(2 * laura + 22 * ringo + 21 * dale >= 57)
model.addConstr(2 * laura + 22 * ringo + 25 * paul >= 57)


model.addConstr(18 * laura + 12 * paul >= 105)
model.addConstr(3 * laura - 8 * ringo >= 0)

model.addConstr(27 * ringo + 3 * dale <= 145)
model.addConstr(29 * laura + 19 * paul <= 282)
model.addConstr(27 * ringo + 19 * paul <= 180)
model.addConstr(20 * jean + 3 * dale <= 202)
model.addConstr(20 * jean + 27 * ringo + 3 * dale <= 153)
model.addConstr(20 * jean + 29 * laura + 3 * dale <= 215)
model.addConstr(20 * jean + 19 * paul + 3 * dale <= 123)
model.addConstr(20 * jean + 29 * laura + 19 * paul <= 87)
model.addConstr(29 * laura + 27 * ringo + 3 * dale <= 173)
model.addConstr(20 * jean + 29 * laura + 27 * ringo + 19 * paul + 3 * dale <= 173)

model.addConstr(22 * jean + 2 * laura <= 390)
model.addConstr(2 * laura + 25 * paul <= 485)
model.addConstr(22 * jean + 2 * laura + 22 * ringo + 25 * paul + 21 * dale <= 485)

model.addConstr(15 * jean + 27 * dale <= 165)
model.addConstr(15 * jean + 12 * paul <= 244)
model.addConstr(12 * paul + 27 * dale <= 159)
model.addConstr(28 * ringo + 12 * paul <= 575)
model.addConstr(15 * jean + 28 * ringo <= 460)
model.addConstr(28 * ringo + 27 * dale <= 128)
model.addConstr(15 * jean + 18 * laura <= 339)
model.addConstr(18 * laura + 28 * ringo <= 403)
model.addConstr(18 * laura + 12 * paul <= 320)
model.addConstr(15 * jean + 12 * paul + 27 * dale <= 541)
model.addConstr(15 * jean + 28 * ringo + 12 * paul <= 321)
model.addConstr(15 * jean + 18 * laura + 28 * ringo <= 563)
model.addConstr(15 * jean + 18 * laura + 12 * paul <= 396)
model.addConstr(15 * jean + 28 * ringo + 27 * dale <= 485)
model.addConstr(18 * laura + 28 * ringo + 12 * paul <= 229)
model.addConstr(15 * jean + 18 * laura + 28 * ringo + 12 * paul + 27 * dale <= 229)


# Optimize model
model.optimize()

# Print results
if model.status == gp.GRB.OPTIMAL:
    print("Optimal solution found:")
    print(f"Jean: {jean.x}")
    print(f"Laura: {laura.x}")
    print(f"Ringo: {ringo.x}")
    print(f"Paul: {paul.x}")
    print(f"Dale: {dale.x}")
    print(f"Objective value: {model.objVal}")
elif model.status == gp.GRB.INFEASIBLE:
    print("Model is infeasible.")
else:
    print(f"Optimization terminated with status {model.status}")

```