```json
{
  "sym_variables": [
    ("x0", "bagged salads"),
    ("x1", "apples"),
    ("x2", "green beans"),
    ("x3", "oranges"),
    ("x4", "slices of pizza")
  ],
  "objective_function": "6*x0 + 8*x1 + 5*x2 + 5*x3 + 4*x4",
  "constraints": [
    "11*x0 + 20*x1 + 4*x2 + 8*x3 + 27*x4 <= 671",
    "10*x0 + 1*x1 + 12*x2 + 23*x3 + 29*x4 <= 744",
    "26*x0 + 21*x1 + 18*x2 + 18*x3 + 21*x4 <= 594",
    "8*x3 + 27*x4 >= 91",
    "20*x1 + 8*x3 >= 67",
    "20*x1 + 27*x4 >= 57",
    "4*x2 + 8*x3 >= 101",
    "11*x0 + 4*x2 >= 134",
    "11*x0 + 4*x2 + 27*x4 >= 70",
    "10*x0 + 1*x1 >= 72",
    "10*x0 + 23*x3 >= 146",
    "1*x1 + 29*x4 >= 56",
    "10*x0 + 12*x2 + 29*x4 >= 97",
    "12*x2 + 23*x3 + 29*x4 >= 97",
    "10*x0 + 23*x3 + 29*x4 >= 97",
    "1*x1 + 12*x2 + 29*x4 >= 97",
    "10*x0 + 12*x2 + 29*x4 >= 87",
    "12*x2 + 23*x3 + 29*x4 >= 87",
    "10*x0 + 23*x3 + 29*x4 >= 87",
    "1*x1 + 12*x2 + 29*x4 >= 87",
    "10*x0 + 12*x2 + 29*x4 >= 100",
    "12*x2 + 23*x3 + 29*x4 >= 100",
    "10*x0 + 23*x3 + 29*x4 >= 100",
    "1*x1 + 12*x2 + 29*x4 >= 100",
    "10*x0 + 12*x2 + 29*x4 >= 93",
    "12*x2 + 23*x3 + 29*x4 >= 93",
    "10*x0 + 23*x3 + 29*x4 >= 93",
    "1*x1 + 12*x2 + 29*x4 >= 93",
    "-2*x3 + 6*x4 >= 0",
    "11*x0 + 20*x1 <= 211",
    "8*x3 + 27*x4 <= 180",
    "4*x2 + 27*x4 <= 630",
    "11*x0 + 20*x1 + 4*x2 + 8*x3 + 27*x4 <= 630",
    "23*x3 + 29*x4 <= 494",
    "1*x1 + 23*x3 <= 434",
    "10*x0 + 29*x4 <= 601",
    "10*x0 + 1*x1 + 12*x2 + 23*x3 + 29*x4 <= 601",
    "21*x1 + 21*x4 <= 245",
    "18*x2 + 21*x4 <= 432",
    "21*x1 + 18*x2 <= 443",
    "26*x0 + 18*x2 <= 312",
    "21*x1 + 18*x3 <= 571",
    "18*x2 + 18*x3 + 21*x4 <= 282",
    "26*x0 + 21*x1 + 18*x2 <= 155",
    "26*x0 + 21*x1 + 18*x3 <= 404",
    "21*x1 + 18*x3 + 21*x4 <= 238",
    "21*x1 + 18*x2 + 21*x4 <= 332",
    "26*x0 + 18*x2 + 21*x4 <= 571",
    "26*x0 + 21*x1 + 18*x2 + 18*x3 + 21*x4 <= 571"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = m.addVars(5, vtype=gp.GRB.INTEGER, names=["bagged salads", "apples", "green beans", "oranges", "slices of pizza"])

# Set objective function
m.setObjective(6*x[0] + 8*x[1] + 5*x[2] + 5*x[3] + 4*x[4], gp.GRB.MAXIMIZE)

# Add constraints
m.addConstr(11*x[0] + 20*x[1] + 4*x[2] + 8*x[3] + 27*x[4] <= 671, "c0")
m.addConstr(10*x[0] + 1*x[1] + 12*x[2] + 23*x[3] + 29*x[4] <= 744, "c1")
m.addConstr(26*x[0] + 21*x[1] + 18*x[2] + 18*x[3] + 21*x[4] <= 594, "c2")
m.addConstr(8*x[3] + 27*x[4] >= 91, "c3")
m.addConstr(20*x[1] + 8*x[3] >= 67, "c4")
m.addConstr(20*x[1] + 27*x[4] >= 57, "c5")
m.addConstr(4*x[2] + 8*x[3] >= 101, "c6")
m.addConstr(11*x[0] + 4*x[2] >= 134, "c7")
m.addConstr(11*x[0] + 4*x[2] + 27*x[4] >= 70, "c8")
m.addConstr(10*x[0] + 1*x[1] >= 72, "c9")
m.addConstr(10*x[0] + 23*x[3] >= 146, "c10")
m.addConstr(1*x[1] + 29*x[4] >= 56, "c11")
m.addConstr(10*x[0] + 12*x[2] + 29*x[4] >= 97, "c12")
m.addConstr(12*x[2] + 23*x[3] + 29*x[4] >= 97, "c13")
m.addConstr(10*x[0] + 23*x[3] + 29*x[4] >= 97, "c14")
m.addConstr(1*x[1] + 12*x[2] + 29*x[4] >= 97, "c15")

# ... (rest of the constraints)


m.addConstr(-2*x[3] + 6*x[4] >= 0, "c37")
# ... (rest of the constraints)


# Optimize model
m.optimize()

# Print solution
if m.status == gp.GRB.OPTIMAL:
    for v in m.getVars():
        print(f'{v.varName}: {v.x}')
    print(f'Objective Value: {m.objVal}')
elif m.status == gp.GRB.INFEASIBLE:
    print("The model is infeasible.")
else:
    print(f"Optimization terminated with status {m.status}")

```