```json
{
  "sym_variables": [
    ("x0", "grams of protein"),
    ("x1", "milligrams of vitamin B5"),
    ("x2", "grams of fat"),
    ("x3", "milligrams of vitamin B7"),
    ("x4", "milligrams of vitamin B4"),
    ("x5", "milligrams of vitamin E"),
    ("x6", "milligrams of vitamin C")
  ],
  "objective_function": "6.57*x0 + 1.58*x1 + 2.49*x2 + 7.78*x3 + 4.18*x4 + 4.85*x5 + 5.57*x6",
  "constraints": [
    "3*x3 + 4*x5 >= 27",
    "6*x3 + 11*x6 >= 13",
    "3*x0 + 11*x6 >= 23",
    "7*x4 + 4*x5 >= 15",
    "4*x5 + 11*x6 >= 23",
    "3*x0 + 7*x4 >= 20",
    "2*x2 + 11*x6 >= 25",
    "3*x0 + 6*x3 >= 9",
    "5*x1 + 4*x5 >= 18",
    "7*x4 + 11*x6 >= 14",
    "3*x0 + 4*x5 >= 26",
    "3*x0 + 7*x4 + 11*x6 >= 25",
    "2*x2 + 6*x3 + 7*x4 >= 25",
    "2*x2 + 6*x3 + 4*x5 >= 25",
    "2*x2 + 7*x4 + 11*x6 >= 25",
    "5*x1 + 6*x3 + 11*x6 >= 25",
    "5*x1 + 4*x5 + 11*x6 >= 25",
    "3*x0 + 2*x2 + 6*x3 >= 25",
    "3*x0 + 6*x3 + 4*x5 >= 25",
    "3*x0 + 5*x1 + 4*x5 >= 25",
    "6*x3 + 7*x4 + 11*x6 >= 25",
    "7*x4 + 4*x5 + 11*x6 >= 25",
    "2*x2 + 6*x3 + 11*x6 >= 25",
    "6*x3 + 4*x5 + 11*x6 >= 25",
    "3*x0 + 6*x3 + 11*x6 >= 25",
    "3*x0 + 2*x2 + 7*x4 >= 25",
    "5*x1 + 7*x4 + 11*x6 >= 25",
    "5*x1 + 6*x3 + 7*x4 >= 25",
    "2*x2 + 4*x5 + 11*x6 >= 25",
    "3*x0 + 5*x1 + 6*x3 >= 25",
    "3*x0 + 4*x5 + 11*x6 >= 25",
    "3*x0 + 5*x1 + 2*x2 >= 25",
    "3*x0 + 5*x1 + 11*x6 >= 25",
    "5*x1 + 2*x2 + 4*x5 >= 25",
    "5*x1 + 6*x3 + 4*x5 >= 25",
    "3*x0 + 6*x3 + 7*x4 >= 25",
    "5*x1 + 2*x2 + 11*x6 >= 25",
    "3*x0 + 7*x4 + 4*x5 >= 25",
    "2*x2 + 7*x4 + 4*x5 >= 25",
    "-1*x1 + x4 >= 0",
    "2*x2 + 11*x6 <= 29",
    "3*x0 + 6*x3 + 4*x5 <= 74",
    "3*x0 + 2*x2 + 4*x5 <= 45",
    "6*x3 + 7*x4 + 11*x6 <= 150",
    "5*x1 + 2*x2 + 11*x6 <= 167",
    "3*x0 + 6*x3 + 7*x4 <= 63",
    "2*x2 + 6*x3 + 4*x5 <= 147",
    "3*x0 + 7*x4 + 4*x5 <= 65",
    "2*x2 + 4*x5 + 11*x6 <= 41",
    "2*x2 + 6*x3 + 7*x4 <= 67",
    "5*x1 + 6*x3 + 7*x4 <= 129",
    "5*x1 + 6*x3 + 4*x5 <= 198",
    "5*x1 + 7*x4 + 4*x5 <= 170",
    "6*x3 + 7*x4 + 4*x5 <= 142",
    "3*x0 + 6*x3 + 11*x6 <= 67",
    "3*x0 + 5*x1 + 2*x2 + 6*x3 + 7*x4 + 4*x5 + 11*x6 >= 19",
    "5*x1 + 5*x2 >= 11",
    "8*x0 + 5*x2 >= 16",
    "8*x0 + 7*x6 >= 21",
    "4*x3 + 7*x6 >= 13",
    "5*x1 + 4*x3 >= 12",
    "5*x2 + 8*x4 >= 14",
    "5*x1 + 6*x5 >= 13",
    "8*x0 + 8*x4 + 7*x6 >= 18",
    "8*x0 + 5*x1 + 5*x2 >= 18",
    "5*x2 + 4*x3 + 6*x5 >= 18",
    "5*x2 + 8*x4 + 7*x6 >= 18",
    "5*x1 + 4*x3 + 6*x5 >= 18",
    "5*x1 + 4*x3 + 8*x4 >= 18",
    "5*x1 + 8*x4 + 7*x6 >= 18",
    "8*x0 + 4*x3 + 6*x5 >= 18",
    "8*x0 + 5*x1 + 8*x4 >= 18",
    "5*x1 + 4*x3 + 7*x6 >= 18",
    "8*x0 + 5*x1 + 7*x6 >= 18",
    "8*x0 + 6*x5 + 7*x6 >= 18",
    "4*x3 + 8*x4 + 7*x6 >= 18",
    "5*x2 + 8*x4 <= 172",
    "5*x1 + 4*x3 <= 62",
    "5*x1 + 7*x6 <= 138",
    "4*x3 + 6*x5 <= 177",
    "8*x0 + 7*x6 <= 140",
    "8*x0 + 6*x5 <= 163",
    "5*x2 + 4*x3 <= 71",
    "8*x0 + 8*x4 <= 152",
    "5*x1 + 5*x2 + 8*x4 <= 68",
    "5*x1 + 8*x4 + 7*x6 <= 58",
    "5*x1 + 5*x2 + 4*x3 <= 81",
    "8*x0 + 4*x3 + 6*x5 <= 50",
    "8*x0 + 5*x1 + 7*x6 <= 119",
    "8*x0 + 6*x5 + 7*x6 <= 36",
    "5*x2 + 4*x3 + 6*x5 <= 82"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
protein = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="protein")
vitamin_b5 = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_b5")
fat = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="fat")
vitamin_b7 = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="vitamin_b7")
vitamin_b4 = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_b4")
vitamin_e = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_e")
vitamin_c = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_c")


# Set objective function
m.setObjective(6.57 * protein + 1.58 * vitamin_b5 + 2.49 * fat + 7.78 * vitamin_b7 + 4.18 * vitamin_b4 + 4.85 * vitamin_e + 5.57 * vitamin_c, gp.GRB.MINIMIZE)

# Add cardiovascular support index constraints
cardiovascular_support = {
    'protein': 3,
    'vitamin_b5': 5,
    'fat': 2,
    'vitamin_b7': 6,
    'vitamin_b4': 7,
    'vitamin_e': 4,
    'vitamin_c': 11
}

muscle_growth = {
    'protein': 8,
    'vitamin_b5': 5,
    'fat': 5,
    'vitamin_b7': 4,
    'vitamin_b4': 8,
    'vitamin_e': 6,
    'vitamin_c': 7
}

resource_constraints = {
    'r0': {'upper_bound': 200, 'description': 'cardiovascular support index', **cardiovascular_support},
    'r1': {'upper_bound': 181, 'description': 'muscle growth index', **muscle_growth}
}


variables = {
    'protein': protein,
    'vitamin_b5': vitamin_b5,
    'fat': fat,
    'vitamin_b7': vitamin_b7,
    'vitamin_b4': vitamin_b4,
    'vitamin_e': vitamin_e,
    'vitamin_c': vitamin_c
}

# Generic constraint adder for single, double, and triple combinations
def add_constraint(m, resource, var_names, lower_bound=None, upper_bound=None):
    coefficients = [resource_constraints[resource][var_name] for var_name in var_names]
    variables_ = [variables[var_name] for var_name in var_names]
    expression = gp.LinExpr(coefficients, variables_)
    if lower_bound is not None:
        m.addConstr(expression >= lower_bound)
    if upper_bound is not None:
        m.addConstr(expression <= upper_bound)

# Add constraints from JSON (and other constraints from the problem description)
for constraint in json_data['constraints']:
    parts = constraint.split(" ")
    lower_bound = None
    upper_bound = None
    if ">=" in constraint:
        lower_bound = float(parts[-1])
    elif "<=" in constraint:
        upper_bound = float(parts[-1])
    var_names = []
    for i in range(0, len(parts) - 2, 2):
        var_names.append(json_data['sym_variables'][int(parts[i][1:])][1].replace("number of ", "").replace("amount of ", "").replace("quantity of ", "").strip())
    add_constraint(m, 'r0', var_names, lower_bound, upper_bound)

for constraint in json_data['constraints'][772:]:
    parts = constraint.split(" ")
    lower_bound = None
    upper_bound = None
    if ">=" in constraint:
        lower_bound = float(parts[-1])
    elif "<=" in constraint:
        upper_bound = float(parts[-1])
    var_names = []
    for i in range(0, len(parts) - 2, 2):
        var_names.append(json_data['sym_variables'][int(parts[i][1:])][1].replace("number of ", "").replace("amount of ", "").replace("quantity of ", "").strip())
    add_constraint(m, 'r1', var_names, lower_bound, upper_bound)


# Optimize model
m.optimize()

# Print results
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('Optimization was infeasible.')
else:
    print('Optimization ended with status %d' % m.status)
```