# mugging

Attempt to resolve Pascal's mugging by proposing & justifying a linear prior probability which bounds losses.
topics: philosophy, transhumanism
created: 23 Dec 2009; modified: 13 Sep 2019; status: draft; confidence: possible;

Pascal’s Mugging is a general problem in decision theory: it exposes the paradoxical and apparently irrational consequences of a thorough-going probabilistic approach to devising a rational utilitarian agent, by offering a deal which seems, intuitively, to be utterly worthless but which the agent will accept. It is generally thought that any system which allows an agent to be exploited this way, to be a ‘money pump’, is irrational & flawed. I attempt to dissect Pascal’s Mugging into 2 separate problems, one of an epistemological flaw in the agent, and another about how to deal with low-probability but high-payoff events.

# Background

Classical decision theory, going back to von Neumann and Morgenstern’s Theory of Games and Economic Behavior, says that a rational agent pursuing an arbitrary goal will select the sequence of actions that leads to the greatest fulfillment of that goal. If we imagine a branching tree of actions, the agent will sum up every path through the tree, and take the highest path. But what if the branches are not certain, if taking a path through the tree like A->D->M is not guaranteed to wind up at M, if each step through the tree is only probabilistic? How does one weigh the probability of a step succeeding against the value of a step in such a way that it can be compared to the many other possible steps? The very simplest way is to multiply the value of a step against the probability of reaching it. This gives us some number for each step; we will call it the ‘expected value’.

So imagine an agent seeking money; he is offered a fair coin-flip where heads, he gains $6 and tails he loses$4. Here he assess three possible steps: don’t accept the deal, accept the deal and get heads, accept the deal and get tails. The value of not accepting the deal is 0, and the probability of 0 is 100%, so 0. The value of accepting the deal and getting heads is $6, and since it’s a fair coin, he has a 50% chance; 50% of$6 is $3. The value of accepting the deal and getting tails is -$4, and this too is a 50% chance; 50% of -4 is -2. So, heads has an expected value of 3; tails has an expected value of -2; added together, they have a value of 1. 1 is greater than 0, so the agent will take the coin-flip and will wax wealthy.

Taking the choice with the greatest expected value is a very simple policy, and it works well in many real-life situations. It tells us to avoid the lottery, for example, and casinos. It will tell us when we win in a game and when we wouldn’t. Besides simplicity, it has the law of large numbers on its side – after enough trials, we will have the expected value. Or if we imagine that there is an agent for every possible outcome, then the total wealth/value across all these possible agents is as high as is possible, no other approach can do better across all possible outcomes. (That is, we could imagine an otherwise highly irrational agent, which has precognition, so it will only play games with you if it knows it will win; this agent would win against an expected-value agent, but only because we have magically defined away all the many outcomes where that precognitive agent loses. Or we could imagine a highly risk-averse agent; it would pass up opportunities our expected-value agent wouldn’t, and in the long run would do worse than our agent.)

So this expected-value paradigm has long been one of the best contenders for a definition of rationality in actions. (As far as beliefs goes, the agent could be a Bayesian or some other statistical formalism.)

# The Mugging

“There is a concept which corrupts and upsets all others. I refer not to Evil, whose limited realm is that of ethics; I refer to the infinite.”1

So let us imagine our agent in the Mugging. As described by Nick Bostrom, our agent is accosted by the mugger and asked what probability it would assign any deal offered by the mugger. How the agent calculates this probability is irrelevant, but the agent does give a probability – one in one quadrillion. The mugger then offers the agent a deal: some money right now, in exchange for 100 quadrillion tomorrow. The agent sets the requested money (-20) against the expected value (100 quadrillion times 1-in-1-quadrillion = 100), and concludes a net benefit of 80, which is greater than the expected-value of not taking the deal (0). (Note that I use ‘money’ here as a place-holder of ‘utility’ or ‘goal-fulfillment’ or some such term.)

Obviously something has gone wrong here. We seem to have a money pump or a Dutch Book: a deal which leaves our supposedly supremely rational agent worse off than he could have been, and worse, a deal which the mugger can offer again and again until our agent is flat-broke. But what exactly went wrong? The agent followed the procedure exactly as we taught him, and it had worked well up to this point.

And this is a real issue, since the mugging could take the form of the mugger asking the agent to become his disciple and help spread his new cult, or to spend the rest of his life statistically analyzing the Bible for messages from God, or ask the agent’s help in bombing some buildings. The mugger can ask essentially anything of the agent, and get it. As a normative ideal of rationality, this leaves something to be desired, and without a good normative ideal of rationality, we cannot point out the errors of other peoples’ ways, or analyze situations where human intuitions about expected-value breaks down (such as with particularly complex financial agreements, or blue-sky research projects).

The simplest fix is to set some upper bound on the agent’s possible value. So our formula would be something like ‘probability times value, unless value is greater than upper-bound in which case 0’. In this case, our agent would have a bound, say, 20 billion, and would consider the offer of 100 quadrillion as an offer for 0, and thus incurring a cost of -20 with no gain (100 quadrillion times 0), which is clearly worse than the status quo of 0. The mugger would go away unless he could somehow convince the agent that there was a better than one-in-a-billion chance that the mugger would deliver on 20 billion (as 1/100 million times 20 billion, minus the cost of the $20 is greater than 0). The upper bound on value has been suggested by multiple authors (McGee 1999, De Blanc 2007 & 2009). The upper bound does have some intuitive appeal. If our agent is seeking pleasure, there’s only so much pleasure it can physiologically have at any one moment, and its lifespan is finite, so the maximum possible pleasure would also be finite. Given that, why would it want any more? In other areas, further gains decrease in value, and sometimes seem to be worthless. (When Bill Gates was valued at$90 billion, would another $100,000 have been worth anything whatsoever to him?) But our grand theory of rationality should work for all agents. What if our agent were immortal? If it could only have 20 billion units of pleasure and then it considered any further pleasure absolutely worthless, would we see it living for a million years or so and then one day simply cease moving & starve to death because it had reached the upper limit and now every possible action was equally worthless? That seems rather odd. And how would this limit be assigned? If we imagine making our agent, how could we calculate what the limit should be? We might say that ‘our agent can only have 10 orgasms a second and will live for a century, so we can set the limit to X’, but this might cause problems if our agent is upgraded to be able to experience pleasure equivalent to 30 orgasms a second or its lifespan is extended. And if the goal is tied to external things, we also have this problem; we might set out to create a rational Gandhi whose mission is to lessen the suffering of all mankind – but mankind may keep growing and expanding indefinitely. If we set the limit too high, then our agent is vulnerable to the Mugging; if the limit is too low, it will commit suicide without, from our perspective, the mission being fulfilled. So the upper bound solution may solve some Muggings, but at costs unacceptable. Here too we can ask our intuitions: we do not feel vulnerable or persuaded by the Mugging even at our most rational, but do we also feel that we might one day cease to take pleasure in any activity and simply wait for death? I at least do not. A second solution is to take into account the specific value offered by the mugger and thereby change the assessed probability. Robin Hanson (Yudkowsky 2007), writing about a negative version of the Mugging (with astronomical threats instead of rewards), suggests that “It might be more promising to assume that states with many people hurt have a low correlation with what any random person claims to be able to effect.” That is, for an agent with a small probability to be confronted with a ‘real’ mugger (genuinely capable of delivering on his claim) is to be in a very unusual position: the agent is now able to affect possibly even more people than Hitler, Stalin, Napoleon, Mao, Alexander the Great etc. all put together. (Perhaps the mugger threatened to harm 20 quadrillion people.) Yet all those other people have no ‘real’ mugger of their own. So what are the odds of our agent just happening to be the only one out of 20 quadrillion people to run into the mugger? We might guess that it’s something like 1 in 20 quadrillion, which as it happens, exactly counterbalances the value, giving us a very small or even negative expected value and defeating the mugger. The problem with this solution is that it seems to solve the Mugging at the expense of other problems. If we initially assume that the chance of us really affecting X people is 1/X, then this suggests some counterintuitive beliefs. For example, we ought to start out believing that the chance of humanity right now being able to do anything about global warming is on the order of 1 in hundreds of billions or trillions. Why? It seems plausible humanity will continue to exist for centuries or millennia, and the billions or trillions of humans living during those centuries will be affected by any fix of global warming. Now, one may be skeptical about the political process being effective or anti-global warming efforts bearing fruit, but one-in-trillions or even just one-in-billions seems unduly pessimistic. And there is a situation in which everybody could in fact affect X people – if there is an infinite number of people. Scientists have suggested infinite universes on multiple occasions, and we cannot rule the idea out on any logical ground. Should our theory of rationality stand or fall on what the cosmologists currently think? That too seems a flaw. The third solution is to object to the procedure entirely. The problem is that our agent provides his probability of any payout first, and then the mugger can easily construct a deal with positive expected-value. Baumann 2009 objects to providing the probability of a payout first, but he doesn’t justify this except to call such an ‘independent’ probability ‘extremely implausible’. I think we can firm this up by pointing out that here, with that independent probability, infinities have snuck right back into the problem. And where infinities are, we should not be surprised to see confusion. Thus, we can dissect the Mugging into 2 distinct problems: the problem of how one should assess arbitrary statements, and how to value high-payoff-low-probability actions. Consider the generalized form of the first question: the mugger asks the agent what its probability that the mugger’s next statement will be true. It replies 1 in n; the mugger then makes the promise ‘give me your wallet & I will give you 1000n tomorrow’ etc. But what sort of probability could n be? It’s in effect trying to give a probability over anything the mugger might say or promise. I don’t think this makes sense, as even if we ignore the unbounded length of the mugger’s potential next statement, he could state strange things like ‘Turing machine X halts’ or ‘the quadrillionth digit of Chaitin’s uncomputable number Omega is 1’ - state all manner of undecidable, intractable, or incoherent statements. We might get rid of outright nonsense with some stipulations on content, but we’d be left with perfectly reasonable yet undecidable or intractable statements. Giving any probability seems to me to be quite impossible. Or to narrow it back down, maybe the agent is told the mugger offers deals paying out a random integer, and asked his assessment that the mugger will pay out on any offer. Each possible offer must have a probability, we feel, which is nonzero. (Per Baumann, we feel that whatever the odds of payout on 10 utilities/dollars is, it’s greater than that of 1000.) But there are an infinite number of integers, so if each one is nonzero, then what is your total assessment? We asked for ‘any’, so the individual probabilities must simply add up - if the mugger has secretly resolved to pay you only if the random integer is 20, but not otherwise, then the total must be non-zero, since if the agent said 0, and the mugger wound up paying because 20 came up, then that’d be a contradiction. But what’s the sum of an infinite series of non-zero terms? The obvious answers are 1 or infinity, both of which are ridiculous answers, and there’s no apparent sensible limit to converge on. So it must be impossible to have a minimum probability for every possible offer. (I remember hearing once that there is no uniform random way to pick an integer from the set of all integers, which would also imply the impossibility of having any sort of maximum-entropy prior on all the integers.) In a very general way, I think this defeats many concerns about agents succumbing to the ‘fanaticism’ problem of thinking it might be in a simulation just because someone mentioned the idea to it, and scouring the universe looking for a way out - you can’t form any sensible probabilities about things ‘outside’ your total assemblage of theories & data & principles, because that implies you have information (encoded as a probability) about those outside things which isn’t included in your assemblage, which is either irrational or contradictory, but if those outside things are part of your assemblage (if you really have good reason to believe them), then it’s not really a ‘mugging’ to pursue them. An example: imagine our universe allows the agent an optimal outcome of 1 trillion utilities, and someone suggests the simulation argument to it, saying nothing stops the ‘real’ universe from being big enough to allow the agent 1 trillion squared utilities, and so it should go look for loopholes; the agent wouldn’t do it because the possibility would be based on actual research and investigations, which all argue that there is no simulation and that even if there were, the agent has no reason to believe it’s any particular size larger than the current universe, because per the previous arguments that would imply assessments over all the integers or all statements/strings/theories. Now, if the agent had real evidence of simulation, such as stars choreographically flashing on and off, or perhaps anthropic arguments from actually running its own simulations, then it might go off on the search - but that’s as it should be. So, Baumann is right in rejecting providing the probability first, since it could well imply outright contradiction, but then how do we decide how to scale our probability by the promised sum? If we don’t scale down in proportion, we just render ourselves muggable at some point, even though the mugger might not know what; but if we scale down proportionately, that seems to me to say something along the lines of ‘under all possible deals I expect a certain constant to be my expected utility’ (eg. if we put him at 1/1 quadrillion when he offers 10 quadrillion, then we expect 10 from the deal, just like we would if it were 1/100 quadrillion for his 1000 quadrillion offer…), which is kind of strange too, since we already have claimed that some sort of nonlinear scaling feels intuitively appropriate - do we decrease nonlinearly until we hit the total wealth of the earth & switch to linear, or just when the promise reaches into the millions, or what? On the other hand, the disproportionately shrinking strategy may not work - imagine we are in a universe where we know the majority of the universe’s utility is in the hands of a perverse god who will send muggers out to do his bidding, only one of which will deliver (but there will be a delivery before the universe expires). In this universe, shouldn’t our probability that a mugger will deliver go up over time as the utility remains unawarded to someone? We don’t actually know that there is such a god, but mightn’t we assign it a nonzero probability since it doesn’t initially seem to run afoul of the previous arguments about the illegitimacy of assigning a probability over everything (a set & finite universe, number of mugger encounters, and utility.) This argument is weak, though, since we could imagine that the utility might not be guaranteed to be awarded to someone, in which case the odds would get worse over time as lottery tickets get used up and the deadline draws near – every increasing-odds scenario could be neutralized by a decreasing-odds scenario. # Bibliography Baumann, Peter. “Counting on Numbers”, Analysis 69:3 (2009), pp. 446-448 Bostrom, Nick. “The Infinitarian Challenge to Aggregative Ethics” (2008), Bostrom, Nick. “Pascal’s Mugging”, Analysis 69:3 (2009), pp. 443-445. De Blanc, Peter. " Convergence of Expected Utilities with Algorithmic Probability Distributions" (2007), De Blanc, Peter. “Convergence of Expected Utility for Universal AI” (2009), McGee, Vann. “An airtight Dutch book”, Analysis 59:4 (1999), pp. 257-65 Yudkowsky, Eliezer. “Pascal’s Mugging: Tiny Probabilities of Vast Utilities”, LessWrong.com, 19 October 2007. One way to try to escape a mugging is to unilaterally declare that all probabilities below a certain small probability will be treated as zero. With the right pair of lower limit and mugger’s credibility, the mugging will not take place. But such a ad hoc method violates common axioms of probability theory, and thus we can expect there to be repercussions. It turns out to be easy to turn such a person into a money pump, if not by the mugging itself. Suppose your friend adopts this position, and he says specifically that any probabilities less than or equal to 1/20 are 0. You then suggest a game; the two of you will roll a d20 die, and if the die turns up 1-19, you will pay him one penny and if the die turns up 20, he pays you one dollar - no, one bazillion dollars. Your friend then calculates: there is a 19/20 chance that he will win a little money, and there is a 1/20 chance he will lose a lot of money - but wait, 1/20 is too small to matter! It is zero chance, by his rule. So, there is no way he can lose money on this game and he can only make money. He is of course wrong, and on the 5th roll you walk away with everything he owns. (And you can do this as many times as you like.) Nor can it be rescued simply by shrinking the probability; the same game that defeated a limit of 1/20 can easily be generalized to 1/n, and in fact, we can make the game even worse: instead of 1 to n-1 winning, we define 0 and 1 as winning, and each increment as losing. As n increases, the large percentage of instant losses increases. So clearly this modification doesn’t work. If we think about the scaling of the prior probability of a reward, there’s clearly 3 general sorts of behavior: 1. sublinear relationship where the probability shrinks slower than the reward increases 2. a linear relationship where the probability shrinks as fast as the reward increases 3. and a superlinear relationship where the probability shrinks faster than the reward increases. The first doesn’t resolve the mugging. If the mugging is ever rejected, then the mugger merely increases the reward and can always devise an accepted mugging. The second and third both resolve the mugging - the agent will reject a large mugging if it rejected a smaller one. But is there any reason to prefer the linear relationship to the superlinear? Yes, by the same reasoning as leads us to reject the lower limit solution. We can come up with a game or a set of deals which presents the same payoff but which an agent will accept when they should reject and vice versa. Let’s suppose a mugger tries a different mugging. Instead of asking for$20, he asks for a penny, and he mentions that he will ask this another 1999 times; because the reward is so small, the probability is much higher than if he had asked for a flat $20 and offered a consequently larger reward. If the agent’s prior was not so low that they always rejected the mugger, then we would see an odd flip - for small sums, the agent would accept the mugging and then as the sums increased, it would suddenly start rejecting muggings, even when the same total sums would have been transacted. That is, just by changing some labels while leaving the aggregate utility alone, we change the agent’s decisions. If the agent had been using a linear relationship, there would be no such flip. If the agent rejected the penny offer it would reject the$20 offer and vice versa. It would be consistently right (or wrong). The sublinear and superlinear relationships are inconsistently wrong.

While raking, I think I finally thought of a proof that the before-offer-probability can’t be known.

The question is basically ‘what fraction of all Turing machines making an offer (which is accepted) will then output a certain result?’

We could rewrite this as ’what is the probability that a random Turing machine will output a certain result?

We could then devise a rewriting of all those Turing machines into Turing machines that halt or not when their offer is accepted (eg. halting might = delivering, not halting = welshing on the deal. This is like Rice’s theorem).

Now we are asking ‘what fraction of all these Turing machines will halt?’

However, this is asking ‘what is Chaitin’s constant for this rewritten set of Turing machines?’ and that is uncomputable!

Since Turing machine-based agents are a subset of all agents that might try to employ Pascal’s Mugging (even if we won’t grant that agents must be Turing machines), the probability is at least partially uncomputable. A decision procedure which entails uncomputability is unacceptable, so we reject giving the probability in advance, and so our probability must be contingent on the offer’s details (like its payoff).

continuing above:

Last I emailed you, I had an intuition that a linear relationship was best but no real justification. I think I have one now that goes like this:

Inasmuch as the mugger could be the robotic instantiation of an arbitrary Turing Machine, making predictions about what the mugger will output (‘do’) in response to your input is tantamount to solving the Halting Problem (see Rice’s theorem). Trying to make a prediction about the fraction of all muggers which will welsh on the deal is like trying to compute Chaitin’s omega; if you only compute part of it, you will make mistakes when the offered reward is very close to the right value to make the expected utility positive, but to compute all of it is impossible. This is true for the same reasons that most universal priors (like for Solomonoff induction) are uncomputable.

So, it is impossible to be an optimal agent when being mugged. An agent must have an erroneous prior and make mistakes. The question becomes what kind of prior and what kind of mistakes should the agent make?

We can look at our prior as a monotonic function on a Cartesian graph with the y-axis for offered-reward and the x-axis for the prior of said reward; for example:

1. the graph might be a simple inverse relationship where prior is inverse to reward; small increases cause small decreases and large increases large decreases
2. it might look more like an exponential where a large increase in reward leads to only a small decrease in the prior probability
3. or it might look logarithmic where small reward increases lead to a large decrease the prior probability.

These three general classes are all there are. (small/small; large/small; small/large.)

Suppose we make our agent with strategy #2. The mugger presents the agent with a mugging, is turned down, and simply throws in a few exponentials and succeeds. The prior doesn’t decrease as fast as the reward increases, so a patient mugger will always win. And this is true even if the agent updates the prior probability so all the previous deals are now considered negative expected utility - the mugger comes back and simply escalates the offer!

Suppose we make our agent have #3. A mugger presents our agent with a mugging, but makes a mistake and offers too high a reward. The agent instantly rejects it because the large reward incurs a massive penalty. So far so good. But the mugger reflects, and decides to break the offer up into 1 billion smaller offers summing to the same reward. Since each of the 1 billion muggings is for a much smaller reward, they incur little penalty and the agent accepts them all and is thoroughly mugged. Oops.

We could try to repair #3 by translating the curve leftwards, if you will - reducing the prior probability down to something safe even at very small values. For example, if a #3 agent would take a dollar in exchange for a penny and its prior is 2%, it can be mugged, and one would repair by forcing the prior down to <1% so now it is either indifferent or rejects outright the mugging. But alas, as most ad hoc interventions do, this doesn’t fix the problem entirely. Now our mugger can simply make 100 billion offers for slivers of a penny rather than dollars. Each deal will seem like a good deal, yet add up to ruin. Not a good system. Worse, any adjustment to the prior based on updates from the mugger’s failure to deliver would seem to leave this hole intact! Suppose they run through the 100 billion offers and the next day the mugger is nowhere to be seen. So the agent cuts the prior in half. Now the mugger can come back and make offers for half slivers of pennies…

If our agent is a #1 agent, matters are a little different.

A #1 agent does not have the disaggregation problem of a #3 agent; whether it’s one big offer or a billion small offers, the expected utilities sum the same no matter how they are divvied up.

Does it have the escalation problem of a #2 agent? It would seem not to; the question of whether it would take a large reward is the same as the question of whether it would take the small reward - would it accept any mugging? It all depends on how far leftwards the line starts off, on whether the equation looks like or or . The degree that the constant differs from 1 is the degree to which our agent is prejudiced towards or against mugging. If the constant is 0.9 then it will accept no muggings, of course, since all rewards come pre-assessed as negative-sum offers; if the constant is 1.1, then vice versa.

So with a bad constant, our #1 agent could be even worse than a #2 or #3 agent! But actually, it’s better. It will make errors and accept some muggings, but each mugging the agent will learn. Each time the mugger fails to deliver, the constant will shrink until it reaches the magic 1 and then the agent will start rejecting muggings. Its losses are finite and limited by how large the constant starts off with, so it doesn’t matter what that constant is. It could be lower than 1, since our agent could learn to increase its constant as well as decrease; if the mugger really is a Dark Lord of the Matrix, the mugger simply has to offer a little proof and our agent will be happy to transact with him.

Considering all the possibilities, the agent with the fewest problems is #1, and we have our answer to how to avoid Pascal’s Mugging: choose a prior which decreases in simple proportion to the offer.

Now, it’s obvious that you don’t want to scale any prior probability more or less than the reward because either way involves you in difficulties. But do we have any non-ad hoc reason to specifically scale the size of the reward by 1/n, to regard the complexity as equal to the size?

I think there may be a Kolmogorov complexity argument that size does equal complexity, and welcome anyone capable of formally dealing with it. My intuition goes: Kolmogorov complexity is about lengths of strings in some language which map onto outputs. By the pigeonhole principle, not all outputs have short inputs. But various languages will favor different outputs with the scarce short inputs, much like a picture compressor won’t do so hot on music files. 3^^^^3 has a short representation in the usual mathematical language, but that language is just one of indefinitely many possible mathematical languages; there are languages where 3^^^^3 has a very long representation, one 3^^^^3 long even, or longer still! Just like there are inputs to zip which compress very well and inputs which .

Now, given that our particular language favors 3^^^^3 with such a short encoding rather than many other numbers relatively nearby to 3^^^^3, doesn’t Pascal’s mugging start looking like an issue with our language favoring certain numbers? It’s not necessary to favor 3^^^^3, other languages don’t favor it or actively disfavor it. Those other languages would seem to be as valid and logically true as the current one, just the proofs or programs may be longer and written differently of course.

So, what do you get when you abstract away from the particular outputs favored by a language? When you add together and average the languages with long encodings and the ones with short encodings for 3^^^^3? What’s the length of the average program for 3^^^^3? I suggest it’s 3^^^^3, with every language that gives it a shorter encoding counterbalanced by a language with an exactly longer encoding.

An example of : has written a which computes the prime , which has over 2 million digits - and does so in a few seconds. Other examples are pretty much anything written for the demoscene, which prized writing complex graphics & audio in just a few hundred bytes.

# Optimal Sequential Decision Making

TODO

Returning to Yudkowsky’s original hypothetical, I, for one, have no difficulty agreeing that one should pay the mugger his $5 if and only if one already has wealth on the order of$3↑↑↑3; after all, has it not always, in all eras and decision theories, been the noblesse oblige of the wealthy to be generous with those less fortunate?

For Pascal’s mugging, consider a MDP version: You have linear utility in money, and you want to maximize your expected total wealth at the end of the game. You can either ‘invest’ your money and receive, say, 7% interest on it (which is +EV), or you can take a gamble with Pascal’s mugger: Pascal’s mugger demands $5 but swears he’ll return p *$5 * 1.10 for whatever p you estimate him at, which is +EV and also has greater EV than merely investing your money (eg if you believe the mugger has 1% probability of paying off, then he’ll pay $550 for an EV of$5.5 while that $5 would only earn$5.35 when invested).

This can be solved by backwards induction as two mutually recursive functions (a payoff and then a maximizing value function), and efficiently implemented by memoization/dynamic programming:

# devtools::install_github("hadley/memoise")
library(memoise)

muggerFee <- 5
payoffMultiplier <- 100
payoffProbability <- payoffMultiplier^-1
payoff <- (payoffMultiplier * muggerFee) * 1.10
investmentPayoff <- 1.07

f <- function(t, wealth, pascal) {
ev <-  if (pascal && wealth>=muggerFee) { payoffProbability     * mV(t-1, payoff+((wealth-muggerFee)*investmentPayoff)) +
(1-payoffProbability) * mV(t-1, (wealth-muggerFee)*investmentPayoff) }
else { 1 * mV(t-1, (wealth * investmentPayoff)) }
## round to pennies; also reduces the state space
return(round(digits=2,ev)) }
mf <- memoise(f)
V <- function(t,wealth, verbose=FALSE) {
if (t==0) { return(wealth) }
else { pascalV <- mf(t, wealth, TRUE);
investV <- mf(t, wealth, FALSE)
if (verbose) { cat(pascalV, investV) }
return(max(pascalV, investV)) }
}
mV <- memoise(V)
mV(10, 10)

mV(1, 5, verbose=TRUE)
# 5.5 5.35[1] 5.5
mV(2, 5, verbose=TRUE)
# 5.8865 5.8745[1] 5.8865
mV(3, 5, verbose=TRUE)
# 6.300055 6.287215[1] 6.300055
mV(4, 5, verbose=TRUE)
# 6.74255885 6.72882005[1] 6.74255885
mV(5, 5, verbose=TRUE)
# 7.21603797 7.20133745[1] 7.21603797
mV(6, 5, verbose=TRUE)
# 7.72266063 7.70693108[1] 7.72266063
mV(7, 5, verbose=TRUE)
# 8.26474687 8.24791625[1] 8.26474687
mV(8, 5, verbose=TRUE)
# 8.84477915 8.82677039[1] 8.84477915
mV(9, 5, verbose=TRUE)
# 9.46541369 9.44614432[1] 9.46541369
mV(10, 5, verbose=TRUE)
# 10.1294927 10.1088744[1] 10.1294927
sapply(0:200, function(n) { print(n); mV(n, 5, verbose=TRUE) })
# [1] 0
# [1] 1
# [1] 2
# [1] 3
# [1] 4
# [1] 5
# [1] 6
# [1] 7
# [1] 8
# [1] 9
# [1] 10
# [1] 11
# 10.8400571 10.8179956[1] 12
# 11.6003611 11.5767553[1] 13
# 12.4138864 12.3886282[1] 14

log utility:

import           Data.Vector (Vector)
import qualified Data.Vector as V

type Rounds = Int
type Cents = Int

data Move = Bet | Invest
deriving (Show, Eq, Ord)

data Outcome = Outcome {
outcomeValue :: Double, -- utility at end of game
outcomeMoves :: [Move] -- A log of moves taken (along the optimistic path)
}
deriving (Show)

instance Eq Outcome where
a == b = outcomeValue a == outcomeValue b

instance Ord Outcome where
a <= b = outcomeValue a <= outcomeValue b

addMove :: Move -> Outcome -> Outcome
addMove m o = o { outcomeMoves = m : outcomeMoves o }

p :: Double
p = 1.1

value :: (Rounds -> Cents -> Outcome) -> Rounds -> Cents -> Outcome
value loop 0 c = Outcome (log $0.01 + fromIntegral c) [] value loop n c | c < 500 = -- Always invest when you have less than$5
addMove Invest $loop (n-1) (round$ cc * 1.07)
| otherwise = maximum [
-- Invest
addMove Invest $loop (n-1) (round$ cc * 1.07),
-- Bet
let success = loop (n-1) (round $500 * 1.1 * p + (cc - 500) * 1.07) failure = loop (n-1) (round$ (cc - 500) * 1.07)
in Outcome { outcomeValue = (1/p) * outcomeValue success + (1 - 1/p) * outcomeValue failure,
outcomeMoves = Bet : outcomeMoves success }]
where
cc = fromIntegral c :: Double

memoised :: Rounds -> Cents -> Outcome
memoised = go
where
go r c
| r >= maxRounds = error "rounds overflow"
| c >= maxCents = error "cents overflow"
| otherwise = table V.! r V.! c
table = V.generate maxRounds (\r -> V.generate maxCents (\c -> value go r c))
maxRounds = 100
maxCents = 1000000

-- Interesting things happen with low p (1.1) starting with $10, if we set utility = log wealth -- λ> memoised 1 1000 -- Outcome {outcomeValue = 6.9754232732066725, outcomeMoves = [Invest]} -- λ> memoised 2 1000 -- Outcome {outcomeValue = 7.043168649574656, outcomeMoves = [Invest,Invest]} -- λ> memoised 3 1000 -- Outcome {outcomeValue = 7.110704286210814, outcomeMoves = [Invest,Invest,Invest]} -- λ> memoised 4 1000 -- Outcome {outcomeValue = 7.1785531114996735, outcomeMoves = [Invest,Invest,Invest,Invest]} -- λ> memoised 5 1000 -- Outcome {outcomeValue = 7.247100293521016, outcomeMoves = [Invest,Invest,Invest,Bet,Bet]} -- λ> memoised 6 1000 -- Outcome {outcomeValue = 7.316358291256226, outcomeMoves = [Invest,Invest,Invest,Bet,Bet,Bet]} -- λ> memoised 10 1000 -- Outcome {outcomeValue = 7.595783603684063, outcomeMoves = [Invest,Invest,Invest,Invest,Bet,Bet,Bet,Bet,Bet,Bet]} -- λ> memoised 20 1000 -- Outcome {outcomeValue = 8.299070043355542, outcomeMoves = [Invest,Invest,Invest,Invest,Invest,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} -- λ> memoised 30 1000 -- Outcome {outcomeValue = 8.996111590438689, outcomeMoves = [Invest,Invest,Invest,Invest,Invest,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} -- With higher p it prefers to invest constantly Linear utility: import Data.Random import Data.Random.Distribution.Categorical (categorical) import Data.Random.Sample (sample) import Data.Vector (Vector) import qualified Data.Vector as V import System.IO.Unsafe import Text.Pretty.Simple (pPrint) type Rounds = Int type Cents = Int type Utility = Double data Move = Bet | Invest deriving (Show, Eq, Ord) data Outcome = Outcome { outcomeValue :: Utility, -- utility at end of game outcomeMovesOptimistic :: [Move], outcomeMovesTypical :: [Move] } deriving (Show) instance Eq Outcome where a == b = outcomeValue a == outcomeValue b instance Ord Outcome where a <= b = outcomeValue a <= outcomeValue b addMove :: Move -> Outcome -> Outcome addMove m o = o { outcomeMovesOptimistic = m : outcomeMovesOptimistic o, outcomeMovesTypical = m : outcomeMovesTypical o } mix :: Double -> Outcome -> Outcome -> Outcome mix f success failure = Outcome { outcomeValue = f * outcomeValue success + (1 - f) * outcomeValue failure, outcomeMovesOptimistic = outcomeMovesOptimistic success, outcomeMovesTypical = choice (outcomeMovesTypical success) (outcomeMovesTypical failure) } where choice a b = unsafePerformIO (sample$ categorical ([(f, a), (1-f, b)]))

value :: Double -> (Cents -> Utility) -> (Rounds -> Cents -> Outcome) -> Rounds -> Cents -> Outcome
value p utility loop 0 c = Outcome (utility c) [] []
value p utility loop n c
| c < 500 =
-- Always invest when you have less than $5 addMove Invest$ loop (n-1) (round $cc * 1.07) | otherwise = maximum [ -- Invest addMove Invest$ loop (n-1) (round $cc * 1.07), -- Bet let success = loop (n-1) (round$ 500 * 1.1 * p + (cc - 500) * 1.07)
failure = loop (n-1) (round $(cc - 500) * 1.07) in addMove Bet$ mix (1/p) success failure]
where
cc = fromIntegral c :: Double

memoised :: Double -> (Cents -> Utility) -> Rounds -> Cents -> Outcome
memoised p utility = go
where
go r c
| r >= maxRounds = error "rounds overflow"
| c >= maxCents = error "cents overflow"
| otherwise = table V.! r V.! c
table = V.generate maxRounds (\r -> V.generate maxCents (\c -> value p utility go r c))
maxRounds = 100
maxCents = 10000000

linearUtility :: Cents -> Utility
linearUtility = fromIntegral

-- λ> memoised 100 linearUtility 20 1000
-- Outcome {outcomeValue = 3990.0001805126485,
--          outcomeMovesOptimistic = [Invest,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet],
--          outcomeMovesTypical = [Invest,Bet,Invest,Invest,Invest,Invest,Invest,Bet,Invest,Invest,Invest,Invest,Bet,Invest,Invest,Invest,Invest,Invest,Invest,Invest]}
-- λ> memoised 100 linearUtility 10 1000
-- Outcome {outcomeValue = 2023.422516,
--          outcomeMovesOptimistic = [Invest,Invest,Invest,Invest,Bet,Bet,Bet,Bet,Bet,Bet],
--          outcomeMovesTypical = [Invest,Invest,Invest,Invest,Bet,Invest,Invest,Bet,Bet,Invest]}
~~

--------

-- Pascal's Mugging: Solving the MDP using Dynamic Programming experiments

{- In Pascal's mugging, a +EV but extremely unlikely long-shot bet is offered to you. Greedy one-step EV maximization says to take it, but this seems wrong (potentially risking gambler's ruin, for example). The Kelly criterion says to not take it (unless the price is extremely small, and increasingly small in proportion to how unlikely it is), however, we probably do not have logarithmic utility in wealth as is required for Kelly to be optimal.

In reality, we face a sequential decision procedure problem: we are acting over many time-steps and so taking the mugging incurs opportunity cost. Optimal policies in MDPs can produce Kelly-*like* behavior without actually requiring any of the commitments of the Kelly criterion.

To make a Pascal's mugging MDP, extend the mugging to an arbitrary _p_. Let's guarantee that the mugging long-shot bet will *always* be +EV, making it as challenging as possible, by inverting the _p_ and adding on 10% as a return. As an alternative, one can 'invest' one's money in an ordinary generic action which returns 7% (loose analogy to stock market indexes), which is also +EV, but still ensures betting > investing.
The mugger demands a fixed number of dollars, say $5, each time. One starts with a certain number of dollars. I use$10 (in cents, so 1000 cents) for no particular reason, which ensures that one can take the bet twice.
This runs for _t_ rounds, and at the final round _t_=0, one earns linear (or optionally, log) utility in $. This forms a MDP. For example, a MDP of t=20, p=100, w=1000, m=500 with 2 actions each turn and 3 possible outcomes (invest / bet & win / bet & lose). This MDP can be solved by backwards induction from _t_=0, with dynamic programming/memoization for efficiency. For each scenario, we report the expected value of the optimal policy, the sequence of moves in the 'optimistic' case where one always wins the bet (if one takes the bet), the 'pessimistic' modal case where one always loses (as would be the case for interesting _p_ like 1/1 billion etc), and a random sampled trajectory. Observations for _t_=1-20, log utility: as expected, one always invests. Betting is never the optimal move. Uninteresting. Observations for _t_=1-20, linear utility: the longer the game and the bigger _t_, the rarer betting seems to become. For short games, the optimal move is to always bet (eg t=1-2). For longer games, the pessimistic strategy is attempt bets early on, and fall back to investing; the optimal strategy does depend on _p_ in hard to understand ways. Very likely bets (low _p_ such as 1/10th) appear to encourage early betting. For the longest games (t=20 so far), it seems like optimal bet attempts may be gradually pushed back through the rounds. In the 'optimistic' scenarios, betting begets betting: when one receives a windfall, it seems one is more interested in EV-maximizing (as makes sense: Kelly-like behavior). Speculation: as _p_ increases, and especially as rounds/time increases, betting becomes increasingly rare. As t increases into the thousands or billions, corresponding to human or civilizational lifetimes, bets become vanishingly unlikely, and only become worth taking when wealth is extremely large (Kelly-like). Hence, there may be no Pascal's mugging paradox in the first place: the strictly literal total-EV-maximizing optimal strategy already ignores astronomically-unlikely bets as generally a bad use of limited resources unless one is already astronomically wealthy. -} -- dependencies: 'vector', 'random-fu', 'uglymemo', 'memoize' --$ ghc -O3 -fforce-recomp -optl-s --make mugging.hs  && time ./mugging

-- Example: P=1/100, linear utility, 10 rounds, $10 starting capital: -- λ> memoised3 100 linearUtility 10 1000 -- Outcome {outcomeValue = 2023.422516, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} {- Output: Simplified (optimal strategy assuming modal scenario where one loses the mugging/bet each time): Rounds: 1; P: 10; [𝗕𝗲𝘁] Rounds: 1; P: 100; [𝗕𝗲𝘁] Rounds: 1; P: 1000; [𝗕𝗲𝘁] Rounds: 1; P: 10000; [𝗕𝗲𝘁] Rounds: 1; P: 100000; [𝗕𝗲𝘁] Rounds: 1; P: 1000000; [𝗕𝗲𝘁] Rounds: 1; P: 10000000; [𝗕𝗲𝘁] Rounds: 1; P: 100000000; [𝗕𝗲𝘁] Rounds: 1; P: 1000000000; [𝗕𝗲𝘁] Rounds: 1; P: 10000000000; [𝗕𝗲𝘁] Rounds: 1; P: 100000000000; [𝗕𝗲𝘁] Rounds: 1; P: 1000000000000; [𝗕𝗲𝘁] Rounds: 2; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 100; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 1000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 10000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 100000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 1000000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 10000000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 100000000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 1000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 10000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 100000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 2; P: 1000000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 3; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 100; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 1000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 10000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 100000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 1000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 10000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 100000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 1000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 10000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 100000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 3; P: 1000000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 4; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 100; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 1000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 10000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 100000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 1000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 10000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 100000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 1000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 10000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 100000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 4; P: 1000000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv] Rounds: 5; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 100; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 1000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 10000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 100000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 1000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 10000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 100000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 1000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 10000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 100000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 5; P: 1000000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 6; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 100; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 1000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 10000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 100000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 1000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 10000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 100000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 1000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 10000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 100000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 6; P: 1000000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 7; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 100; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 1000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 10000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 100000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 1000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 10000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 100000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 1000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 10000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 100000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 7; P: 1000000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 100; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 1000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 10000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 100000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 1000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 10000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 100000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 1000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 10000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 100000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 8; P: 1000000000000; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 9; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 9; P: 100; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 1000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 10000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 100000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 1000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 10000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 100000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 1000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 10000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 100000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 9; P: 1000000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁] Rounds: 10; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 10; P: 100; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 1000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 10000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 100000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 1000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 10000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 100000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 1000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 10000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 100000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 10; P: 1000000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv] Rounds: 11; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 11; P: 100; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 1000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 10000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 100000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 1000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 10000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 100000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 1000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 10000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 100000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 11; P: 1000000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 12; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 12; P: 100; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 1000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 10000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 100000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 1000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 10000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 100000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 1000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 10000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 100000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 12; P: 1000000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 13; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 13; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 1000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 10000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 100000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 1000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 10000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 100000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 1000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 10000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 100000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 13; P: 1000000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁] Rounds: 14; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 14; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 1000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 10000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 100000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 1000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 10000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 100000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 1000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 10000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 100000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 14; P: 1000000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv] Rounds: 15; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 15; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 1000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 10000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 100000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 1000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 10000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 100000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 1000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 10000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 100000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 15; P: 1000000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv] Rounds: 16; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 16; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 1000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 10000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 100000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 1000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 10000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 100000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 1000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 10000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 100000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 16; P: 1000000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv] Rounds: 17; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 17; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 1000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 10000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 100000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 1000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 10000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 100000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 1000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 10000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 100000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 17; P: 1000000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv] Rounds: 18; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 1000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 10000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 100000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 1000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 10000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 100000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 1000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 10000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 100000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 18; P: 1000000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 1000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 10000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 100000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 1000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 10000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 100000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 1000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 10000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 100000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 19; P: 1000000000000; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv] Rounds: 20; P: 10; [𝗕𝗲𝘁,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 20; P: 100; [Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv] Rounds: 20; P: 1000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Rounds: 20; P: 10000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Rounds: 20; P: 100000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Rounds: 20; P: 1000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Rounds: 20; P: 10000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Rounds: 20; P: 100000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Rounds: 20; P: 100000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Rounds: 20; P: 1000000000; [Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,𝗕𝗲𝘁,Inv,Inv,𝗕𝗲𝘁] Full output: Rounds: 1; P: 10; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 100; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 1000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 10000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 100000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 1000000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 10000000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 100000000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 1000000000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 10000000000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 100000000000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 1; P: 1000000000000; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 2; P: 10; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 100; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 1000; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 10000; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 100000; Outcome {outcomeValue = 1175.5000000000002, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 1000000; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 10000000; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 100000000; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 1000000000; Outcome {outcomeValue = 1175.5000000000002, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 10000000000; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 100000000000; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 2; P: 1000000000000; Outcome {outcomeValue = 1175.500000000001, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 3; P: 10; Outcome {outcomeValue = 1261.0500000000002, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 100; Outcome {outcomeValue = 1258.4885, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 1000; Outcome {outcomeValue = 1258.2249850000003, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 10000; Outcome {outcomeValue = 1258.19799985, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 100000; Outcome {outcomeValue = 1258.1952999985003, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 1000000; Outcome {outcomeValue = 1258.1950299999849, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 10000000; Outcome {outcomeValue = 1258.1950029999998, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 100000000; Outcome {outcomeValue = 1258.1950002999997, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 1000000000; Outcome {outcomeValue = 1258.19500003, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 10000000000; Outcome {outcomeValue = 1258.1950000030001, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 100000000000; Outcome {outcomeValue = 1258.1950000003, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 3; P: 1000000000000; Outcome {outcomeValue = 1258.1950000000313, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 4; P: 10; Outcome {outcomeValue = 1352.295, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 100; Outcome {outcomeValue = 1347.0769500000001, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 1000; Outcome {outcomeValue = 1346.5299694999999, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 10000; Outcome {outcomeValue = 1346.474799695, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 100000; Outcome {outcomeValue = 1346.4692599969503, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 1000000; Outcome {outcomeValue = 1346.468710999969, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 10000000; Outcome {outcomeValue = 1346.4686560999999, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 100000000; Outcome {outcomeValue = 1346.4686506099997, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 1000000000; Outcome {outcomeValue = 1346.468650061, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 10000000000; Outcome {outcomeValue = 1346.4686500061002, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 100000000000; Outcome {outcomeValue = 1346.46865000061, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 4; P: 1000000000000; Outcome {outcomeValue = 1346.4686500000623, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 5; P: 10; Outcome {outcomeValue = 1449.7680000000003, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 100; Outcome {outcomeValue = 1441.65918, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 1000; Outcome {outcomeValue = 1440.8073418049999, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 10000; Outcome {outcomeValue = 1440.72103852805, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 100000; Outcome {outcomeValue = 1440.7124038952807, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 1000000; Outcome {outcomeValue = 1440.7115503899527, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 10000000; Outcome {outcomeValue = 1440.7114649389996, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 100000000; Outcome {outcomeValue = 1440.7114564438996, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 1000000000; Outcome {outcomeValue = 1440.7114555943901, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 10000000000; Outcome {outcomeValue = 1440.711455509439, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 100000000000; Outcome {outcomeValue = 1440.7114555009439, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 5; P: 1000000000000; Outcome {outcomeValue = 1440.7114555000967, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv]} Rounds: 6; P: 10; Outcome {outcomeValue = 1553.8500000000001, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 100; Outcome {outcomeValue = 1542.6530009999997, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 1000; Outcome {outcomeValue = 1541.4738720300002, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 10000; Outcome {outcomeValue = 1541.3544930903122, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 100000; Outcome {outcomeValue = 1541.3425693665035, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 1000000; Outcome {outcomeValue = 1541.3413889372346, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 10000000; Outcome {outcomeValue = 1541.3412705937299, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 100000000; Outcome {outcomeValue = 1541.3412586993725, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 1000000000; Outcome {outcomeValue = 1541.3412575169377, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 10000000000; Outcome {outcomeValue = 1541.3412573981936, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 100000000000; Outcome {outcomeValue = 1541.3412573863193, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 6; P: 1000000000000; Outcome {outcomeValue = 1541.3412573851344, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 7; P: 10; Outcome {outcomeValue = 1665.1391000000003, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 100; Outcome {outcomeValue = 1650.5196089999, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 1000; Outcome {outcomeValue = 1648.9777280920002, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 10000; Outcome {outcomeValue = 1648.8224804209394, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 100000; Outcome {outcomeValue = 1648.8068581206098, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 1000000; Outcome {outcomeValue = 1648.8053168128254, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 10000000; Outcome {outcomeValue = 1648.8051625812905, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 100000000; Outcome {outcomeValue = 1648.8051471181288, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 1000000000; Outcome {outcomeValue = 1648.8051455738137, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 10000000000; Outcome {outcomeValue = 1648.8051454191814, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 100000000000; Outcome {outcomeValue = 1648.8051454036677, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 7; P: 1000000000000; Outcome {outcomeValue = 1648.805145402124, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 10; Outcome {outcomeValue = 1784.8319471000004, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 100; Outcome {outcomeValue = 1766.705954248005, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 1000; Outcome {outcomeValue = 1764.7955146860031, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 10000; Outcome {outcomeValue = 1764.6030608669125, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 100000; Outcome {outcomeValue = 1764.5836261877691, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 1000000; Outcome {outcomeValue = 1764.5817186197064, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 10000000; Outcome {outcomeValue = 1764.581526961981, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 100000000; Outcome {outcomeValue = 1764.5815077061975, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 1000000000; Outcome {outcomeValue = 1764.5815057926206, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 10000000000; Outcome {outcomeValue = 1764.5815056014624, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 100000000000; Outcome {outcomeValue = 1764.5815055822154, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 1000000000000; Outcome {outcomeValue = 1764.5815055803018, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 9; P: 10; Outcome {outcomeValue = 1912.6880766100007, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 9; P: 100; Outcome {outcomeValue = 1890.7847000000002, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 1000; Outcome {outcomeValue = 1890.473469, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 10000; Outcome {outcomeValue = 1890.4414468599998, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 100000; Outcome {outcomeValue = 1890.4381646865004, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 1000000; Outcome {outcomeValue = 1890.4378414686498, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 10000000; Outcome {outcomeValue = 1890.4378090468651, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 100000000; Outcome {outcomeValue = 1890.4378058546863, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 1000000000; Outcome {outcomeValue = 1890.437805535469, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 10000000000; Outcome {outcomeValue = 1890.4378055035468, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 100000000000; Outcome {outcomeValue = 1890.4378055003547, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 9; P: 1000000000000; Outcome {outcomeValue = 1890.4378055000361, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet]} Rounds: 10; P: 10; Outcome {outcomeValue = 2049.2672623980006, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 10; P: 100; Outcome {outcomeValue = 2023.422516, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 1000; Outcome {outcomeValue = 2022.681667015, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 10000; Outcome {outcomeValue = 2022.606870680016, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 100000; Outcome {outcomeValue = 2022.5992871101002, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 1000000; Outcome {outcomeValue = 2022.5985357114096, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 10000000; Outcome {outcomeValue = 2022.5984601711452, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 100000000; Outcome {outcomeValue = 2022.598452717114, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 1000000000; Outcome {outcomeValue = 2022.5984519677118, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 10000000000; Outcome {outcomeValue = 2022.5984518932714, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 100000000000; Outcome {outcomeValue = 2022.5984518858268, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 10; P: 1000000000000; Outcome {outcomeValue = 2022.598451885084, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Bet,Inv]} Rounds: 11; P: 10; Outcome {outcomeValue = 2195.191426151001, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 11; P: 100; Outcome {outcomeValue = 2167.2104209102995, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 1000; Outcome {outcomeValue = 2165.946741094001, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 10000; Outcome {outcomeValue = 2165.819280590932, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 100000; Outcome {outcomeValue = 2165.8065581221103, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 1000000; Outcome {outcomeValue = 2165.8052868128398, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 10000000; Outcome {outcomeValue = 2165.805159381291, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 100000000; Outcome {outcomeValue = 2165.8051467981286, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 1000000000; Outcome {outcomeValue = 2165.8051455418135, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 10000000000; Outcome {outcomeValue = 2165.8051454158813, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 100000000000; Outcome {outcomeValue = 2165.8051454033475, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 11; P: 1000000000000; Outcome {outcomeValue = 2165.805145402092, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 12; P: 10; Outcome {outcomeValue = 2351.9165039234813, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 12; P: 100; Outcome {outcomeValue = 2319.0337360690037, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 1000; Outcome {outcomeValue = 2317.278498203006, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 10000; Outcome {outcomeValue = 2317.1012607419207, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 100000; Outcome {outcomeValue = 2317.08347618602, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 1000000; Outcome {outcomeValue = 2317.0817026196914, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 10000000; Outcome {outcomeValue = 2317.0815251619815, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 100000000; Outcome {outcomeValue = 2317.0815075261976, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 1000000000; Outcome {outcomeValue = 2317.081505775621, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 10000000000; Outcome {outcomeValue = 2317.081505599562, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 100000000000; Outcome {outcomeValue = 2317.081505582036, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 12; P: 1000000000000; Outcome {outcomeValue = 2317.0815055802855, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 13; P: 10; Outcome {outcomeValue = 2519.3151394141323, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 13; P: 100; Outcome {outcomeValue = 2482.7484799131007, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 1000; Outcome {outcomeValue = 2480.339414096994, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 10000; Outcome {outcomeValue = 2480.098847560943, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 100000; Outcome {outcomeValue = 2480.07469481951, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 1000000; Outcome {outcomeValue = 2480.0722934825562, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 10000000; Outcome {outcomeValue = 2480.072052548263, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 100000000; Outcome {outcomeValue = 2480.0720283248256, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 1000000000; Outcome {outcomeValue = 2480.072025917484, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 10000000000; Outcome {outcomeValue = 2480.0720256767486, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 100000000000; Outcome {outcomeValue = 2480.072025652594, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 13; P: 1000000000000; Outcome {outcomeValue = 2480.0720256501772, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet]} Rounds: 14; P: 10; Outcome {outcomeValue = 2698.1303739295427, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 14; P: 100; Outcome {outcomeValue = 2656.914591151875, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 1000; Outcome {outcomeValue = 2653.9384352179895, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 10000; Outcome {outcomeValue = 2653.6403543919414, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 100000; Outcome {outcomeValue = 2653.610375552121, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 1000000; Outcome {outcomeValue = 2653.6073995562874, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 10000000; Outcome {outcomeValue = 2653.6071006556413, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 100000000; Outcome {outcomeValue = 2653.6070707555627, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 1000000000; Outcome {outcomeValue = 2653.607067776558, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 10000000000; Outcome {outcomeValue = 2653.607067478656, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 100000000000; Outcome {outcomeValue = 2653.6070674487255, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 14; P: 1000000000000; Outcome {outcomeValue = 2653.607067445736, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 15; P: 10; Outcome {outcomeValue = 2890.0112223224787, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 15; P: 100; Outcome {outcomeValue = 2843.273967269926, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 1000; Outcome {outcomeValue = 2839.68981803449, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 10000; Outcome {outcomeValue = 2839.329697759892, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 100000; Outcome {outcomeValue = 2839.2935599361, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 1000000; Outcome {outcomeValue = 2839.2899629951835, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 10000000; Outcome {outcomeValue = 2839.2896022995365, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 100000000; Outcome {outcomeValue = 2839.289566169952, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 1000000000; Outcome {outcomeValue = 2839.289562565995, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 10000000000; Outcome {outcomeValue = 2839.2895622067003, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 100000000000; Outcome {outcomeValue = 2839.2895621705884, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 15; P: 1000000000000; Outcome {outcomeValue = 2839.289562166983, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 16; P: 10; Outcome {outcomeValue = 3094.996554866296, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 16; P: 100; Outcome {outcomeValue = 3042.6721923794657, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 1000; Outcome {outcomeValue = 3038.4430685771395, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 10000; Outcome {outcomeValue = 3038.0173281150187, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 100000; Outcome {outcomeValue = 3037.974563027051, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 1000000; Outcome {outcomeValue = 3037.9703063047996, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 10000000; Outcome {outcomeValue = 3037.969879030503, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 100000000; Outcome {outcomeValue = 3037.969836253049, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 1000000000; Outcome {outcomeValue = 3037.969831991305, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 10000000000; Outcome {outcomeValue = 3037.969831565731, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 100000000000; Outcome {outcomeValue = 3037.9698315229934, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 1000000000000; Outcome {outcomeValue = 3037.9698315187175, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 17; P: 10; Outcome {outcomeValue = 3314.775432025319, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100; Outcome {outcomeValue = 3256.0407800662133, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000; Outcome {outcomeValue = 3251.109497223838, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000; Outcome {outcomeValue = 3250.6129767211323, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100000; Outcome {outcomeValue = 3250.5632279349134, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000000; Outcome {outcomeValue = 3250.558272796092, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000000; Outcome {outcomeValue = 3250.5577750796383, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100000000; Outcome {outcomeValue = 3250.5577252479625, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000000000; Outcome {outcomeValue = 3250.5577202757972, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000000000; Outcome {outcomeValue = 3250.5577197798802, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100000000000; Outcome {outcomeValue = 3250.557719730057, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000000000000; Outcome {outcomeValue = 3250.557719725075, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 18; P: 10; Outcome {outcomeValue = 3549.5471941950427, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 100; Outcome {outcomeValue = 3484.342551847106, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 1000; Outcome {outcomeValue = 3478.6612866299793, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 10000; Outcome {outcomeValue = 3478.0903606655224, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 100000; Outcome {outcomeValue = 3478.0330963864562, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 1000000; Outcome {outcomeValue = 3478.027396641777, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 10000000; Outcome {outcomeValue = 3478.026823864213, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 100000000; Outcome {outcomeValue = 3478.02676645642, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 1000000000; Outcome {outcomeValue = 3478.026760740644, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 10000000000; Outcome {outcomeValue = 3478.0267601689648, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 100000000000; Outcome {outcomeValue = 3478.0267601116157, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 1000000000000; Outcome {outcomeValue = 3478.0267601058754, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 10; Outcome {outcomeValue = 3801.1633277001265, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 100; Outcome {outcomeValue = 3728.6191535183216, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 1000; Outcome {outcomeValue = 3722.1425139023795, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 10000; Outcome {outcomeValue = 3721.491189468131, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 100000; Outcome {outcomeValue = 3721.4274152634634, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 1000000; Outcome {outcomeValue = 3721.421095529733, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 10000000; Outcome {outcomeValue = 3721.420462153009, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 100000000; Outcome {outcomeValue = 3721.4203987152987, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 1000000000; Outcome {outcomeValue = 3721.4203923825307, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 10000000000; Outcome {outcomeValue = 3721.420391751055, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 100000000000; Outcome {outcomeValue = 3721.420391687695, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 1000000000000; Outcome {outcomeValue = 3721.4203916813563, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 20; P: 10; Outcome {outcomeValue = 4069.9240039858764, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 20; P: 100; Outcome {outcomeValue = 3990.0001805126485, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 20; P: 1000; Outcome {outcomeValue = 3983.5192518070403, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 10000; Outcome {outcomeValue = 3983.0037521275003, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 100000; Outcome {outcomeValue = 3982.9521354952763, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 1000000; Outcome {outcomeValue = 3982.9469445523428, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 10000000; Outcome {outcomeValue = 3982.946428555262, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 100000000; Outcome {outcomeValue = 3982.9463770755247, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 1000000000; Outcome {outcomeValue = 3982.946371895554, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 10000000000; Outcome {outcomeValue = 3982.9463713792557, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 100000000000; Outcome {outcomeValue = 3982.9463713275964, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 20; P: 1000000000000; Outcome {outcomeValue = 3982.9463713224627, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet]} Rounds: 21; P: 10; Outcome {outcomeValue = 4357.881683820732, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 21; P: 100; Outcome {outcomeValue = 4269.677279499589, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 21; P: 1000; Outcome {outcomeValue = 4262.215553265326, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 10000; Outcome {outcomeValue = 4261.610091871682, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 100000; Outcome {outcomeValue = 4261.549389571319, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 1000000; Outcome {outcomeValue = 4261.543291960912, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 10000000; Outcome {outcomeValue = 4261.542684596129, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 100000000; Outcome {outcomeValue = 4261.542624079611, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 1000000000; Outcome {outcomeValue = 4261.542617988963, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 10000000000; Outcome {outcomeValue = 4261.542617381798, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 100000000000; Outcome {outcomeValue = 4261.542617321138, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 21; P: 1000000000000; Outcome {outcomeValue = 4261.542617315094, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Bet,Inv]} Rounds: 22; P: 10; Outcome {outcomeValue = 4665.292582720691, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 22; P: 100; Outcome {outcomeValue = 4568.933421325381, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 22; P: 1000; Outcome {outcomeValue = 4560.519544309388, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 10000; Outcome {outcomeValue = 4559.811992762625, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 100000; Outcome {outcomeValue = 4559.7412996453295, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 1000000; Outcome {outcomeValue = 4559.734209968522, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 10000000; Outcome {outcomeValue = 4559.73350589689, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 100000000; Outcome {outcomeValue = 4559.733435579685, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 1000000000; Outcome {outcomeValue = 4559.73342852597, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 10000000000; Outcome {outcomeValue = 4559.7334278196995, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 22; P: 100000000000; Outcome {outcomeValue = 4559.733427749519, outcomeMovesOptimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet], outcomeMovesSample = [Inv,Inv,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Bet]} Rounds: 16; P: 1000000000000000; Outcome {outcomeValue = 3037.969831518245, outcomeMovesOptimistic = [Inv,Bet,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 16; P: 1000000000000; Outcome {outcomeValue = 3037.9698315187175, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 15; P: 1000; Outcome {outcomeValue = 2839.68981803449, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 17; P: 100000000; Outcome {outcomeValue = 3250.5577252479625, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100000; Outcome {outcomeValue = 3250.5632279349134, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000000; Outcome {outcomeValue = 3250.558272796092, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000; Outcome {outcomeValue = 3250.6129767211323, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000000000; Outcome {outcomeValue = 3250.5577202757972, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000000000; Outcome {outcomeValue = 3250.5577197798802, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100000000000; Outcome {outcomeValue = 3250.557719730057, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10; Outcome {outcomeValue = 3314.775432025319, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000000; Outcome {outcomeValue = 3250.5577750796383, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000000000000; Outcome {outcomeValue = 3250.557719725075, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100; Outcome {outcomeValue = 3256.0407800662133, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000; Outcome {outcomeValue = 3251.109497223838, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 100000000000000; Outcome {outcomeValue = 3250.5577197245298, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Inv,Inv,Bet,Bet,Bet,Inv,Inv,Inv,Bet,Bet,Bet,Inv,Inv], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000000000000; Outcome {outcomeValue = 3250.557719724574, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 1000000000000000; Outcome {outcomeValue = 3250.557719724522, outcomeMovesOptimistic = [Inv,Bet,Inv,Inv,Bet,Bet,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10000000000000000; Outcome {outcomeValue = 3250.5577197245198, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Inv], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv]} Rounds: 10; P: 10; Outcome {outcomeValue = 2049.2672623980006, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 11; P: 10; Outcome {outcomeValue = 2195.191426151001, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 12; P: 10; Outcome {outcomeValue = 2351.9165039234813, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 13; P: 10; Outcome {outcomeValue = 2519.3151394141323, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 14; P: 10; Outcome {outcomeValue = 2698.1303739295427, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 15; P: 10; Outcome {outcomeValue = 2890.0112223224787, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 16; P: 10; Outcome {outcomeValue = 3094.996554866296, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 17; P: 10; Outcome {outcomeValue = 3314.775432025319, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 18; P: 10; Outcome {outcomeValue = 3549.5471941950427, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 19; P: 10; Outcome {outcomeValue = 3801.1633277001265, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 1; P: 10; Outcome {outcomeValue = 1085.0, outcomeMovesOptimistic = [Bet], outcomeMovesPessimistic = [Bet], outcomeMovesSample = [Bet]} Rounds: 20; P: 10; Outcome {outcomeValue = 4069.9240039858764, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 21; P: 10; Outcome {outcomeValue = 4357.881683820732, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 22; P: 10; Outcome {outcomeValue = 4665.292582720691, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 23; P: 10; Outcome {outcomeValue = 4994.524693936235, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 24; P: 10; Outcome {outcomeValue = 5347.039909785561, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 25; P: 10; Outcome {outcomeValue = 5723.471774558708, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 26; P: 10; Outcome {outcomeValue = 6126.440628537147, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 27; P: 10; Outcome {outcomeValue = 6557.755357986062, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 28; P: 10; Outcome {outcomeValue = 7019.33157948173, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 29; P: 10; Outcome {outcomeValue = 7513.2396465544125, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 2; P: 10; Outcome {outcomeValue = 1175.5, outcomeMovesOptimistic = [Bet,Bet], outcomeMovesPessimistic = [Bet,Bet], outcomeMovesSample = [Bet,Bet]} Rounds: 30; P: 10; Outcome {outcomeValue = 8041.675689164191, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 31; P: 10; Outcome {outcomeValue = 8607.000947021235, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Be Rounds: 32; P: 10; Outcome {outcomeValue = 9212.145474319137, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 33; P: 10; Outcome {outcomeValue = 9860.708233641944, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 34; P: 10; Outcome {outcomeValue = 10554.567236945477, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 35; P: 10; Outcome {outcomeValue = 11296.976881618233, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 36; P: 10; Outcome {outcomeValue = 12091.366583538122, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 37; P: 10; Outcome {outcomeValue = 12941.358069635182, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 38; P: 10; Outcome {outcomeValue = 13850.84654328551, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 39; P: 10; Outcome {outcomeValue = 14823.995218871272, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 3; P: 10; Outcome {outcomeValue = 1261.0500000000002, outcomeMovesOptimistic = [Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv], outcomeMovesSample = [Bet,Bet,Inv]} Rounds: 40; P: 10; Outcome {outcomeValue = 15865.270895838501, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 41; P: 10; Outcome {outcomeValue = 16979.433772814802, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Inv,Bet,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 42; P: 10; Outcome {outcomeValue = 18171.597355359278, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 43; P: 10; Outcome {outcomeValue = 19447.208838892184, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 44; P: 10; Outcome {outcomeValue = 20812.109231723676, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 45; P: 10; Outcome {outcomeValue = 22272.554431611723, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 46; P: 10; Outcome {outcomeValue = 23835.21701567615, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 47; P: 10; Outcome {outcomeValue = 25507.284533930433, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 48; P: 10; Outcome {outcomeValue = 27296.39364815825, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 49; P: 10; Outcome {outcomeValue = 29210.7344248831, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 4; P: 10; Outcome {outcomeValue = 1352.295, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv]} Rounds: 50; P: 10; Outcome {outcomeValue = 31259.073253349154, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 51; P: 10; Outcome {outcomeValue = 33450.80149898732, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 52; P: 10; Outcome {outcomeValue = 35795.9507249662, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 53; P: 10; Outcome {outcomeValue = 38306.6662945432, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet]} Rounds: 54; P: 10; Outcome {outcomeValue = 40992.88024479775, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv]} Rounds: 55; P: 10; Outcome {outcomeValue = 43867.10679324395, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv]} Rounds: 56; P: 10; Outcome {outcomeValue = 46942.42722730838, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv]} Rounds: 57; P: 10; Outcome {outcomeValue = 50232.97188664501, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 58; P: 10; Outcome {outcomeValue = 53753.843472570996, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 59; P: 10; Outcome {outcomeValue = 57521.13433695601, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Be Rounds: 5; P: 10; Outcome {outcomeValue = 1449.7680000000003, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Bet,Bet,Bet]} Rounds: 60; P: 10; Outcome {outcomeValue = 61552.05866151852, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Be Rounds: 61; P: 10; Outcome {outcomeValue = 65865.13037198837, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 62; P: 10; Outcome {outcomeValue = 70480.7225315759, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 63; P: 10; Outcome {outcomeValue = 75419.31664835848, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 64; P: 10; Outcome {outcomeValue = 80703.52092194308, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 65; P: 10; Outcome {outcomeValue = 86357.50766005585, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 66; P: 10; Outcome {outcomeValue = 92407.1891075209, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 67; P: 10; Outcome {outcomeValue = 98880.27404315234, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 68; P: 10; Outcome {outcomeValue = 105806.3943279055, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 69; P: 10; Outcome {outcomeValue = 113217.9081859192, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 6; P: 10; Outcome {outcomeValue = 1553.8500000000001, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv]} Rounds: 70; P: 10; Outcome {outcomeValue = 121148.0968419349, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 71; P: 10; Outcome {outcomeValue = 129633.26186022675, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 72; P: 10; Outcome {outcomeValue = 138712.08166891677, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 73; P: 10; Outcome {outcomeValue = 148426.43595463567, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 74; P: 10; Outcome {outcomeValue = 158821.18873113784, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 75; P: 10; Outcome {outcomeValue = 169943.3927573727, outcomeMovesOptimistic = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Inv,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet]} Rounds: 7; P: 10; Outcome {outcomeValue = 1665.1391000000003, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv]} Rounds: 8; P: 10; Outcome {outcomeValue = 1784.8319471000004, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv]} Rounds: 9; P: 10; Outcome {outcomeValue = 1912.6880766100007, outcomeMovesOptimistic = [Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet,Bet], outcomeMovesPessimistic = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv], outcomeMovesSample = [Bet,Bet,Inv,Inv,Inv,Inv,Inv,Inv,Inv]} -} import Data.Random () import Data.Random.Distribution.Categorical (categorical) import Data.Random.Sample (sample) import qualified Data.Vector as V ((!), generate) import qualified Data.Function.Memoize as Memoize (memoFix2) import System.IO.Unsafe (unsafePerformIO) import Data.MemoUgly as Ugly (memo) import Control.Concurrent.Async (mapConcurrently) type Rounds = Int type Cents = Int type Utility = Double data Move = Bet | Inv deriving (Show, Eq, Ord) data Outcome = Outcome { outcomeValue :: Utility, -- utility at end of game outcomeMovesOptimistic :: [Move], outcomeMovesPessimistic :: [Move], outcomeMovesSample :: [Move] } deriving (Show) instance Eq Outcome where a == b = outcomeValue a == outcomeValue b instance Ord Outcome where a <= b = outcomeValue a <= outcomeValue b addMove :: Move -> Outcome -> Outcome addMove m o = o { outcomeMovesOptimistic = m : outcomeMovesOptimistic o, outcomeMovesPessimistic = m : outcomeMovesPessimistic o, outcomeMovesSample = m : outcomeMovesSample o } mix :: Double -> Outcome -> Outcome -> Outcome mix f success failure = -- WARNING: be careful with 'unsafePerformIO'; if used in the wrong place, it'll be cached/memoized -- and you won't get random samples for 'outcomeMovesSample'. unsafePerformIO$ do newSample <- choice (outcomeMovesSample success) (outcomeMovesSample failure)
return $Outcome { outcomeValue = f * outcomeValue success + (1 - f) * outcomeValue failure, outcomeMovesOptimistic = outcomeMovesOptimistic success, outcomeMovesPessimistic = outcomeMovesPessimistic failure, outcomeMovesSample = newSample } where choice a b = sample$ categorical ([(f, a), (1-f, b)])

value :: Double -> (Cents -> Utility) -> (Rounds -> Cents -> Outcome) -> Rounds -> Cents -> Outcome
value _ utility _ 0 c = Outcome (utility c) [] [] []
value p _ loop n c
| c < 500 =
-- Always invest when you have less than $5 addMove Inv$ loop (n-1) (round $cc * 1.07) | otherwise = maximum [ -- Invest addMove Inv$ loop (n-1) (round $cc * 1.07), -- Bet let success = loop (n-1) (round$ 500 * 1.1 * p + (cc - 500) * 1.07)
failure = loop (n-1) (round $(cc - 500) * 1.07) in addMove Bet$ mix (1/p) success failure]
where
cc = fromIntegral c :: Double

-- Several evaluation strategies are implemented, each with different space-time tradeoffs:
direct, memoised, memoised2, memoised3 :: Double -> (Cents -> Utility) -> Rounds -> Cents -> Outcome
-- No memoization beyond standard Haskell laziness; avoids overhead, memory-efficient, good for sparse recurrency
direct p utility = go
where
go r c = value p utility go r c

-- Memoization using an explicit 2D (Cents X Rounds) Data.Vector table; Rounds are lazy but maxCents is strict
-- fastest, but also most memory-hungry: maxCents is easy to exceed, but can't be made too large either without OOMing
memoised p utility = go
where
go r c
| r >= maxRounds = error "rounds overflow"
| c >= maxCents = error "cents overflow"
| otherwise = table V.! r V.! c
table = V.generate maxRounds (\r -> V.generate maxCents (\c -> value p utility go r c))
maxRounds = 100
maxCents = 1000000

-- Memoization using 'memoize'; ordinary pure function memoization, using a binary tree cache for lookups; no sharing across independent invocations. Reasonably fast & memory-efficient.
memoised2 p utility = Memoize.memoFix2 (value p utility)

-- Memoization using 'uglymemo'; side-effectful, using Data.Map cache for lookups;
-- This version doesn't have global sharing but at least recursive calls are memoized for efficiency.
-- Subsequent calls to the same value function returned by this are shared, though.
-- That is: let score = memoised3 100 linearUtility
--          in (score 10 1000, score 20 1000)
-- Will use the same memo table and share computation.
memoised3 p utility = go
where
go = Ugly.memo (\r -> Ugly.memo (\c -> value p utility go r c))

linearUtility, logUtility :: Cents -> Utility
linearUtility = fromIntegral
logUtility x = log (0.001 + fromIntegral x) -- +small constant to avoid -Inf

report :: Int -> Int -> String
report power rounds = ("Rounds: "++show rounds++"; P: "++show((10::Int)^power)++"; ") ++ (show $memoised3 (10^power) linearUtility rounds 1000) main :: IO () main = do -- print$ "Instances: payoff probabilities from 1/10th..1/ten billionth, $10 capital, 20 rounds" mapM (\power -> let score = memoised3 (10^power) linearUtility in mapM_ (\rounds -> putStrLn$ report score power rounds)  [1..100::Int])
[1,2,4,8,16::Int]
return ()

x1e.32xlarge https://aws.amazon.com/ec2/instance-types/x1e/ us-east-2b (Ohio) 16 September 2019 3904GB RAM spot: $8.0064/hr; on-demand$26.688 per Hour https://aws.amazon.com/ec2/pricing/on-demand/

06:11 PM \$ ssh -i “/home/gwern/.ssh/Ohio.pem” ubuntu@ec2-18-191-93-35.us-east-2.compute.amazonaws.com

1. , ‘Avatars of the Tortoise’, Discussion (1932)↩︎