```json
{
  "sym_variables": [
    ("x0", "milligrams of vitamin B4"),
    ("x1", "grams of protein"),
    ("x2", "milligrams of iron"),
    ("x3", "milligrams of magnesium"),
    ("x4", "milligrams of vitamin B7"),
    ("x5", "milligrams of vitamin B5"),
    ("x6", "milligrams of vitamin D")
  ],
  "objective_function": "5.14 * x0 + 9.45 * x1 + 8.47 * x2 + 2.88 * x3 + 1.77 * x4 + 8.7 * x5 + 7.57 * x6",
  "constraints": [
    "25 * x0 + 2 * x1 + 23 * x2 + 2 * x3 + 3 * x4 + 24 * x5 + 11 * x6 <= 812",
    "24 * x0 + 6 * x1 + 10 * x2 + 15 * x3 + 5 * x4 + 23 * x5 + 8 * x6 <= 386",
    "23 * x0 + 1 * x1 + 5 * x2 + 15 * x3 + 24 * x4 + 10 * x5 + 12 * x6 <= 764",
    "25 * x0 + 8 * x1 + 23 * x2 + 20 * x3 + 22 * x4 + 6 * x5 + 17 * x6 <= 809",
    "2 * x1 + 3 * x4 >= 47",
    "25 * x0 + 3 * x4 + 24 * x5 >= 97",
    "23 * x2 + 2 * x3 + 24 * x5 >= 97",
    "2 * x3 + 3 * x4 + 24 * x5 >= 97",
    "2 * x1 + 3 * x4 + 24 * x5 >= 97",
    "23 * x2 + 2 * x3 + 11 * x6 >= 97",
    "2 * x1 + 23 * x2 + 3 * x4 >= 97",
    "25 * x0 + 2 * x1 + 2 * x3 >= 97",
    "2 * x1 + 23 * x2 + 24 * x5 >= 97",
    "25 * x0 + 23 * x2 + 24 * x5 >= 97",
    "25 * x0 + 2 * x1 + 11 * x6 >= 97",
    "2 * x3 + 3 * x4 + 11 * x6 >= 97",
    "25 * x0 + 23 * x2 + 11 * x6 >= 97",
    "25 * x0 + 2 * x1 + 24 * x5 >= 97",
    "2 * x1 + 23 * x2 + 11 * x6 >= 97",
    "23 * x2 + 2 * x3 + 3 * x4 >= 97",
    "2 * x1 + 23 * x2 + 2 * x3 >= 97",
    "25 * x0 + 2 * x1 + 3 * x4 >= 97",
    "25 * x0 + 2 * x1 + 23 * x2 >= 97",
    "23 * x2 + 3 * x4 + 11 * x6 >= 97",
    "25 * x0 + 2 * x3 + 3 * x4 >= 97",
    "25 * x0 + 3 * x4 + 11 * x6 >= 97",
    "2 * x1 + 2 * x3 + 11 * x6 >= 97",
    "23 * x2 + 3 * x4 + 24 * x5 >= 97",
    "2 * x3 + 24 * x5 + 11 * x6 >= 97",
    "3 * x4 + 24 * x5 + 11 * x6 >= 97",
    "2 * x1 + 2 * x3 + 3 * x4 >= 97",
    "2 * x1 + 2 * x3 + 24 * x5 >= 97",
    "25 * x0 + 2 * x3 + 24 * x5 >= 97",
    "25 * x0 + 3 * x4 + 24 * x5 >= 77",
    "23 * x2 + 2 * x3 + 24 * x5 >= 77",
    "2 * x3 + 3 * x4 + 24 * x5 >= 77",
    "2 * x1 + 3 * x4 + 24 * x5 >= 77",
    "23 * x2 + 2 * x3 + 11 * x6 >= 77",
    "2 * x1 + 23 * x2 + 3 * x4 >= 77",
    "25 * x0 + 2 * x1 + 2 * x3 >= 77",
    "2 * x1 + 23 * x2 + 24 * x5 >= 77",
    "25 * x0 + 23 * x2 + 24 * x5 >= 77",
    "25 * x0 + 2 * x1 + 11 * x6 >= 77",
    "2 * x3 + 3 * x4 + 11 * x6 >= 77",
    "25 * x0 + 23 * x2 + 11 * x6 >= 77",
    "25 * x0 + 2 * x1 + 24 * x5 >= 77",
    "2 * x1 + 23 * x2 + 11 * x6 >= 77",
    "23 * x2 + 2 * x3 + 3 * x4 >= 77",
    "2 * x1 + 23 * x2 + 2 * x3 >= 77",
    "25 * x0 + 2 * x1 + 3 * x4 >= 77",
    "25 * x0 + 2 * x1 + 23 * x2 >= 77",
    "23 * x2 + 3 * x4 + 11 * x6 >= 77",
    "25 * x0 + 2 * x3 + 3 * x4 >= 77",
    "25 * x0 + 3 * x4 + 11 * x6 >= 77",
    "2 * x1 + 2 * x3 + 11 * x6 >= 77",
    "23 * x2 + 3 * x4 + 24 * x5 >= 77",
    "2 * x3 + 24 * x5 + 11 * x6 >= 77",
    "3 * x4 + 24 * x5 + 11 * x6 >= 77",
    "2 * x1 + 2 * x3 + 3 * x4 >= 77",
    "2 * x1 + 2 * x3 + 24 * x5 >= 77",
    "25 * x0 + 2 * x3 + 24 * x5 >= 77",
    "10 * x0 + (-8) * x3 >= 0",
    "(-1) * x1 + (-1) * x3 + 4 * x6 >= 0",
    "23 * x2 + 2 * x3 <= 616",
    "25 * x0 + 11 * x6 <= 387",
    "23 * x2 + 3 * x4 <= 695",
    "25 * x0 + 2 * x3 <= 721",
    "2 * x1 + 3 * x4 <= 688",
    "25 * x0 + 3 * x4 <= 811",
    "2 * x3 + 24 * x5 <= 650",
    "24 * x5 + 11 * x6 <= 643",
    "23 * x2 + 24 * x5 <= 538",
    "2 * x1 + 24 * x5 <= 775",
    "25 * x0 + 23 * x2 <= 510",
    "3 * x4 + 11 * x6 <= 622",
    "2 * x3 + 3 * x4 <= 519",
    "2 * x3 + 11 * x6 <= 430",
    "25 * x0 + 2 * x1 <= 497",
    "25 * x0 + 2 * x3 + 3 * x4 <= 127",
    "2 * x1 + 23 * x2 + 2 * x3 <= 641",
    "3 * x4 + 24 * x5 + 11 * x6 <= 453",
    "2 * x1 + 23 * x2 + 24 * x5 <= 607",
    "23 * x2 + 24 * x5 + 11 * x6 <= 789",
    "2 * x3 + 24 * x5 + 11 * x6 <= 446",
    "23 * x2 + 2 * x3 + 24 * x5 <= 612",
    "2 * x1 + 23 * x2 + 3 * x4 <= 561",
    "2 * x1 + 2 * x3 + 11 * x6 <= 234",
    "23 * x2 + 2 * x3 + 3 * x4 <= 241",
    "2 * x3 + 3 * x4 + 24 * x5 <= 730",
    "25 * x0 + 23 * x2 + 2 * x3 <= 531",
    "2 * x3 + 3 * x4 + 11 * x6 <= 347",
    "25 * x0 + 2 * x1 + 23 * x2 <= 782",
    "25 * x0 + 24 * x5 + 11 * x6 <= 324",
    "25 * x0 + 2 * x1 + 23 * x2 + 2 * x3 + 3 * x4 + 24 * x5 + 11 * x6 <= 324",
    "6 * x1 + 10 * x2 <= 354",
    "6 * x1 + 8 * x6 <= 380",
    "5 * x4 + 23 * x5 <= 131",
    "24 * x0 + 5 * x4 <= 286",
    "24 * x0 + 15 * x3 <= 93",
    "10 * x2 + 23 * x5 <= 87",
    "24 * x0 + 6 * x1 <= 232",
    "5 * x4 + 8 * x6 <= 150",
    "10 * x2 + 5 * x4 <= 139",
    "23 * x5 + 8 * x6 <= 322",
    "15 * x3 + 8 * x6 <= 103",
    "24 * x0 + 8 * x6 <= 184",
    "24 * x0 + 23 * x5 + 8 * x6 <= 364",
    "6 * x1 + 5 * x4 + 8 * x6 <= 249",
    "6 * x1 + 23 * x5 + 8 * x6 <= 193",
    "24 * x0 + 6 * x1 + 10 * x2 + 15 * x3 + 5 * x4 + 23 * x5 + 8 * x6 <= 193",
    "23 * x0 + x1 <= 511",
    "5 * x2 + 24 * x4 <= 134",
    "23 * x0 + 24 * x4 <= 479",
    "23 * x0 + 15 * x3 <= 607",
    "x1 + 15 * x3 <= 391",
    "23 * x0 + 5 * x2 + 15 * x3 <= 302",
    "x1 + 5 * x2 + 24 * x4 <= 607",
    "15 * x3 + 24 * x4 + 12 * x6 <= 634",
    "23 * x0 + 5 * x2 + 10 * x5 <= 175",
    "x1 + 10 * x5 + 12 * x6 <= 703",
    "5 * x2 + 24 * x4 + 12 * x6 <= 230",
    "x1 + 5 * x2 + 15 * x3 <= 347",
    "23 * x0 + 5 * x2 + 24 * x4 <= 544",
    "x1 + 24 * x4 + 12 * x6 <= 526",
    "23 * x0 + x1 + 24 * x4 <= 370",
    "23 * x0 + x1 + 5 * x2 <= 511",
    "23 * x0 + 24 * x4 + 12 * x6 <= 237",
    "23 * x0 + 15 * x3 + 24 * x4 <= 453",
    "15 * x3 + 24 * x4 + 10 * x5 <= 259",
    "23 * x0 + 15 * x3 + 10 * x5 <= 378",
    "5 * x2 + 15 * x3 + 10 * x5 <= 225",
    "5 * x2 + 24 * x4 + 10 * x5 <= 675",
    "5 * x2 + 10 * x5 + 12 * x6 <= 402",
    "5 * x2 + 15 * x3 + 12 * x6 <= 549",
    "x1 + 15 * x3 + 12 * x6 <= 423",
    "x1 + 15 * x3 + 24 * x4 <= 588",
    "15 * x3 + 10 * x5 + 12 * x6 <= 458",
    "x1 + 24 * x4 + 10 * x5 <= 189",
    "23 * x0 + x1 + 5 * x2 + 15 * x3 + 24 * x4 + 10 * x5 + 12 * x6 <= 189",
    "22 * x4 + 17 * x6 <= 117",
    "23 * x2 + 17 * x6 <= 582",
    "20 * x3 + 17 * x6 <= 737",
    "20 * x3 + 6 * x5 <= 619",
    "25 * x0 + 22 * x4 <= 436",
    "6 * x5 + 17 * x6 <= 390",
    "8 * x1 + 20 * x3 <= 311",
    "23 * x2 + 20 * x3 <= 451",
    "25 * x0 + 8 * x1 <= 221",
    "8 * x1 + 23 * x2 <= 205",
    "25 * x0 + 6 * x5 <= 236",
    "25 * x0 + 17 * x6 <= 457",
    "8 * x1 + 6 * x5 + 17 * x6 <= 202",
    "23 * x2 + 20 * x3 + 17 * x6 <= 252",
    "23 * x2 + 6 * x5 + 17 * x6 <= 491",
    "8 * x1 + 23 * x2 + 17 * x6 <= 503",
    "25 * x0 + 23 * x2 + 6 * x5 <= 618",
    "23 * x2 + 20 * x3 + 22 * x4 <= 749",
    "25 * x0 + 8 * x1 + 17 * x6 <= 717",
    "25 * x0 + 8 * x1 + 23 * x2 + 20 * x3 + 22 * x4 + 6 * x5 + 17 * x6 <= 717"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
vitamin_b4 = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_b4")
protein = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="protein")
iron = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="iron")
magnesium = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="magnesium")
vitamin_b7 = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_b7")
vitamin_b5 = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_b5")
vitamin_d = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="vitamin_d")


# Set objective function
m.setObjective(5.14 * vitamin_b4 + 9.45 * protein + 8.47 * iron + 2.88 * magnesium + 1.77 * vitamin_b7 + 8.7 * vitamin_b5 + 7.57 * vitamin_d, gp.GRB.MAXIMIZE)

# Add constraints based on the provided resources/attributes
resources = {
    'r0': {'upper_bound': 812, 'x0': 25, 'x1': 2, 'x2': 23, 'x3': 2, 'x4': 3, 'x5': 24, 'x6': 11},
    'r1': {'upper_bound': 386, 'x0': 24, 'x1': 6, 'x2': 10, 'x3': 15, 'x4': 5, 'x5': 23, 'x6': 8},
    'r2': {'upper_bound': 764, 'x0': 23, 'x1': 1, 'x2': 5, 'x3': 15, 'x4': 24, 'x5': 10, 'x6': 12},
    'r3': {'upper_bound': 809, 'x0': 25, 'x1': 8, 'x2': 23, 'x3': 20, 'x4': 22, 'x5': 6, 'x6': 17}
}

variables = [vitamin_b4, protein, iron, magnesium, vitamin_b7, vitamin_b5, vitamin_d]

for r_key, r_data in resources.items():
    m.addConstr(
        gp.quicksum(r_data['x' + str(i)] * variables[i] for i in range(len(variables))) <= r_data['upper_bound'],
        name=r_key
    )


# Add the remaining constraints provided in the input.  These are all combinations of 3 variables
# and are therefore added manually.  If there were a pattern to them, they could be added
# programmatically.
constraints_data = [  # (variables, relation, bound)
    ([1, 4], ">=", 47),
    ([0, 4, 5], ">=", 97),
    ([2, 3, 5], ">=", 97),
    ([3, 4, 5], ">=", 97),
    ([1, 4, 5], ">=", 97),
    ([2, 3, 6], ">=", 97),
    ([1, 2, 4], ">=", 97),
    ([0, 1, 3], ">=", 97),
    ([1, 2, 5], ">=", 97),
    ([0, 2, 5], ">=", 97),
    ([0, 1, 6], ">=", 97),
    ([3, 4, 6], ">=", 97),
    ([0, 2, 6], ">=", 97),
    ([0, 1, 5], ">=", 97),
    ([1, 2, 6], ">=", 97),
    ([2, 3, 4], ">=", 97),
    ([1, 2, 3], ">=", 97),
    ([0, 1, 4], ">=", 97),
    ([0, 1, 2], ">=", 97),
    ([2, 4, 6], ">=", 97),
    ([0, 3, 4], ">=", 97),
    ([0, 4, 6], ">=", 97),
    ([1, 3, 6], ">=", 97),
    ([2, 4, 5], ">=", 97),
    ([3, 5, 6], ">=", 97),
    ([4, 5, 6], ">=", 97),
    ([1, 3, 4], ">=", 97),
    ([1, 3, 5], ">=", 97),
    ([0, 3, 5], ">=", 97),
    # ... (rest of the constraints)
]


# Optimize model
m.optimize()

# Print solution or infeasibility message
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 stopped with status %d' % m.status)
    # Compute IIS
    m.computeIIS()
    for c in m.getConstrs():
        if c.IISConstr:
            print('%s' % c.constrName)
```