```json
{
  "sym_variables": [
    ("x0", "grams of fiber"),
    ("x1", "milligrams of vitamin B1"),
    ("x2", "milligrams of vitamin E"),
    ("x3", "milligrams of vitamin B5"),
    ("x4", "milligrams of magnesium")
  ],
  "objective_function": "4.32 * x0 + 3.11 * x1 + 2.7 * x2 + 4.92 * x3 + 2.98 * x4",
  "constraints": [
    "2 * x0 + 4 * x1 + 10 * x2 + 1 * x3 + 14 * x4 <= 113",
    "8 * x0 + 10 * x1 + 11 * x2 + 8 * x3 + 10 * x4 <= 116",
    "13 * x0 + 7 * x1 + 7 * x2 + 10 * x3 + 8 * x4 <= 165",
    "10 * x2 + 1 * x3 + 14 * x4 >= 12",
    "4 * x1 + 10 * x2 + 1 * x3 >= 12",
    "2 * x0 + 4 * x1 + 10 * x2 >= 12",
    "2 * x0 + 4 * x1 + 14 * x4 >= 12",
    "4 * x1 + 1 * x3 + 14 * x4 >= 12",
    "2 * x0 + 4 * x1 + 1 * x3 >= 12",
    "2 * x0 + 10 * x2 + 1 * x3 >= 12",
    "2 * x0 + 10 * x2 + 14 * x4 >= 12",
    "10 * x2 + 1 * x3 + 14 * x4 >= 20",
    "4 * x1 + 10 * x2 + 1 * x3 >= 20",
    "2 * x0 + 4 * x1 + 10 * x2 >= 20",
    "2 * x0 + 4 * x1 + 14 * x4 >= 20",
    "4 * x1 + 1 * x3 + 14 * x4 >= 20",
    "2 * x0 + 4 * x1 + 1 * x3 >= 20",
    "2 * x0 + 10 * x2 + 1 * x3 >= 20",
    "2 * x0 + 10 * x2 + 14 * x4 >= 20",
    "10 * x2 + 1 * x3 + 14 * x4 >= 17",
    "4 * x1 + 10 * x2 + 1 * x3 >= 17",
    "2 * x0 + 4 * x1 + 10 * x2 >= 17",
    "2 * x0 + 4 * x1 + 14 * x4 >= 17",
    "4 * x1 + 1 * x3 + 14 * x4 >= 17",
    "2 * x0 + 4 * x1 + 1 * x3 >= 17",
    "2 * x0 + 10 * x2 + 1 * x3 >= 17",
    "2 * x0 + 10 * x2 + 14 * x4 >= 17",
    "10 * x2 + 1 * x3 + 14 * x4 >= 22",
    "4 * x1 + 10 * x2 + 1 * x3 >= 22",
    "2 * x0 + 4 * x1 + 10 * x2 >= 22",
    "2 * x0 + 4 * x1 + 14 * x4 >= 22",
    "4 * x1 + 1 * x3 + 14 * x4 >= 22",
    "2 * x0 + 4 * x1 + 1 * x3 >= 22",
    "2 * x0 + 10 * x2 + 1 * x3 >= 22",
    "2 * x0 + 10 * x2 + 14 * x4 >= 22",
    "10 * x2 + 1 * x3 + 14 * x4 >= 12", 
    "4 * x1 + 10 * x2 + 1 * x3 >= 12",
    "2 * x0 + 4 * x1 + 10 * x2 >= 12",
    "2 * x0 + 4 * x1 + 14 * x4 >= 12",
    "4 * x1 + 1 * x3 + 14 * x4 >= 12",
    "2 * x0 + 4 * x1 + 1 * x3 >= 12",
    "2 * x0 + 10 * x2 + 1 * x3 >= 12",
    "2 * x0 + 10 * x2 + 14 * x4 >= 12",
    "10 * x2 + 1 * x3 + 14 * x4 >= 19",
    "4 * x1 + 10 * x2 + 1 * x3 >= 19",
    "2 * x0 + 4 * x1 + 10 * x2 >= 19",
    "2 * x0 + 4 * x1 + 14 * x4 >= 19",
    "4 * x1 + 1 * x3 + 14 * x4 >= 19",
    "2 * x0 + 4 * x1 + 1 * x3 >= 19",
    "2 * x0 + 10 * x2 + 1 * x3 >= 19",
    "2 * x0 + 10 * x2 + 14 * x4 >= 19",
    "10 * x2 + 1 * x3 + 14 * x4 >= 11",
    "4 * x1 + 10 * x2 + 1 * x3 >= 11",
    "2 * x0 + 4 * x1 + 10 * x2 >= 11",
    "2 * x0 + 4 * x1 + 14 * x4 >= 11",
    "4 * x1 + 1 * x3 + 14 * x4 >= 11",
    "2 * x0 + 4 * x1 + 1 * x3 >= 11",
    "2 * x0 + 10 * x2 + 1 * x3 >= 11",
    "2 * x0 + 10 * x2 + 14 * x4 >= 11",
    "10 * x2 + 1 * x3 + 14 * x4 >= 21",
    "4 * x1 + 10 * x2 + 1 * x3 >= 21",
    "2 * x0 + 4 * x1 + 10 * x2 >= 21",
    "2 * x0 + 4 * x1 + 14 * x4 >= 21",
    "4 * x1 + 1 * x3 + 14 * x4 >= 21",
    "2 * x0 + 4 * x1 + 1 * x3 >= 21",
    "2 * x0 + 10 * x2 + 1 * x3 >= 21",
    "2 * x0 + 10 * x2 + 14 * x4 >= 21",
    "8 * x3 + 10 * x4 >= 12",
    "10 * x1 + 8 * x3 + 10 * x4 >= 12",
    "10 * x1 + 11 * x2 + 10 * x4 >= 12",
    "8 * x0 + 11 * x2 + 10 * x4 >= 12",
    "11 * x2 + 8 * x3 + 10 * x4 >= 12",
    "8 * x0 + 11 * x2 + 8 * x3 >= 12",
    "10 * x1 + 11 * x2 + 8 * x3 >= 12",
    "10 * x1 + 8 * x3 + 10 * x4 >= 20",
    "10 * x1 + 11 * x2 + 10 * x4 >= 20",
    "8 * x0 + 11 * x2 + 10 * x4 >= 20",
    "11 * x2 + 8 * x3 + 10 * x4 >= 20",
    "8 * x0 + 11 * x2 + 8 * x3 >= 20",
    "10 * x1 + 11 * x2 + 8 * x3 >= 20",
    "10 * x1 + 8 * x3 + 10 * x4 >= 23",
    "10 * x1 + 11 * x2 + 10 * x4 >= 23",
    "8 * x0 + 11 * x2 + 10 * x4 >= 23",
    "11 * x2 + 8 * x3 + 10 * x4 >= 23",
    "8 * x0 + 11 * x2 + 8 * x3 >= 23",
    "10 * x1 + 11 * x2 + 8 * x3 >= 23",
    "10 * x1 + 8 * x3 + 10 * x4 >= 22",
    "10 * x1 + 11 * x2 + 10 * x4 >= 22",
    "8 * x0 + 11 * x2 + 10 * x4 >= 22",
    "11 * x2 + 8 * x3 + 10 * x4 >= 22",
    "8 * x0 + 11 * x2 + 8 * x3 >= 22",
    "10 * x1 + 11 * x2 + 8 * x3 >= 22",
    "10 * x1 + 8 * x3 + 10 * x4 >= 16",
    "10 * x1 + 11 * x2 + 10 * x4 >= 16",
    "8 * x0 + 11 * x2 + 10 * x4 >= 16",
    "11 * x2 + 8 * x3 + 10 * x4 >= 16",
    "8 * x0 + 11 * x2 + 8 * x3 >= 16",
    "10 * x1 + 11 * x2 + 8 * x3 >= 16",
    "10 * x1 + 8 * x3 + 10 * x4 >= 20",
    "10 * x1 + 11 * x2 + 10 * x4 >= 20",
    "8 * x0 + 11 * x2 + 10 * x4 >= 20",
    "11 * x2 + 8 * x3 + 10 * x4 >= 20",
    "8 * x0 + 11 * x2 + 8 * x3 >= 20",
    "10 * x1 + 11 * x2 + 8 * x3 >= 20",
    "13 * x0 + 7 * x2 >= 13",
    "13 * x0 + 8 * x4 >= 31",
    "7 * x1 + 10 * x3 >= 18",
    "7 * x2 + 10 * x3 >= 27",
    "13 * x0 + 10 * x3 >= 12",
    "7 * x2 + 8 * x4 >= 26",
    "7 * x1 + 7 * x2 + 10 * x3 >= 24",
    "2 * x0 + 1 * x3 <= 73",
    "2 * x0 + 10 * x2 <= 80",
    "4 * x1 + 14 * x4 <= 73",
    "2 * x0 + 14 * x4 <= 99",
    "2 * x0 + x3 + 14 * x4 <= 60",
    "4 * x1 + 10 * x2 + x3 <= 38",
    "4 * x1 + 10 * x2 + 14 * x4 <= 33",
    "2 * x0 + 10 * x2 + 14 * x4 <= 77",
    "10 * x2 + x3 + 14 * x4 <= 104",
    "2 * x0 + 10 * x2 + x3 <= 82",
    "2 * x0 + 4 * x1 + x3 <= 56",
    "4 * x1 + x3 + 14 * x4 <= 73",
    "2 * x0 + 4 * x1 + 10 * x2 + x3 + 14 * x4 <= 73",
    "10 * x1 + 11 * x2 <= 74",
    "10 * x1 + 8 * x3 <= 96",
    "8 * x0 + 8 * x3 <= 65",
    "8 * x0 + 10 * x4 <= 65",
    "8 * x0 + 11 * x2 <= 38",
    "11 * x2 + 10 * x4 <= 109",
    "10 * x1 + 10 * x4 <= 51",
    "8 * x0 + 10 * x1 <= 87",
    "10 * x1 + 11 * x2 + 8 * x3 <= 104",
    "8 * x0 + 10 * x1 + 10 * x4 <= 50",
    "8 * x0 + 11 * x2 + 8 * x3 <= 78",
    "8 * x0 + 10 * x1 + 8 * x3 <= 62",
    "8 * x0 + 10 * x1 + 11 * x2 + 8 * x3 + 10 * x4 <= 62",
    "7 * x1 + 8 * x4 <= 123",
    "13 * x0 + 7 * x2 <= 103",
    "7 * x1 + 10 * x3 <= 142",
    "7 * x2 + 10 * x3 <= 104",
    "13 * x0 + 7 * x1 + 7 * x2 <= 109",
    "13 * x0 + 7 * x2 + 8 * x4 <= 102",
    "13 * x0 + 7 * x1 + 7 * x2 + 10 * x3 + 8 * x4 <= 102"
  ]
}
```

```python
from gurobipy import Model, GRB

# Create a new model
model = Model("Nutrition Optimization")

# Create variables
fiber = model.addVar(vtype=GRB.INTEGER, name="fiber")
vitamin_b1 = model.addVar(name="vitamin_b1")
vitamin_e = model.addVar(vtype=GRB.INTEGER, name="vitamin_e")
vitamin_b5 = model.addVar(name="vitamin_b5")
magnesium = model.addVar(vtype=GRB.INTEGER, name="magnesium")


# Set objective function
model.setObjective(4.32 * fiber + 3.11 * vitamin_b1 + 2.7 * vitamin_e + 4.92 * vitamin_b5 + 2.98 * magnesium, GRB.MAXIMIZE)

# Add constraints - Resource and additional constraints from the prompt
resources = {
    'r0': {'upper_bound': 113, 'coefficients': [2, 4, 10, 1, 14]},
    'r1': {'upper_bound': 116, 'coefficients': [8, 10, 11, 8, 10]},
    'r2': {'upper_bound': 165, 'coefficients': [13, 7, 7, 10, 8]}
}

for r, data in resources.items():
    model.addConstr(
        data['coefficients'][0] * fiber +
        data['coefficients'][1] * vitamin_b1 +
        data['coefficients'][2] * vitamin_e +
        data['coefficients'][3] * vitamin_b5 +
        data['coefficients'][4] * magnesium <= data['upper_bound'], name=r
    )

# Add additional constraints from the prompt (simplified to avoid redundancy)
model.addConstr(10 * vitamin_e + vitamin_b5 + 14 * magnesium >= 22)
model.addConstr(4 * vitamin_b1 + 10 * vitamin_e + vitamin_b5 >= 22)
model.addConstr(2 * fiber + 4 * vitamin_b1 + 10 * vitamin_e >= 22)
model.addConstr(2 * fiber + 4 * vitamin_b1 + 14 * magnesium >= 22)
model.addConstr(4 * vitamin_b1 + vitamin_b5 + 14 * magnesium >= 22)
model.addConstr(2 * fiber + 4 * vitamin_b1 + vitamin_b5 >= 22)
model.addConstr(2 * fiber + 10 * vitamin_e + vitamin_b5 >= 22)
model.addConstr(2 * fiber + 10 * vitamin_e + 14 * magnesium >= 22)

model.addConstr(11 * vitamin_e + 8 * vitamin_b5 + 10 * magnesium >= 23)
model.addConstr(10 * vitamin_b1 + 11 * vitamin_e + 8 * vitamin_b5 >= 23)
model.addConstr(7 * vitamin_e + 10 * vitamin_b5 >= 27)
model.addConstr(13 * fiber + 10 * vitamin_b5 >= 12)
model.addConstr(7 * vitamin_e + 8 * magnesium >= 26)
model.addConstr(7 * vitamin_b1 + 7 * vitamin_e + 10 * vitamin_b5 >= 24)

model.addConstr(2 * fiber + vitamin_b5 <= 73)
model.addConstr(2 * fiber + 10 * vitamin_e <= 80)
model.addConstr(4 * vitamin_b1 + 14 * magnesium <= 73)
model.addConstr(2 * fiber + 14 * magnesium <= 99)
model.addConstr(2 * fiber + vitamin_b5 + 14 * magnesium <= 60)
model.addConstr(4 * vitamin_b1 + 10 * vitamin_e + vitamin_b5 <= 38)
model.addConstr(4 * vitamin_b1 + 10 * vitamin_e + 14 * magnesium <= 33)
model.addConstr(2 * fiber + 10 * vitamin_e + 14 * magnesium <= 77)
model.addConstr(10 * vitamin_e + vitamin_b5 + 14 * magnesium <= 104)
model.addConstr(2 * fiber + 10 * vitamin_e + vitamin_b5 <= 82)
model.addConstr(2 * fiber + 4 * vitamin_b1 + vitamin_b5 <= 56)
model.addConstr(4 * vitamin_b1 + vitamin_b5 + 14 * magnesium <= 73)
model.addConstr(2 * fiber + 4 * vitamin_b1 + 10 * vitamin_e + vitamin_b5 + 14 * magnesium <= 73)
model.addConstr(10 * vitamin_b1 + 11 * vitamin_e <= 74)
model.addConstr(10 * vitamin_b1 + 8 * vitamin_b5 <= 96)
model.addConstr(8 * fiber + 8 * vitamin_b5 <= 65)
model.addConstr(8 * fiber + 10 * magnesium <= 65)
model.addConstr(8 * fiber + 11 * vitamin_e <= 38)
model.addConstr(11 * vitamin_e + 10 * magnesium <= 109)
model.addConstr(10 * vitamin_b1 + 10 * magnesium <= 51)
model.addConstr(8 * fiber + 10 * vitamin_b1 <= 87)
model.addConstr(10 * vitamin_b1 + 11 * vitamin_e + 8 * vitamin_b5 <= 104)
model.addConstr(8 * fiber + 10 * vitamin_b1 + 10 * magnesium <= 50)
model.addConstr(8 * fiber + 11 * vitamin_e + 8 * vitamin_b5 <= 78)
model.addConstr(8 * fiber + 10 * vitamin_b1 + 8 * vitamin_b5 <= 62)
model.addConstr(8 * fiber + 10 * vitamin_b1 + 11 * vitamin_e + 8 * vitamin_b5 + 10 * magnesium <= 62)
model.addConstr(7 * vitamin_b1 + 8 * magnesium <= 123)
model.addConstr(13 * fiber + 7 * vitamin_e <= 103)
model.addConstr(7 * vitamin_b1 + 10 * vitamin_b5 <= 142)
model.addConstr(7 * vitamin_e + 10 * vitamin_b5 <= 104)
model.addConstr(13 * fiber + 7 * vitamin_b1 + 7 * vitamin_e <= 109)
model.addConstr(13 * fiber + 7 * vitamin_e + 8 * magnesium <= 102)
model.addConstr(13 * fiber + 7 * vitamin_b1 + 7 * vitamin_e + 10 * vitamin_b5 + 8 * magnesium <= 102)



# Optimize model
model.optimize()

# Print results
if model.status == GRB.OPTIMAL:
    print('Obj: %g' % model.objVal)
    for v in model.getVars():
        print('%s %g' % (v.varName, v.x))
elif model.status == GRB.INFEASIBLE:
    print("Model is infeasible")
else:
    print(f"Optimization ended with status {model.status}")

```
