```json
{
  "sym_variables": [
    ("x0", "automatic alerts"),
    ("x1", "network administrators"),
    ("x2", "system administrators"),
    ("x3", "intrusion analysts"),
    ("x4", "patches per day")
  ],
  "objective_function": "5.43 * x0 + 6.09 * x1 + 6.75 * x2 + 7.06 * x3 + 7.38 * x4",
  "constraints": [
    "1.27 * x0 + 3.74 * x1 + 3.5 * x2 + 1.06 * x3 + 1.38 * x4 <= 634",
    "1.0 * x0 + 0.81 * x1 + 3.66 * x2 + 4.84 * x3 + 5.75 * x4 <= 502",
    "4.15 * x0 + 1.93 * x1 + 0.86 * x2 + 5.98 * x3 + 0.59 * x4 <= 449",
    "x0 + x1 >= 83",
    "x2 + x3 >= 44",
    "x1 + x4 >= 61",
    "x2 + x4 >= 42",
    "x0 + x4 >= 86",
    "x1 + x2 >= 82",
    "x3 + x4 >= 78",
    "x0 + x2 >= 106",
    "x0 + x3 >= 78",
    "x0 + x1 + x2 + x3 + x4 >= 78",
    "0.81 * x1 + 4.84 * x3 >= 74",
    "1.0 * x0 + 5.75 * x4 >= 66",
    "0.81 * x1 + 3.66 * x2 >= 84",
    "1.0 * x0 + 0.81 * x1 >= 75",
    "1.0 * x0 + 0.81 * x1 + 3.66 * x2 + 4.84 * x3 + 5.75 * x4 >= 75",
    "4.15 * x0 + 1.93 * x1 >= 60",
    "5.98 * x3 + 0.59 * x4 >= 85",
    "1.93 * x1 + 0.86 * x2 >= 43",
    "0.86 * x2 + 0.59 * x4 >= 77",
    "4.15 * x0 + 5.98 * x3 >= 32",
    "1.93 * x1 + 0.86 * x2 + 0.59 * x4 >= 73",
    "4.15 * x0 + 1.93 * x1 + 0.86 * x2 + 5.98 * x3 + 0.59 * x4 >= 73",
    "-3 * x0 + 8 * x1 >= 0",
    "1.27 * x0 + 3.74 * x1 + 1.06 * x3 <= 588",
    "1.27 * x0 + 3.74 * x1 + 1.38 * x4 <= 293",
    "1.0 * x0 + 3.66 * x2 + 4.84 * x3 <= 360",
    "4.15 * x0 + 5.98 * x3 <= 406",
    "4.15 * x0 + 1.93 * x1 + 0.86 * x2 <= 312",
    "1.93 * x1 + 5.98 * x3 + 0.59 * x4 <= 107",
    "0.86 * x2 + 5.98 * x3 + 0.59 * x4 <= 366",
    "4.15 * x0 + 0.86 * x2 + 0.59 * x4 <= 212",
    "1.93 * x1 + 0.86 * x2 + 5.98 * x3 <= 342",
    "1.93 * x1 + 0.86 * x2 + 0.59 * x4 <= 125"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = m.addVars(5, vtype=gp.GRB.INTEGER, names=['automatic alerts', 'network administrators', 'system administrators', 'intrusion analysts', 'patches per day'])


# Set objective function
m.setObjective(5.43 * x[0] + 6.09 * x[1] + 6.75 * x[2] + 7.06 * x[3] + 7.38 * x[4], gp.GRB.MINIMIZE)

# Add constraints
resource_constraints = {
    'r0': {'upper_bound': 634, 'coefficients': [1.27, 3.74, 3.5, 1.06, 1.38]},
    'r1': {'upper_bound': 502, 'coefficients': [1.0, 0.81, 3.66, 4.84, 5.75]},
    'r2': {'upper_bound': 449, 'coefficients': [4.15, 1.93, 0.86, 5.98, 0.59]}
}

for resource, data in resource_constraints.items():
    m.addConstr(gp.quicksum(data['coefficients'][i] * x[i] for i in range(5)) <= data['upper_bound'], name=resource)


m.addConstr(x[0] + x[1] >= 83)
m.addConstr(x[2] + x[3] >= 44)
m.addConstr(x[1] + x[4] >= 61)
m.addConstr(x[2] + x[4] >= 42)
m.addConstr(x[0] + x[4] >= 86)
m.addConstr(x[1] + x[2] >= 82)
m.addConstr(x[3] + x[4] >= 78)
m.addConstr(x[0] + x[2] >= 106)
m.addConstr(x[0] + x[3] >= 78)
m.addConstr(x[0] + x[1] + x[2] + x[3] + x[4] >= 78)
m.addConstr(0.81 * x[1] + 4.84 * x[3] >= 74)
m.addConstr(1.0 * x[0] + 5.75 * x[4] >= 66)
m.addConstr(0.81 * x[1] + 3.66 * x[2] >= 84)
m.addConstr(1.0 * x[0] + 0.81 * x[1] >= 75)
m.addConstr(1.0 * x[0] + 0.81 * x[1] + 3.66 * x[2] + 4.84 * x[3] + 5.75 * x[4] >= 75)
m.addConstr(4.15 * x[0] + 1.93 * x[1] >= 60)
m.addConstr(5.98 * x[3] + 0.59 * x[4] >= 85)
m.addConstr(1.93 * x[1] + 0.86 * x[2] >= 43)
m.addConstr(0.86 * x[2] + 0.59 * x[4] >= 77)
m.addConstr(4.15 * x[0] + 5.98 * x[3] >= 32)
m.addConstr(1.93 * x[1] + 0.86 * x[2] + 0.59 * x[4] >= 73)
m.addConstr(4.15 * x[0] + 1.93 * x[1] + 0.86 * x[2] + 5.98 * x[3] + 0.59 * x[4] >= 73)
m.addConstr(-3 * x[0] + 8 * x[1] >= 0)
m.addConstr(1.27 * x[0] + 3.74 * x[1] + 1.06 * x[3] <= 588)
m.addConstr(1.27 * x[0] + 3.74 * x[1] + 1.38 * x[4] <= 293)
m.addConstr(1.0 * x[0] + 3.66 * x[2] + 4.84 * x[3] <= 360)
m.addConstr(4.15 * x[0] + 5.98 * x[3] <= 406)
m.addConstr(4.15 * x[0] + 1.93 * x[1] + 0.86 * x[2] <= 312)
m.addConstr(1.93 * x[1] + 5.98 * x[3] + 0.59 * x[4] <= 107)
m.addConstr(0.86 * x[2] + 5.98 * x[3] + 0.59 * x[4] <= 366)
m.addConstr(4.15 * x[0] + 0.86 * x[2] + 0.59 * x[4] <= 212)
m.addConstr(1.93 * x[1] + 0.86 * x[2] + 5.98 * x[3] <= 342)
m.addConstr(1.93 * x[1] + 0.86 * x[2] + 0.59 * x[4] <= 125)



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

```
