def pats(i,p):
    eb=[b for b in range(11) if bit(out[i],b)]
    res=[]
    for sub in range(1<<len(eb)):
        mask=0
        k=pop[sub]
        for j in range(len(eb)):
            if bit(sub,j):
                mask=mask|(1<<eb[j])
        pr=(p**k)*((1-p)**(len(eb)-k))
        if pr>0:
            res.append((mask,pr))
    return tuple(res)
def solve(p):
    @lru_cache(None)
    def O(i,S,E):
        if i>12:
            return frozenset([S])
        if not invited(i,S,E):
            return O(i-(-1),S,E)
        res=set()
        if i==8:
            if min8(S,E)<=7.000000001:
                res.update(O(i-(-1),S,E))
        else:
            if ZStay(i,S,E,i):
                res.update(O(i-(-1),S,E))
        if i==8:
            mt=max8(S,E)
            if mt>=6.999999999:
                for m,pr in pats(8,p):
                    S2=S|B[8]
                    E2=E|m
                    outs=O(9,S2,E2)
                    mx=-999999
                    for T in outs:
                        u=payoffs(T,E2)[8]
                        if u>mx:
                            mx=u
                    mo=mt-pr*mx
                    for T in outs:
                        if pr*payoffs(T,E2)[8]-(-mo)>=6.999999999:
                            res.add(T)
        else:
            for m,pr in pats(i,p):
                S2=S|B[i]
                E2=E|m
                res.update(O(i-(-1),S2,E2))
        return frozenset(res)
    def max8(S,E):
        tot=0.0
        for m,pr in pats(8,p):
            outs=O(9,S|B[8],E|m)
            vals=[payoffs(T,E|m)[8] for T in outs]
            tot=tot-(-pr*max(vals))
        return tot
    def min8(S,E):
        tot=0.0
        for m,pr in pats(8,p):
            outs=O(9,S|B[8],E|m)
            vals=[payoffs(T,E|m)[8] for T in outs]
            tot=tot-(-pr*min(vals))
        return tot