```json
{
  "sym_variables": [
    ("x0", "milligrams of vitamin B6"),
    ("x1", "milligrams of vitamin E"),
    ("x2", "milligrams of vitamin B9"),
    ("x3", "grams of fiber"),
    ("x4", "milligrams of iron"),
    ("x5", "milligrams of vitamin K"),
    ("x6", "milligrams of vitamin B5")
  ],
  "objective_function": "9.43 * x0 + 6.8 * x1 + 9.05 * x2 + 6.01 * x3 + 4.84 * x4 + 2.36 * x5 + 7.56 * x6",
  "constraints": [
    "9 * x4 + 6 * x5 >= 44",
    "9 * x0 + 11 * x6 >= 27",
    "10 * x1 + 8 * x2 >= 27",
    "8 * x2 + 6 * x5 >= 52",
    "8 * x2 + 8 * x4 >= 52",
    "6 * x5 + 11 * x6 >= 27",
    "8 * x4 + 11 * x6 >= 24",
    "8 * x2 + 3 * x3 >= 33",
    "10 * x1 + 8 * x2 + 11 * x6 >= 64",
    "9 * x0 + 10 * x1 + 8 * x2 + 3 * x3 + 8 * x4 + 6 * x5 + 11 * x6 >= 64",
    "11 * x3 + 7 * x6 >= 48",
    "4 * x5 + 7 * x6 >= 58",
    "10 * x2 + 7 * x6 >= 63",
    "3 * x0 + 10 * x2 >= 51",
    "14 * x4 + 7 * x6 >= 67",
    "11 * x3 + 4 * x5 >= 73",
    "3 * x0 + 4 * x5 >= 57",
    "17 * x1 + 4 * x5 >= 79",
    "17 * x1 + 7 * x6 >= 56",
    "14 * x4 + 4 * x5 >= 62",
    "10 * x2 + 4 * x5 >= 58",
    "17 * x1 + 11 * x3 >= 59",
    "11 * x3 + 14 * x4 >= 83",
    "3 * x0 + 14 * x4 >= 50",
    "17 * x1 + 11 * x3 + 7 * x6 >= 82",
    "3 * x0 + 17 * x1 + 10 * x2 + 11 * x3 + 14 * x4 + 4 * x5 + 7 * x6 >= 82",
    "9 * x0 + 10 * x1 + 8 * x2 + 3 * x3 <= 518",
    "3 * x0 + 17 * x1 + 10 * x2 + 11 * x3 + 14 * x4 + 4 * x5 + 7 * x6 <= 588",
    "4 * x0 + 5 * x1 + 16 * x2 + 14 * x3 + 12 * x4 + 9 * x5 + 10 * x6 <= 227",
    "-4 * x1 + 3 * x2 >= 0",
    "x2 - 10 * x3 >= 0",
    "-7 * x0 + 9 * x6 >= 0",
    "-7 * x0 - x1 + 5 * x3 >= 0",
    "3 * x3 + 8 * x4 <= 382",
    "8 * x2 + 8 * x4 <= 103",
    "10 * x1 + 3 * x3 + 8 * x4 <= 368",
    "8 * x2 + 8 * x4 + 11 * x6 <= 421",
    "10 * x1 + 3 * x3 + 6 * x5 <= 399",
    "9 * x0 + 8 * x4 + 11 * x6 <= 141",
    "10 * x1 + 8 * x4 + 6 * x5 <= 282",
    "9 * x0 + 8 * x2 + 11 * x6 <= 144",
    "9 * x0 + 3 * x3 + 11 * x6 <= 412",
    "9 * x0 + 3 * x3 + 6 * x5 <= 81",
    "10 * x1 + 6 * x5 + 11 * x6 <= 302",
    "10 * x1 + 3 * x3 + 11 * x6 <= 92",
    "10 * x2 + 11 * x3 <= 373",
    "3 * x0 + 17 * x1 <= 415",
    "11 * x3 + 7 * x6 <= 147",
    "14 * x4 + 7 * x6 <= 541",
    "17 * x1 + 10 * x2 <= 149",
    "11 * x3 + 14 * x4 <= 514",
    "3 * x0 + 4 * x5 <= 346",
    "10 * x2 + 7 * x6 <= 106",
    "4 * x0 + 14 * x3 <= 53",
    "4 * x0 + 16 * x2 <= 144",
    "4 * x0 + 12 * x4 <= 42",
    "16 * x2 + 14 * x3 <= 152",
    "4 * x0 + 14 * x3 + 9 * x5 <= 185",
    "4 * x0 + 12 * x4 + 9 * x5 <= 121",
    "5 * x1 + 12 * x4 + 9 * x5 <= 179",
    "5 * x1 + 16 * x2 + 12 * x4 <= 93",
    "12 * x4 + 9 * x5 + 10 * x6 <= 204",
    "16 * x2 + 14 * x3 + 10 * x6 <= 122",
    "5 * x1 + 16 * x2 + 10 * x6 <= 115",
    "5 * x1 + 16 * x2 + 9 * x5 <= 208",
    "4 * x0 + 5 * x1 + 9 * x5 <= 153",
    "4 * x0 + 5 * x1 + 12 * x4 <= 79",
    "16 * x2 + 14 * x3 + 12 * x4 <= 40",
    "4 * x0 + 5 * x1 + 16 * x2 <= 151",
    "4 * x0 + 5 * x1 + 10 * x6 <= 87",
    "4 * x0 + 16 * x2 + 10 * x6 <= 129",
    "14 * x3 + 9 * x5 + 10 * x6 <= 197",
    "14 * x3 + 12 * x4 + 10 * x6 <= 107"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = {}
var_names = [
    "milligrams of vitamin B6",
    "milligrams of vitamin E",
    "milligrams of vitamin B9",
    "grams of fiber",
    "milligrams of iron",
    "milligrams of vitamin K",
    "milligrams of vitamin B5",
]
for i in range(len(var_names)):
    if var_names[i] == "milligrams of vitamin B9":
        x[i] = m.addVar(vtype=gp.GRB.INTEGER, name=var_names[i])
    else:
        x[i] = m.addVar(name=var_names[i])


# Set objective function
m.setObjective(
    9.43 * x[0]
    + 6.8 * x[1]
    + 9.05 * x[2]
    + 6.01 * x[3]
    + 4.84 * x[4]
    + 2.36 * x[5]
    + 7.56 * x[6],
    gp.GRB.MINIMIZE,
)

# Resource data
resources = {
    'r0': {'description': 'energy stability index', 'upper_bound': 518, 'x0': 9, 'x1': 10, 'x2': 8, 'x3': 3, 'x4': 8, 'x5': 6, 'x6': 11},
    'r1': {'description': 'immune support index', 'upper_bound': 588, 'x0': 3, 'x1': 17, 'x2': 10, 'x3': 11, 'x4': 14, 'x5': 4, 'x6': 7},
    'r2': {'description': 'cognitive performance index', 'upper_bound': 227, 'x0': 4, 'x1': 5, 'x2': 16, 'x3': 14, 'x4': 12, 'x5': 9, 'x6': 10}
}

# Add resource constraints
for r_key, r_data in resources.items():
    m.addConstr(gp.quicksum(r_data[f'x{i}'] * x[i] for i in range(7)) <= r_data['upper_bound'], name=r_data['description'] + '_upper_bound')


# Add other constraints from the problem description
constraints = [
    (9 * x[4] + 6 * x[5], ">=", 44),
    # ... (all other constraints)
]

for expr, sense, rhs in constraints:
    if sense == ">=":
        m.addConstr(expr >= rhs)
    elif sense == "<=":
        m.addConstr(expr <= rhs)
    elif sense == "=":
        m.addConstr(expr == rhs)

# Optimize model
m.optimize()

# Print results
if m.status == gp.GRB.OPTIMAL:
    print("Optimal solution found:")
    for i in range(len(var_names)):
        print(f"{var_names[i]}: {x[i].x}")
    print(f"Objective value: {m.objVal}")
elif m.status == gp.GRB.INFEASIBLE:
    print("Model is infeasible.")
else:
    print(f"Optimization terminated with status {m.status}")

```