```json
{
  "sym_variables": [
    ("x0", "military intelligence companies"),
    ("x1", "armored companies"),
    ("x2", "transportation companies"),
    ("x3", "reconnaissance troops"),
    ("x4", "mechanized infantry companies")
  ],
  "objective_function": "8.23 * x0 + 4.69 * x1 + 6.7 * x2 + 6.31 * x3 + 8.32 * x4",
  "constraints": [
    "15 * x0 + 8 * x2 >= 47",
    "12 * x1 + 9 * x3 >= 80",
    "9 * x3 + 24 * x4 >= 114",
    "12 * x1 + 24 * x4 >= 43",
    "15 * x0 + 12 * x1 >= 41",
    "12 * x1 + 8 * x2 >= 75",
    "15 * x0 + 9 * x3 >= 41",
    "15 * x0 + 24 * x4 >= 120",
    "15 * x0 + 12 * x1 + 8 * x2 + 9 * x3 + 24 * x4 >= 120",
    "23 * x1 + 25 * x4 >= 54",
    "18 * x3 + 25 * x4 >= 69",
    "18 * x0 + 23 * x2 + 25 * x4 >= 67",
    "23 * x1 + 18 * x3 + 25 * x4 >= 67",
    "18 * x0 + 23 * x1 + 18 * x3 >= 67",
    "18 * x0 + 18 * x3 + 25 * x4 >= 67",
    "23 * x1 + 23 * x2 + 25 * x4 >= 67",
    "18 * x0 + 23 * x1 + 23 * x2 >= 67",
    "18 * x0 + 23 * x2 + 25 * x4 >= 84",
    "23 * x1 + 18 * x3 + 25 * x4 >= 84",
    "18 * x0 + 23 * x1 + 18 * x3 >= 84",
    "18 * x0 + 18 * x3 + 25 * x4 >= 84",
    "23 * x1 + 23 * x2 + 25 * x4 >= 84",
    "18 * x0 + 23 * x1 + 23 * x2 >= 84",
    "18 * x0 + 23 * x2 + 25 * x4 >= 102",
    "23 * x1 + 18 * x3 + 25 * x4 >= 102",
    "18 * x0 + 23 * x1 + 18 * x3 >= 102",
    "18 * x0 + 18 * x3 + 25 * x4 >= 102",
    "23 * x1 + 23 * x2 + 25 * x4 >= 102",
    "18 * x0 + 23 * x1 + 23 * x2 >= 102",
    "18 * x0 + 23 * x2 + 25 * x4 >= 73",
    "23 * x1 + 18 * x3 + 25 * x4 >= 73",
    "18 * x0 + 23 * x1 + 18 * x3 >= 73",
    "18 * x0 + 18 * x3 + 25 * x4 >= 73",
    "23 * x1 + 23 * x2 + 25 * x4 >= 73",
    "18 * x0 + 23 * x1 + 23 * x2 >= 73",
    "18 * x0 + 23 * x2 + 25 * x4 >= 98",
    "23 * x1 + 18 * x3 + 25 * x4 >= 98",
    "18 * x0 + 23 * x1 + 18 * x3 >= 98",
    "18 * x0 + 18 * x3 + 25 * x4 >= 98",
    "23 * x1 + 23 * x2 + 25 * x4 >= 98",
    "18 * x0 + 23 * x1 + 23 * x2 >= 98",
    "18 * x0 + 23 * x2 + 25 * x4 >= 108",
    "23 * x1 + 18 * x3 + 25 * x4 >= 108",
    "18 * x0 + 23 * x1 + 18 * x3 >= 108",
    "18 * x0 + 18 * x3 + 25 * x4 >= 108",
    "23 * x1 + 23 * x2 + 25 * x4 >= 108",
    "18 * x0 + 23 * x1 + 23 * x2 >= 108",
    "18 * x0 + 23 * x1 + 23 * x2 + 18 * x3 + 25 * x4 >= 108",
    "6 * x2 - x4 >= 0",
    "15 * x0 + 9 * x3 + 24 * x4 <= 247",
    "15 * x0 + 12 * x1 + 8 * x2 <= 469",
    "12 * x1 + 8 * x2 + 9 * x3 <= 460",
    "8 * x2 + 9 * x3 + 24 * x4 <= 581",
    "12 * x1 + 8 * x2 + 24 * x4 <= 294",
    "18 * x3 + 25 * x4 <= 301",
    "23 * x2 + 25 * x4 <= 419",
    "23 * x1 + 18 * x3 <= 326",
    "23 * x1 + 23 * x2 <= 197",
    "18 * x0 + 18 * x3 <= 393",
    "23 * x1 + 18 * x3 + 25 * x4 <= 257",
    "23 * x1 + 23 * x2 + 18 * x3 <= 243",
    "18 * x0 + 23 * x2 + 18 * x3 <= 284",
    "15 * x0 <= 614",
    "18 * x0 + 23 * x1 + 23 * x2 + 18 * x3 + 25 * x4 <= 554"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = m.addVars(5, vtype=gp.GRB.INTEGER, name=["Military Intelligence", "Armored", "Transportation", "Recon", "Mechanized Infantry"])

# Set objective function
m.setObjective(8.23 * x[0] + 4.69 * x[1] + 6.7 * x[2] + 6.31 * x[3] + 8.32 * x[4], gp.GRB.MINIMIZE)

# Add constraints
logistical_capacity = [15, 12, 8, 9, 24]
fuel_demand = [18, 23, 23, 18, 25]
logistical_upper_bound = 614
fuel_upper_bound = 554


m.addConstr(15 * x[0] + 8 * x[2] >= 47)
m.addConstr(12 * x[1] + 9 * x[3] >= 80)
m.addConstr(9 * x[3] + 24 * x[4] >= 114)
m.addConstr(12 * x[1] + 24 * x[4] >= 43)
m.addConstr(15 * x[0] + 12 * x[1] >= 41)
m.addConstr(12 * x[1] + 8 * x[2] >= 75)
m.addConstr(15 * x[0] + 9 * x[3] >= 41)
m.addConstr(15 * x[0] + 24 * x[4] >= 120)
m.addConstr(15 * x[0] + 12 * x[1] + 8 * x[2] + 9 * x[3] + 24 * x[4] >= 120)

m.addConstr(23 * x[1] + 25 * x[4] >= 54)
m.addConstr(18 * x[3] + 25 * x[4] >= 69)


for i in range(5):
    for j in range(i,5):
        for k in range(j,5):
            m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] >= 67)
            m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] >= 73)
            m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] <= 284)
            if i != j and j != k:
                m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] >= 84)
                m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] >= 98)
                m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] >= 102)
                m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] >= 108)
                m.addConstr(fuel_demand[i]*x[i] + fuel_demand[j]*x[j] + fuel_demand[k]*x[k] <= 243)

m.addConstr(sum(fuel_demand[i]*x[i] for i in range(5)) >= 108)


m.addConstr(6 * x[2] - x[4] >= 0)
m.addConstr(15 * x[0] + 9 * x[3] + 24 * x[4] <= 247)
m.addConstr(15 * x[0] + 12 * x[1] + 8 * x[2] <= 469)
m.addConstr(12 * x[1] + 8 * x[2] + 9 * x[3] <= 460)
m.addConstr(8 * x[2] + 9 * x[3] + 24 * x[4] <= 581)
m.addConstr(12 * x[1] + 8 * x[2] + 24 * x[4] <= 294)
m.addConstr(18 * x[3] + 25 * x[4] <= 301)
m.addConstr(23 * x[2] + 25 * x[4] <= 419)
m.addConstr(23 * x[1] + 18 * x[3] <= 326)
m.addConstr(23 * x[1] + 23 * x[2] <= 197)
m.addConstr(18 * x[0] + 18 * x[3] <= 393)
m.addConstr(23 * x[1] + 18 * x[3] + 25 * x[4] <= 257)


m.addConstr(sum(logistical_capacity[i] * x[i] for i in range(5)) <= logistical_upper_bound)
m.addConstr(sum(fuel_demand[i] * x[i] for i in range(5)) <= fuel_upper_bound)



# Optimize model
m.optimize()

# Print results
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}")

```
