#!/usr/bin/python

from operator import mul

nCk = lambda n,k: int(round(reduce(mul, (float(n-i)/(i+1) for i in range(k)), 1)))
pHit = 1.0/3
pmf = lambda dice, hits: pHit**hits * (1-pHit)**(dice-hits) * nCk(dice, hits)
roll = lambda dice: map(lambda hits: pmf(dice, hits), range(dice+1))
avg_result = lambda probs: sum(map(lambda tup: tup[0]*tup[1], enumerate(probs))) / sum(probs)

def second_chance_roll(dice):
    roll_results = [0] * (dice + 1)
    for (hits, prob) in enumerate(roll(dice)):
        for (edge_hits, edge_prob) in enumerate(roll(dice - hits)):
            roll_results[hits + edge_hits] += prob * edge_prob
    return roll_results

exploding_d6 = [0] * 11
exploding_d6[0] -= 1
for i in range(11)[::-1]:
    exploding_d6[i] += 2.0/6**i
    exploding_d6[i] -= sum(exploding_d6[i+1:])

def push_limits_roll(dice, edge):
    dice += edge
    if dice == 0:
        return [1]
    if dice == 1:
        return exploding_d6
    previous_dice_results = push_limits_roll(dice - 1, 0)
    roll_results = [0] * (len(exploding_d6) + len(previous_dice_results) - 1)
    for (prev_hits, prev_prob) in enumerate(previous_dice_results):
        for (hits, prob) in enumerate(exploding_d6):
            roll_results[prev_hits + hits] += prev_prob * prob
    return roll_results

def summon(summon_dice, summon_edge, spirit_force, spirit_edge, drain_dice, drain_edge, body):
    summon_roll = roll(summon_dice)
    if summon_edge:
        summon_roll = second_chance_roll(summon_dice)
    spirit_roll = roll(spirit_force)
    if spirit_edge:
        spirit_roll = push_limits_roll(spirit_force, spirit_force/2 + spirit_force%2)
    drain_roll = roll(drain_dice)
    if drain_edge:
        drain_roll = second_chance_roll(drain_dice)

    physical_boxes = 8 + body/2 + body%2
    damage_taken = [0] * (len(exploding_d6) * (spirit_force + spirit_force/2 + spirit_force%2) * 2 + 1)
    services_if_conscious = [0] * (summon_dice + 1)

    for (summon_hits, summon_prob) in enumerate(summon_roll):
        for (spirit_hits, spirit_prob) in enumerate(spirit_roll):
            for (drain_hits, drain_prob) in enumerate(drain_roll):
                services = max(0, summon_hits - spirit_hits)
                damage = max(0, spirit_hits * 2 - drain_hits)
                probability = summon_prob * spirit_prob * drain_prob
                damage_taken[damage] += probability
                if damage < physical_boxes:
                    services_if_conscious[services] += probability

    print "conscious with 1+ services: %4.1f%%" % (100 * sum(services_if_conscious[1:]))
    print "conscious with no services: %4.1f%%" % (100 * services_if_conscious[0])
    print "unconscious:                %4.1f%%" % (100 * sum(damage_taken[physical_boxes:physical_boxes+body+1]))
    print "dead:                       %4.1f%%" % (100 * sum(damage_taken[physical_boxes+body+1:]))
    print "average services if conscious: %.1f" % avg_result(services_if_conscious)

import os
import sys
if __name__ == "__main__":
    if len(sys.argv) != 8:
        print "usage: " + os.path.basename(sys.argv[0]) + " summon_dice edge? spirit_force edge? drain_dice edge? body"
        print "example: " + os.path.basename(sys.argv[0]) + " 14 1 12 1 10 1 3"
    else:
        summon(int(sys.argv[1]), int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4]), int(sys.argv[5]), int(sys.argv[6]), int(sys.argv[7]))