```json
{
  "sym_variables": [
    ("x0", "peanutbutter sandwiches"),
    ("x1", "kiwis"),
    ("x2", "chicken drumsticks"),
    ("x3", "bagged salads"),
    ("x4", "potatoes")
  ],
  "objective_function": "4.17 * x0 + 5.07 * x1 + 1.76 * x2 + 5.66 * x3 + 8.71 * x4",
  "constraints": [
    "11 * x0 + 13 * x3 >= 35",
    "11 * x0 + 17 * x4 >= 44",
    "9 * x1 + 13 * x3 >= 27",
    "11 * x0 + 16 * x2 >= 66",
    "16 * x2 + 17 * x4 >= 45",
    "13 * x3 + 17 * x4 >= 31",
    "11 * x0 + 9 * x1 + 16 * x2 + 13 * x3 + 17 * x4 >= 31",
    "17 * x1 + 1 * x2 >= 37",
    "5 * x0 + 20 * x3 >= 37",
    "20 * x3 + 13 * x4 >= 24",
    "5 * x0 + 17 * x1 + 1 * x2 + 20 * x3 + 13 * x4 >= 24",
    "19 * x0 + 5 * x3 >= 47",
    "5 * x3 + 14 * x4 >= 66",
    "14 * x1 + 14 * x4 >= 58",
    "14 * x1 + 5 * x3 >= 45",
    "19 * x0 + 18 * x2 + 14 * x4 >= 37",
    "14 * x1 + 18 * x2 + 5 * x3 >= 37",
    "19 * x0 + 18 * x2 + 14 * x4 >= 40",
    "14 * x1 + 18 * x2 + 5 * x3 >= 40",
    "19 * x0 + 14 * x1 + 18 * x2 + 5 * x3 + 14 * x4 >= 40",
    "12 * x0 + 13 * x1 >= 27",
    "13 * x2 + 17 * x3 >= 16",
    "12 * x0 + 12 * x4 >= 44",
    "12 * x0 + 17 * x3 >= 41",
    "12 * x0 + 13 * x2 >= 44",
    "13 * x1 + 12 * x4 >= 38",
    "12 * x0 + 13 * x1 + 17 * x3 >= 22",  
    "13 * x1 + 17 * x3 + 12 * x4 >= 22",
    "13 * x1 + 13 * x2 + 12 * x4 >= 22",
    "12 * x0 + 13 * x2 + 17 * x3 >= 22",
    "12 * x0 + 13 * x1 + 12 * x4 >= 22",
    "12 * x0 + 13 * x1 + 17 * x3 >= 41",
    "13 * x1 + 17 * x3 + 12 * x4 >= 41",
    "13 * x1 + 13 * x2 + 12 * x4 >= 41",
    "12 * x0 + 13 * x2 + 17 * x3 >= 41",
    "12 * x0 + 13 * x1 + 12 * x4 >= 41",
    "12 * x0 + 13 * x1 + 17 * x3 >= 32",
    "13 * x1 + 17 * x3 + 12 * x4 >= 32",
    "13 * x1 + 13 * x2 + 12 * x4 >= 32",
    "12 * x0 + 13 * x2 + 17 * x3 >= 32",
    "12 * x0 + 13 * x1 + 12 * x4 >= 32",
    "12 * x0 + 13 * x1 + 17 * x3 >= 44",
    "13 * x1 + 17 * x3 + 12 * x4 >= 44",
    "13 * x1 + 13 * x2 + 12 * x4 >= 44",
    "12 * x0 + 13 * x2 + 17 * x3 >= 44",
    "12 * x0 + 13 * x1 + 12 * x4 >= 44",
    "12 * x0 + 13 * x1 + 17 * x3 >= 38",
    "13 * x1 + 17 * x3 + 12 * x4 >= 38",
    "13 * x1 + 13 * x2 + 12 * x4 >= 38",
    "12 * x0 + 13 * x2 + 17 * x3 >= 38",
    "12 * x0 + 13 * x1 + 12 * x4 >= 38",
    "12 * x0 + 13 * x1 + 13 * x2 + 17 * x3 + 12 * x4 >= 38",
    "11 * x0 + 8 * x4 >= 32",
    "3 * x2 + 11 * x3 >= 27",
    "3 * x2 + 8 * x4 >= 29",
    "8 * x1 + 3 * x2 >= 43",
    "11 * x0 + 8 * x1 >= 20",
    "8 * x1 + 11 * x3 >= 21",
    "3 * x2 + 11 * x3 + 8 * x4 >= 36",
    "11 * x0 + 8 * x1 + 11 * x3 >= 36",
    "3 * x2 + 11 * x3 + 8 * x4 >= 35",
    "11 * x0 + 8 * x1 + 11 * x3 >= 35",
    "11 * x0 + 8 * x1 + 3 * x2 + 11 * x3 + 8 * x4 >= 35",
    "9 * x3 - 5 * x4 >= 0",
    "-10 * x0 + 10 * x3 >= 0",
    "11 * x0 + 16 * x2 <= 135",
    "9 * x1 + 13 * x3 + 17 * x4 <= 78",
    "9 * x1 + 16 * x2 + 17 * x4 <= 325",
    "5 * x0 + 13 * x4 <= 156",
    "1 * x2 + 13 * x4 <= 116",
    "5 * x0 + 20 * x3 <= 136",
    "1 * x2 + 20 * x3 <= 62",
    "17 * x1 + 20 * x3 <= 139",
    "17 * x1 + 1 * x2 + 13 * x4 <= 171",
    "5 * x0 + 17 * x1 + 1 * x2 <= 182",
    "19 * x0 + 14 * x1 + 18 * x2 <= 221",
    "14 * x1 + 5 * x3 + 14 * x4 <= 227",
    "13 * x2 + 12 * x4 <= 97",
    "17 * x3 + 12 * x4 <= 99",
    "12 * x0 + 13 * x1 <= 122",
    "13 * x1 + 13 * x2 <= 74",
    "13 * x2 + 17 * x3 <= 49",
    "13 * x1 + 12 * x4 <= 150",
    "12 * x0 + 12 * x4 <= 186",
    "3 * x2 + 11 * x3 <= 129",
    "11 * x0 + 3 * x2 <= 169",
    "3 * x2 + 8 * x4 <= 52",
    "8 * x1 + 8 * x4 <= 173",
    "11 * x3 + 8 * x4 <= 63",
    "11 * x0 + 3 * x2 + 11 * x3 <= 64",
    "11 * x0 + 8 * x1 + 3 * x2 <= 184",
    "8 * x1 + 3 * x2 + 8 * x4 <= 78",
    "11 * x0 + 8 * x1 + 11 * x3 <= 60",
    "11 * x0 + 8 * x1 + 8 * x4 <= 190",
    "8 * x1 + 11 * x3 + 8 * x4 <= 71",
    "11 * x0 + 11 * x3 + 8 * x4 <= 88",
    "r0 <= 344",
    "r1 <= 189",
    "r2 <= 330",
    "r3 <= 229",
    "r4 <= 230"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = m.addVars(5, lb=0.0, ub=gp.GRB.INFINITY, vtype=gp.GRB.CONTINUOUS, names=["x0", "x1", "x2", "x3", "x4"])
r = m.addVars(5, lb=0.0, ub=gp.GRB.INFINITY, vtype=gp.GRB.CONTINUOUS, names=["r0", "r1", "r2", "r3", "r4"])


# Set objective
m.setObjective(4.17 * x[0] + 5.07 * x[1] + 1.76 * x[2] + 5.66 * x[3] + 8.71 * x[4], gp.GRB.MINIMIZE)

# Add constraints

# Resource constraints
m.addConstr(r[0] == 11 * x[0] + 9 * x[1] + 16 * x[2] + 13 * x[3] + 17 * x[4], "fat_constraint")
m.addConstr(r[1] == 5 * x[0] + 17 * x[1] + 1 * x[2] + 20 * x[3] + 13 * x[4], "cost_constraint")
m.addConstr(r[2] == 19 * x[0] + 14 * x[1] + 18 * x[2] + 5 * x[3] + 14 * x[4], "calcium_constraint")
m.addConstr(r[3] == 12 * x[0] + 13 * x[1] + 13 * x[2] + 17 * x[3] + 12 * x[4], "sourness_constraint")
m.addConstr(r[4] == 11 * x[0] + 8 * x[1] + 3 * x[2] + 11 * x[3] + 8 * x[4], "tastiness_constraint")


m.addConstr(r[0] <= 344)
m.addConstr(r[1] <= 189)
m.addConstr(r[2] <= 330)
m.addConstr(r[3] <= 229)
m.addConstr(r[4] <= 230)


# Other constraints, translated from the JSON's "constraints"
for constraint_str in json_data["constraints"]:
    m.addConstr(eval(constraint_str))  # eval() is used here for simplicity, but be cautious in real-world applications


# Optimize model
m.optimize()

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

```
