```json
{
  "sym_variables": [
    ("x0", "honeypots"),
    ("x1", "security engineers"),
    ("x2", "patches per day"),
    ("x3", "Mbps bandwidth allocated to monitoring"),
    ("x4", "system administrators"),
    ("x5", "security onions"),
    ("x6", "deployed decoys")
  ],
  "objective_function": "7*x0 + 6*x1 + 7*x2 + 1*x3 + 9*x4 + 6*x5 + 9*x6",
  "constraints": [
    "12*x0 + 12*x1 + 21*x2 + 10*x3 + 7*x4 + 4*x5 + 23*x6 <= 1179",
    "29*x0 + 7*x1 + 12*x2 + 5*x3 + 16*x4 + 14*x5 + 8*x6 <= 1006",
    "22*x0 + 20*x1 + 11*x2 + 26*x3 + 8*x4 + 27*x5 + 24*x6 <= 1173",
    "28*x0 + 17*x1 + 11*x2 + 15*x3 + 18*x4 + 2*x5 + 14*x6 <= 877",
    "21*x2 + 23*x6 >= 89",
    "12*x1 + 23*x6 >= 155",
    "7*x4 + 4*x5 >= 144",
    "10*x3 + 4*x5 >= 161",
    "10*x3 + 23*x6 >= 114",
    "12*x1 + 10*x3 >= 87",
    "21*x2 + 4*x5 >= 155",
    "12*x0 + 4*x5 >= 114",
    "21*x2 + 10*x3 >= 75",
    "4*x5 + 23*x6 >= 114",
    "7*x4 + 4*x5 + 23*x6 >= 124",
    "12*x1 + 21*x2 + 10*x3 >= 124",
    "12*x0 + 7*x4 + 23*x6 >= 124",
    "12*x0 + 21*x2 + 23*x6 >= 124",
    "12*x1 + 21*x2 + 23*x6 >= 124",
    "21*x2 + 10*x3 + 23*x6 >= 124",
    "12*x1 + 7*x4 + 23*x6 >= 124",
    "12*x0 + 10*x3 + 7*x4 >= 124",
    "12*x0 + 12*x1 + 7*x4 >= 124",
    "12*x0 + 12*x1 + 10*x3 >= 124",
    "12*x1 + 21*x2 + 4*x5 >= 124",
    "21*x2 + 7*x4 + 23*x6 >= 124",
    "21*x2 + 4*x5 + 23*x6 >= 124",
    "10*x3 + 7*x4 + 4*x5 >= 124",
    "12*x0 + 21*x2 + 4*x5 >= 124",
    "12*x0 + 12*x1 + 4*x5 >= 124",
    "12*x0 + 10*x3 + 23*x6 >= 124",
    "12*x0 + 4*x5 + 23*x6 >= 124",
    "12*x0 + 12*x1 + 23*x6 >= 124",
    "12*x1 + 10*x3 + 4*x5 >= 124",
    "12*x0 + 21*x2 + 7*x4 >= 124",
    "12*x1 + 10*x3 + 7*x4 >= 124",
    "12*x1 + 10*x3 + 23*x6 >= 124",
    "7*x4 + 4*x5 + 23*x6 >= 89",  
    "12*x1 + 21*x2 + 10*x3 >= 89",
    "12*x0 + 7*x4 + 23*x6 >= 89",
    "12*x0 + 21*x2 + 23*x6 >= 89",
    "12*x1 + 21*x2 + 23*x6 >= 89",
    "21*x2 + 10*x3 + 23*x6 >= 89",
    "12*x1 + 7*x4 + 23*x6 >= 89",
    "12*x0 + 10*x3 + 7*x4 >= 89",
    "12*x0 + 12*x1 + 7*x4 >= 89",
    "12*x0 + 12*x1 + 10*x3 >= 89",
    "12*x1 + 21*x2 + 4*x5 >= 89",
    "21*x2 + 7*x4 + 23*x6 >= 89",
    "21*x2 + 4*x5 + 23*x6 >= 89",
    "10*x3 + 7*x4 + 4*x5 >= 89",
    "12*x0 + 21*x2 + 4*x5 >= 89",
    "12*x0 + 12*x1 + 4*x5 >= 89",
    "12*x0 + 10*x3 + 23*x6 >= 89",
    "12*x0 + 4*x5 + 23*x6 >= 89",
    "12*x0 + 12*x1 + 23*x6 >= 89",
    "12*x1 + 10*x3 + 4*x5 >= 89",
    "12*x0 + 21*x2 + 7*x4 >= 89",
    "12*x1 + 10*x3 + 7*x4 >= 89",
    "12*x1 + 10*x3 + 23*x6 >= 89",
    "6*x2 - x3 >= 0",
    "-4*x3 + 4*x5 >= 0",
    "12*x1 + 7*x4 <= 881",
    "21*x2 + 10*x3 <= 239",
    "21*x2 + 23*x6 <= 582",
    "12*x1 + 23*x6 <= 1024",
    "12*x0 + 12*x1 <= 328",
    "4*x5 + 23*x6 <= 361",
    "21*x2 + 7*x4 <= 220",
    "12*x1 + 21*x2 <= 823",
    "12*x1 + 21*x2 + 4*x5 <= 684",
    "12*x1 + 21*x2 + 7*x4 <= 632",
    "12*x0 + 12*x1 + 23*x6 <= 359",
    "12*x0 + 7*x4 + 23*x6 <= 732",
    "12*x0 + 10*x3 + 4*x5 <= 1075",
    "7*x4 + 4*x5 + 23*x6 <= 775",
    "21*x2 + 4*x5 + 23*x6 <= 751",
    "21*x2 + 10*x3 + 7*x4 <= 854",
    "21*x2 + 10*x3 + 23*x6 <= 928",
    "21*x2 + 10*x3 + 4*x5 <= 1033",
    "12*x1 + 10*x3 + 23*x6 <= 282",
    "12*x1 + 10*x3 + 7*x4 <= 830",
    "12*x0 + 12*x1 + 21*x2 <= 1015",
    "12*x1 + 7*x4 + 23*x6 <= 896",
    "7*x1 + 5*x3 <= 989",
    "29*x0 + 8*x6 <= 378",
    "7*x1 + 8*x6 <= 178",
    "5*x3 + 14*x5 <= 422",
    "29*x0 + 12*x2 <= 579",
    "14*x5 + 8*x6 <= 242",
    "12*x2 + 5*x3 + 16*x4 <= 243",
    "29*x0 + 12*x2 + 14*x5 <= 888",
    "29*x0 + 16*x4 + 8*x6 <= 852",
    "22*x0 + 20*x1 >= 79",
    "26*x3 + 27*x5 >= 63",
    "11*x2 + 27*x5 >= 66",
    "27*x5 + 24*x6 >= 101",
    "8*x4 + 27*x5 >= 71",
    "11*x2 + 26*x3 >= 138",
    "20*x1 + 8*x4 >= 55",
    "22*x0 + 27*x5 >= 139",
    "26*x3 + 8*x4 >= 66",
    "26*x3 + 27*x5 + 24*x6 >= 149",
    "11*x2 + 26*x3 + 24*x6 >= 149",
    "20*x1 + 11*x2 + 26*x3 >= 149",
    "26*x3 + 27*x5 + 24*x6 >= 98",
    "11*x2 + 26*x3 + 24*x6 >= 98",
    "20*x1 + 11*x2 + 26*x3 >= 98",
    "26*x3 + 27*x5 + 24*x6 >= 116",
    "11*x2 + 26*x3 + 24*x6 >= 116",
    "20*x1 + 11*x2 + 26*x3 >= 116",
    "22*x0 + 20*x1 + 11*x2 + 26*x3 + 8*x4 + 27*x5 + 24*x6 >= 116",
    "17*x1 + 11*x2 >= 67",
    "28*x0 + 2*x5 >= 93",
    "28*x0 + 17*x1 >= 85",
    "18*x4 + 14*x6 >= 60",
    "15*x3 + 18*x4 >= 52",
    "18*x4 + 2*x5 >= 102",
    "2*x5 + 14*x6 >= 62",
    "17*x1 + 2*x5 >= 41",
    "28*x0 + 15*x3 >= 62",
    "11*x2 + 2*x5 >= 76",
    "17*x1 + 14*x6 >= 55",
    "15*x3 + 2*x5 >= 111",
    "15*x3 + 14*x6 >= 73",
    "28*x0 + 15*x3 + 14*x6 >= 112",
    "17*x1 + 15*x3 + 2*x5 >= 112",
    "28*x0 + 11*x2 + 14*x6 >= 112",
    "28*x0 + 11*x2 + 2*x5 >= 112",
    "11*x2 + 2*x5 + 14*x6 >= 112",
    "11*x2 + 18*x4 + 2*x5 >= 112",
    "15*x3 + 2*x5 + 14*x6 >= 112",
    "28*x0 + 17*x1 + 15*x3 >= 112",
    "15*x3 + 18*x4 + 14*x6 >= 112",
    "28*x0 + 15*x3 + 18*x4 >= 112",
    "28*x0 + 18*x4 + 14*x6 >= 112",
    "17*x1 + 11*x2 + 14*x6 >= 112",
    "28*x0 + 11*x2 + 15*x3 >= 112",
    "15*x3 + 18*x4 + 2*x5 >= 112",
    "28*x0 + 17*x1 + 2*x5 >= 112",
    "17*x1 + 2*x5 + 14*x6 >= 112",
    "28*x0 + 17*x1 + 11*x2 >= 112",
    "17*x1 + 15*x3 + 18*x4 >= 112",
    "28*x0 + 2*x5 + 14*x6 >= 112",
    "28*x0 + 18*x4 + 2*x5 >= 112",
    "18*x4 + 2*x5 + 14*x6 >= 112",
    "28*x0 + 17*x1 + 18*x4 >= 112",
    "17*x1 + 15*x3 + 14*x6 >= 112",
    "28*x0 + 17*x1 + 14*x6 >= 112",
    "5*x3 + 16*x4 >= 117",
    "12*x2 + 14*x5 >= 55",
    "12*x2 + 5*x3 + 16*x4 >= 88",
    "7*x1 + 12*x2 + 16*x4 >= 88",
    "29*x0 + 7*x1 + 12*x2 >= 88",
    "7*x1 + 5*x3 + 16*x4 >= 88",
    "7*x1 + 12*x2 + 8*x6 >= 88",
    "7*x1 + 16*x4 + 8*x6 >= 88",
    "29*x0 + 14*x5 + 8*x6 >= 88",
    "7*x1 + 5*x3 + 8*x6 >= 88",
    "7*x1 + 16*x4 + 14*x5 >= 88",
    "29*x0 + 7*x1 + 14*x5 >= 88",
    "12*x2 + 16*x4 + 14*x5 >= 88",
    "29*x0 + 5*x3 + 8*x6 >= 88",
    "x0 >= 0",
    "x1 >= 0",
    "x2 >= 0",
    "x3 >= 0",
    "x4 >= 0",
    "x5 >= 0",
    "x6 >= 0"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
honeypots = m.addVar(vtype=gp.GRB.INTEGER, name="honeypots")
security_engineers = m.addVar(vtype=gp.GRB.INTEGER, name="security_engineers")
patches_per_day = m.addVar(vtype=gp.GRB.INTEGER, name="patches_per_day")
mbps_bandwidth = m.addVar(vtype=gp.GRB.INTEGER, name="Mbps_bandwidth")
system_administrators = m.addVar(vtype=gp.GRB.INTEGER, name="system_administrators")
security_onions = m.addVar(vtype=gp.GRB.INTEGER, name="security_onions")
deployed_decoys = m.addVar(vtype=gp.GRB.INTEGER, name="deployed_decoys")


# Set objective function
m.setObjective(7*honeypots + 6*security_engineers + 7*patches_per_day + mbps_bandwidth + 9*system_administrators + 6*security_onions + 9*deployed_decoys, gp.GRB.MINIMIZE)

# Add constraints
resources = {'r0': {'description': 'dollar cost', 'upper_bound': 1179, 'x0': 12, 'x1': 12, 'x2': 21, 'x3': 10, 'x4': 7, 'x5': 4, 'x6': 23}, 'r1': {'description': 'network latency impact', 'upper_bound': 1006, 'x0': 29, 'x1': 7, 'x2': 12, 'x3': 5, 'x4': 16, 'x5': 14, 'x6': 8}, 'r2': {'description': 'data confidentiality impact', 'upper_bound': 1173, 'x0': 22, 'x1': 20, 'x2': 11, 'x3': 26, 'x4': 8, 'x5': 27, 'x6': 24}, 'r3': {'description': 'computational load', 'upper_bound': 877, 'x0': 28, 'x1': 17, 'x2': 11, 'x3': 15, 'x4': 18, 'x5': 2, 'x6': 14}}
vars = [honeypots, security_engineers, patches_per_day, mbps_bandwidth, system_administrators, security_onions, deployed_decoys]

for r_key, r_data in resources.items():
    m.addConstr(sum(r_data[f'x{i}'] * vars[i] for i in range(len(vars))) <= r_data['upper_bound'], r_key)


m.addConstr(21*patches_per_day + 23*deployed_decoys >= 89)
m.addConstr(12*security_engineers + 23*deployed_decoys >= 155)
m.addConstr(7*system_administrators + 4*security_onions >= 144)
m.addConstr(10*mbps_bandwidth + 4*security_onions >= 161)
m.addConstr(10*mbps_bandwidth + 23*deployed_decoys >= 114)
m.addConstr(12*security_engineers + 10*mbps_bandwidth >= 87)
m.addConstr(21*patches_per_day + 4*security_onions >= 155)
m.addConstr(12*honeypots + 4*security_onions >= 114)
m.addConstr(21*patches_per_day + 10*mbps_bandwidth >= 75)
m.addConstr(4*security_onions + 23*deployed_decoys >= 114)
m.addConstr(7*system_administrators + 4*security_onions + 23*deployed_decoys >= 124)
m.addConstr(12*security_engineers + 21*patches_per_day + 10*mbps_bandwidth >= 124)
m.addConstr(12*honeypots + 7*system_administrators + 23*deployed_decoys >= 124)
m.addConstr(12*honeypots + 21*patches_per_day + 23*deployed_decoys >= 124)
m.addConstr(12*security_engineers + 21*patches_per_day + 23*deployed_decoys >= 124)
m.addConstr(21*patches_per_day + 10*mbps_bandwidth + 23*deployed_decoys >= 124)
m.addConstr(12*security_engineers + 7*system_administrators + 23*deployed_decoys >= 124)
m.addConstr(12*honeypots + 10*mbps_bandwidth + 7*system_administrators >= 124)
m.addConstr(12*honeypots + 12*security_engineers + 7*system_administrators >= 124)
m.addConstr(12*honeypots + 12*security_engineers + 10*mbps_bandwidth >= 124)
m.addConstr(12*security_engineers + 21*patches_per_day + 4*security_onions >= 124)
m.addConstr(21*patches_per_day + 7*system_administrators + 23*deployed_decoys >= 124)
m.addConstr(21*patches_per_day + 4*security_onions + 23*deployed_decoys >= 124)
m.addConstr(10*mbps_bandwidth + 7*system_administrators + 4*security_onions >= 124)
m.addConstr(12*honeypots + 21*patches_per_day + 4*security_onions >= 124)
m.addConstr(12*honeypots + 12*security_engineers + 4*security_onions >= 124)
m.addConstr(12*honeypots + 10*mbps_bandwidth + 23*deployed_decoys >= 124)
m.addConstr(12*honeypots + 4*security_onions + 23*deployed_decoys >= 124)
m.addConstr(12*honeypots + 12*security_engineers + 23*deployed_decoys >= 124)
m.addConstr(12*security_engineers + 10*mbps_bandwidth + 4*security_onions >= 124)
m.addConstr(12*honeypots + 21*patches_per_day + 7*system_administrators >= 124)
m.addConstr(12*security_engineers + 10*mbps_bandwidth + 7*system_administrators >= 124)
m.addConstr(12*security_engineers + 10*mbps_bandwidth + 23*deployed_decoys >= 124)


# ... (rest of the constraints, following the same pattern)

m.addConstr(6*patches_per_day - mbps_bandwidth >= 0)
m.addConstr(-4*mbps_bandwidth + 4*security_onions >= 0)
m.addConstr(12*security_engineers + 7*system_administrators <= 881)
# ... (rest of the constraints)


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

```