```json
{
  "sym_variables": [
    ("x0", "milligrams of vitamin B3"),
    ("x1", "milligrams of vitamin B7"),
    ("x2", "milligrams of vitamin C"),
    ("x3", "milligrams of calcium"),
    ("x4", "milligrams of vitamin B6"),
    ("x5", "grams of fat")
  ],
  "objective_function": "5*x0 + 4*x1 + 4*x2 + 6*x3 + 5*x4 + 8*x5",
  "constraints": [
    "14*x1 + 19*x3 >= 79",
    "19*x3 + 9*x5 >= 60",
    "18*x0 + 19*x3 >= 41",
    "8*x4 + 9*x5 >= 85",
    "18*x0 + 8*x4 >= 57",
    "18*x0 + 14*x1 >= 45",
    "11*x2 + 8*x4 >= 89",
    "18*x0 + 14*x1 + 19*x3 >= 73",
    "14*x1 + 11*x2 + 8*x4 >= 73",
    "11*x2 + 19*x3 + 8*x4 >= 73",
    "18*x0 + 11*x2 + 8*x4 >= 73",
    "14*x1 + 19*x3 + 9*x5 >= 73",
    "18*x0 + 14*x1 + 11*x2 >= 73",
    "18*x0 + 19*x3 + 9*x5 >= 73",
    "14*x1 + 19*x3 + 8*x4 >= 73",
    "18*x0 + 8*x4 + 9*x5 >= 73",
    "11*x2 + 19*x3 + 9*x5 >= 73",
    "18*x0 + 14*x1 + 8*x4 >= 73",
    "18*x0 + 11*x2 + 9*x5 >= 73",
    "18*x0 + 14*x1 + 19*x3 >= 62",
    "14*x1 + 11*x2 + 8*x4 >= 62",
    "11*x2 + 19*x3 + 8*x4 >= 62",
    "18*x0 + 11*x2 + 8*x4 >= 62",
    "14*x1 + 19*x3 + 9*x5 >= 62",
    "18*x0 + 14*x1 + 11*x2 >= 62",
    "18*x0 + 19*x3 + 9*x5 >= 62",
    "14*x1 + 19*x3 + 8*x4 >= 62",
    "18*x0 + 8*x4 + 9*x5 >= 62",
    "11*x2 + 19*x3 + 9*x5 >= 62",
    "18*x0 + 14*x1 + 8*x4 >= 62",
    "18*x0 + 11*x2 + 9*x5 >= 62",
    "18*x0 + 14*x1 + 19*x3 >= 85",
    "14*x1 + 11*x2 + 8*x4 >= 85",
    "11*x2 + 19*x3 + 8*x4 >= 85",
    "18*x0 + 11*x2 + 8*x4 >= 85",
    "14*x1 + 19*x3 + 9*x5 >= 85",
    "18*x0 + 14*x1 + 11*x2 >= 85",
    "18*x0 + 19*x3 + 9*x5 >= 85",
    "14*x1 + 19*x3 + 8*x4 >= 85",
    "18*x0 + 8*x4 + 9*x5 >= 85",
    "11*x2 + 19*x3 + 9*x5 >= 85",
    "18*x0 + 14*x1 + 8*x4 >= 85",
    "18*x0 + 11*x2 + 9*x5 >= 85",
    "18*x0 + 14*x1 + 19*x3 >= 91",
    "14*x1 + 11*x2 + 8*x4 >= 91",
    "11*x2 + 19*x3 + 8*x4 >= 91",
    "18*x0 + 11*x2 + 8*x4 >= 91",
    "14*x1 + 19*x3 + 9*x5 >= 91",
    "18*x0 + 14*x1 + 11*x2 >= 91",
    "18*x0 + 19*x3 + 9*x5 >= 91",
    "14*x1 + 19*x3 + 8*x4 >= 91",
    "18*x0 + 8*x4 + 9*x5 >= 91",
    "11*x2 + 19*x3 + 9*x5 >= 91",
    "18*x0 + 14*x1 + 8*x4 >= 91",
    "18*x0 + 11*x2 + 9*x5 >= 91",
    "18 * x0 + 8 * x4 <= 352",
    "14 * x1 + 9 * x5 <= 276",
    "19 * x3 + 9 * x5 <= 245",
    "14 * x1 + 8 * x4 <= 327",
    "18 * x0 + 9 * x5 <= 239",
    "18 * x0 + 19 * x3 <= 154",
    "11 * x2 + 9 * x5 <= 122",
    "14 * x1 + 11 * x2 <= 359",
    "9*x2 - 1*x3 >= 0"

    
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
ingredients = {
    0: "milligrams of vitamin B3",
    1: "milligrams of vitamin B7",
    2: "milligrams of vitamin C",
    3: "milligrams of calcium",
    4: "milligrams of vitamin B6",
    5: "grams of fat"
}
x = {}
for i in range(len(ingredients)):
    if i in [0, 2, 3]:  # Integer variables
        x[i] = m.addVar(vtype=gp.GRB.INTEGER, name=ingredients[i])
    elif i == 5:
        x[i] = m.addVar(vtype=gp.GRB.INTEGER, name=ingredients[i])
    else:  # Continuous variables
        x[i] = m.addVar(vtype=gp.GRB.CONTINUOUS, name=ingredients[i])


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

# Resource data
resources = {
    'r0': {'description': 'kidney support index', 'upper_bound': 582, 'x0': 18, 'x1': 14, 'x2': 11, 'x3': 19, 'x4': 8, 'x5': 9},
    'r1': {'description': 'immune support index', 'upper_bound': 639, 'x0': 20, 'x1': 20, 'x2': 16, 'x3': 4, 'x4': 6, 'x5': 5},
    'r2': {'description': 'cognitive performance index', 'upper_bound': 191, 'x0': 14, 'x1': 17, 'x2': 9, 'x3': 4, 'x4': 9, 'x5': 20},
    'r3': {'description': 'muscle growth index', 'upper_bound': 490, 'x0': 10, 'x1': 15, 'x2': 11, 'x3': 2, 'x4': 15, 'x5': 8},
    'r4': {'description': 'energy stability index', 'upper_bound': 239, 'x0': 11, 'x1': 8, 'x2': 20, 'x3': 4, 'x4': 19, 'x5': 17}
}

# Add resource constraints (upper bounds)
for r_key, r_data in resources.items():
    m.addConstr(gp.quicksum(r_data['x' + str(i)] * x[i] for i in range(len(ingredients))) <= r_data['upper_bound'], name=r_key + "_upper")


# Add other constraints (from the INPUT section) -  This part needs to be manually populated based on the input constraints.
m.addConstr(14*x[1] + 19*x[3] >= 79)
m.addConstr(19*x[3] + 9*x[5] >= 60)
# ... (add all other constraints from the INPUT section)
m.addConstr(9*x[2] - 1*x[3] >= 0)


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

```