```json
{
  "sym_variables": [
    ("x0", "pen testers"),
    ("x1", "honeypots"),
    ("x2", "system administrators"),
    ("x3", "patches per day"),
    ("x4", "automatic alerts"),
    ("x5", "SOC operators"),
    ("x6", "security onions")
  ],
  "objective_function": "3*x0 + 7*x1 + 3*x2 + 7*x3 + 4*x4 + 1*x5 + 1*x6",
  "constraints": [
    "3*x0 + 7*x1 + 18*x2 + 16*x3 + 4*x4 + 11*x5 + 14*x6 <= 225",
    "3*x0 + 16*x3 + 14*x6 >= 20",
    "7*x1 + 18*x2 + 11*x5 >= 20",
    "7*x1 + 16*x3 + 4*x4 >= 20",
    "3*x0 + 18*x2 + 4*x4 >= 20",
    "3*x0 + 4*x4 + 11*x5 >= 20",
    "16*x3 + 4*x4 + 11*x5 >= 20",
    "16*x3 + 11*x5 + 14*x6 >= 20",
    "7*x1 + 18*x2 + 14*x6 >= 20",
    "3*x0 + 7*x1 + 18*x2 >= 20",
    "18*x2 + 16*x3 + 14*x6 >= 20",
    "3*x0 + 18*x2 + 14*x6 >= 20",
    "3*x0 + 11*x5 + 14*x6 >= 20",
    "3*x0 + 16*x3 + 14*x6 >= 23",
    "7*x1 + 18*x2 + 11*x5 >= 23",
    "7*x1 + 16*x3 + 4*x4 >= 23",
    "3*x0 + 18*x2 + 4*x4 >= 23",
    "3*x0 + 4*x4 + 11*x5 >= 23",
    "16*x3 + 4*x4 + 11*x5 >= 23",
    "16*x3 + 11*x5 + 14*x6 >= 23",
    "7*x1 + 18*x2 + 14*x6 >= 23",
    "3*x0 + 7*x1 + 18*x2 >= 23",
    "18*x2 + 16*x3 + 14*x6 >= 23",
    "3*x0 + 18*x2 + 14*x6 >= 23",
    "3*x0 + 11*x5 + 14*x6 >= 23",
    "3*x0 + 16*x3 + 14*x6 >= 28",
    "7*x1 + 18*x2 + 11*x5 >= 28",
    "7*x1 + 16*x3 + 4*x4 >= 28",
    "3*x0 + 18*x2 + 4*x4 >= 28",
    "3*x0 + 4*x4 + 11*x5 >= 28",
    "16*x3 + 4*x4 + 11*x5 >= 28",
    "16*x3 + 11*x5 + 14*x6 >= 28",
    "7*x1 + 18*x2 + 14*x6 >= 28",
    "3*x0 + 7*x1 + 18*x2 >= 28",
    "18*x2 + 16*x3 + 14*x6 >= 28",
    "3*x0 + 18*x2 + 14*x6 >= 28",
    "3*x0 + 11*x5 + 14*x6 >= 28",
    "3*x0 + 16*x3 + 14*x6 >= 32",
    "7*x1 + 18*x2 + 11*x5 >= 32",
    "7*x1 + 16*x3 + 4*x4 >= 32",
    "3*x0 + 18*x2 + 4*x4 >= 32",
    "3*x0 + 4*x4 + 11*x5 >= 32",
    "16*x3 + 4*x4 + 11*x5 >= 32",
    "16*x3 + 11*x5 + 14*x6 >= 32",
    "7*x1 + 18*x2 + 14*x6 >= 32",
    "3*x0 + 7*x1 + 18*x2 >= 32",
    "18*x2 + 16*x3 + 14*x6 >= 32",
    "3*x0 + 18*x2 + 14*x6 >= 32",
    "3*x0 + 11*x5 + 14*x6 >= 32",
    "3*x0 + 16*x3 + 14*x6 >= 30",
    "7*x1 + 18*x2 + 11*x5 >= 30",
    "7*x1 + 16*x3 + 4*x4 >= 30",
    "3*x0 + 18*x2 + 4*x4 >= 30",
    "3*x0 + 4*x4 + 11*x5 >= 30",
    "16*x3 + 4*x4 + 11*x5 >= 30",
    "16*x3 + 11*x5 + 14*x6 >= 30",
    "7*x1 + 18*x2 + 14*x6 >= 30",
    "3*x0 + 7*x1 + 18*x2 >= 30",
    "18*x2 + 16*x3 + 14*x6 >= 30",
    "3*x0 + 18*x2 + 14*x6 >= 30",
    "3*x0 + 11*x5 + 14*x6 >= 30",
    "3*x0 + 16*x3 + 14*x6 >= 19",
    "7*x1 + 18*x2 + 11*x5 >= 19",
    "7*x1 + 16*x3 + 4*x4 >= 19",
    "3*x0 + 18*x2 + 4*x4 >= 19",
    "3*x0 + 4*x4 + 11*x5 >= 19",
    "16*x3 + 4*x4 + 11*x5 >= 19",
    "16*x3 + 11*x5 + 14*x6 >= 19",
    "7*x1 + 18*x2 + 14*x6 >= 19",
    "3*x0 + 7*x1 + 18*x2 >= 19",
    "18*x2 + 16*x3 + 14*x6 >= 19",
    "3*x0 + 18*x2 + 14*x6 >= 19",
    "3*x0 + 11*x5 + 14*x6 >= 19",
    "3*x0 + 16*x3 + 14*x6 >= 17",
    "7*x1 + 18*x2 + 11*x5 >= 17",
    "7*x1 + 16*x3 + 4*x4 >= 17",
    "3*x0 + 18*x2 + 4*x4 >= 17",
    "3*x0 + 4*x4 + 11*x5 >= 17",
    "16*x3 + 4*x4 + 11*x5 >= 17",
    "16*x3 + 11*x5 + 14*x6 >= 17",
    "7*x1 + 18*x2 + 14*x6 >= 17",
    "3*x0 + 7*x1 + 18*x2 >= 17",
    "18*x2 + 16*x3 + 14*x6 >= 17",
    "3*x0 + 18*x2 + 14*x6 >= 17",
    "3*x0 + 11*x5 + 14*x6 >= 17",
    "3*x0 + 16*x3 + 14*x6 >= 27",
    "7*x1 + 18*x2 + 11*x5 >= 27",
    "7*x1 + 16*x3 + 4*x4 >= 27",
    "3*x0 + 18*x2 + 4*x4 >= 27",
    "3*x0 + 4*x4 + 11*x5 >= 27",
    "16*x3 + 4*x4 + 11*x5 >= 27",
    "16*x3 + 11*x5 + 14*x6 >= 27",
    "7*x1 + 18*x2 + 14*x6 >= 27",
    "3*x0 + 7*x1 + 18*x2 >= 27",
    "18*x2 + 16*x3 + 14*x6 >= 27",
    "3*x0 + 18*x2 + 14*x6 >= 27",
    "3*x0 + 11*x5 + 14*x6 >= 27",
    "3*x0 + 16*x3 + 14*x6 >= 22",
    "7*x1 + 18*x2 + 11*x5 >= 22",
    "7*x1 + 16*x3 + 4*x4 >= 22",
    "3*x0 + 18*x2 + 4*x4 >= 22",
    "3*x0 + 4*x4 + 11*x5 >= 22",
    "16*x3 + 4*x4 + 11*x5 >= 22",
    "16*x3 + 11*x5 + 14*x6 >= 22",
    "7*x1 + 18*x2 + 14*x6 >= 22",
    "3*x0 + 7*x1 + 18*x2 >= 22",
    "18*x2 + 16*x3 + 14*x6 >= 22",
    "3*x0 + 18*x2 + 14*x6 >= 22",
    "3*x0 + 11*x5 + 14*x6 >= 22",
    "16*x3 + 14*x6 <= 86",
    "7*x1 + 11*x5 <= 78",
    "7*x1 + 14*x6 <= 198",
    "4*x4 + 11*x5 <= 199",
    "3*x0 + 16*x3 <= 176",
    "3*x0 + 18*x2 <= 140",
    "18*x2 + 4*x4 <= 188",
    "7*x1 + 18*x2 <= 195",
    "18*x2 + 16*x3 + 4*x4 <= 62",
    "3*x0 + 18*x2 + 11*x5 <= 97",
    "3*x0 + 16*x3 + 14*x6 <= 168",
    "3*x0 + 11*x5 + 14*x6 <= 55",
    "18*x2 + 11*x5 + 14*x6 <= 101",
    "16*x3 + 4*x4 + 11*x5 <= 82",
    "3*x0 + 7*x1 + 18*x2 + 16*x3 + 4*x4 + 11*x5 + 14*x6 <= 82"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = m.addVars(7, names=['pen testers', 'honeypots', 'system administrators', 'patches per day', 'automatic alerts', 'SOC operators', 'security onions'], type=gp.GRB.INTEGER)


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

# Add constraints
m.addConstr(3*x[0] + 7*x[1] + 18*x[2] + 16*x[3] + 4*x[4] + 11*x[5] + 14*x[6] <= 225, "r0")

impact_values = [3, 7, 18, 16, 4, 11, 14]
constraint_combinations = [
    ([0, 3, 6], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([1, 2, 5], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([1, 3, 4], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([0, 2, 4], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([0, 4, 5], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([3, 4, 5], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([3, 5, 6], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([1, 2, 6], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([0, 1, 2], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([2, 3, 6], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([0, 2, 6], [20, 23, 28, 32, 30, 19, 17, 27, 22]),
    ([0, 5, 6], [20, 23, 28, 32, 30, 19, 17, 27, 22])
]

for combination, bounds in constraint_combinations:
    for bound in bounds:
        constraint = gp.LinExpr()
        for var_index in combination:
            constraint += impact_values[var_index] * x[var_index]
        m.addConstr(constraint >= bound)

m.addConstr(16*x[3] + 14*x[6] <= 86)
m.addConstr(7*x[1] + 11*x[5] <= 78)
m.addConstr(7*x[1] + 14*x[6] <= 198)
m.addConstr(4*x[4] + 11*x[5] <= 199)
m.addConstr(3*x[0] + 16*x[3] <= 176)
m.addConstr(3*x[0] + 18*x[2] <= 140)
m.addConstr(18*x[2] + 4*x[4] <= 188)
m.addConstr(7*x[1] + 18*x[2] <= 195)
m.addConstr(18*x[2] + 16*x[3] + 4*x[4] <= 62)
m.addConstr(3*x[0] + 18*x[2] + 11*x[5] <= 97)
m.addConstr(3*x[0] + 16*x[3] + 14*x[6] <= 168)
m.addConstr(3*x[0] + 11*x[5] + 14*x[6] <= 55)
m.addConstr(18*x[2] + 11*x[5] + 14*x[6] <= 101)
m.addConstr(16*x[3] + 4*x[4] + 11*x[5] <= 82)
m.addConstr(3*x[0] + 7*x[1] + 18*x[2] + 16*x[3] + 4*x[4] + 11*x[5] + 14*x[6] <= 82)


# Optimize model
m.optimize()

# Print solution
if m.status == gp.GRB.OPTIMAL:
    for v in m.getVars():
        print(f'{v.varName}: {v.x}')
    print(f'Obj: {m.objVal}')
elif m.status == gp.GRB.INFEASIBLE:
    print("Model is infeasible")
else:
    print(f"Optimization ended with status {m.status}")

```
