From a3cc67159d56dcf2fc31e454afb0c9e6a8bf1ce3 Mon Sep 17 00:00:00 2001 From: twonirwana Date: Thu, 2 May 2024 19:10:26 +0200 Subject: [PATCH] DieId (#101) * Adding a dieId to identify a random element and use the dieId to predetermine the result of a random element * Returning the exact position in the expression on an exception --- README.adoc | 2 +- .../janno/evaluator/dice/DiceEvaluator.java | 103 +- .../de/janno/evaluator/dice/DiceHelper.java | 111 +- .../java/de/janno/evaluator/dice/DieId.java | 33 + .../evaluator/dice/ExpressionException.java | 13 +- .../evaluator/dice/ExpressionPosition.java | 51 + .../de/janno/evaluator/dice/Function.java | 8 +- .../de/janno/evaluator/dice/Operator.java | 18 +- .../janno/evaluator/dice/RandomElement.java | 23 +- .../janno/evaluator/dice/RandomElements.java | 33 - .../evaluator/dice/RandomElementsBuilder.java | 90 + .../java/de/janno/evaluator/dice/Roll.java | 66 +- .../de/janno/evaluator/dice/RollBuilder.java | 15 +- .../de/janno/evaluator/dice/RollContext.java | 62 + .../de/janno/evaluator/dice/RollElement.java | 15 +- .../java/de/janno/evaluator/dice/RollId.java | 25 + .../de/janno/evaluator/dice/RollResult.java | 19 + .../java/de/janno/evaluator/dice/Roller.java | 2 +- .../java/de/janno/evaluator/dice/Token.java | 52 +- .../de/janno/evaluator/dice/Tokenizer.java | 98 +- .../evaluator/dice/UniqueRandomElements.java | 95 - .../janno/evaluator/dice/ValidatorUtil.java | 40 +- .../evaluator/dice/function/AbstractIf.java | 32 +- .../janno/evaluator/dice/function/Cancel.java | 15 +- .../dice/function/ColorFunction.java | 19 +- .../dice/function/ConcatFunction.java | 13 +- .../janno/evaluator/dice/function/Double.java | 17 +- .../evaluator/dice/function/Explode.java | 32 +- .../evaluator/dice/function/GroupCount.java | 14 +- .../de/janno/evaluator/dice/function/If.java | 62 +- .../evaluator/dice/function/IfEqual.java | 3 +- .../evaluator/dice/function/IfGreater.java | 7 +- .../janno/evaluator/dice/function/IfIn.java | 5 +- .../evaluator/dice/function/IfLesser.java | 7 +- .../de/janno/evaluator/dice/function/Max.java | 14 +- .../de/janno/evaluator/dice/function/Min.java | 14 +- .../evaluator/dice/function/Replace.java | 20 +- .../evaluator/dice/function/SortAsc.java | 14 +- .../evaluator/dice/function/SortDesc.java | 14 +- .../janno/evaluator/dice/function/Value.java | 32 +- .../evaluator/dice/operator/bool/AndBool.java | 18 +- .../dice/operator/bool/EqualBool.java | 14 +- .../dice/operator/bool/GreaterBool.java | 18 +- .../dice/operator/bool/GreaterEqualBool.java | 18 +- .../evaluator/dice/operator/bool/InBool.java | 14 +- .../dice/operator/bool/LesserBool.java | 18 +- .../dice/operator/bool/LesserEqualBool.java | 18 +- .../dice/operator/bool/NegateBool.java | 16 +- .../evaluator/dice/operator/bool/OrBool.java | 18 +- .../evaluator/dice/operator/die/Color.java | 20 +- .../dice/operator/die/ExplodingAddDice.java | 87 +- .../dice/operator/die/ExplodingDice.java | 79 +- .../dice/operator/die/RegularDice.java | 56 +- .../evaluator/dice/operator/die/Reroll.java | 25 +- .../evaluator/dice/operator/die/Tag.java | 18 +- .../dice/operator/list/AddToList.java | 19 +- .../evaluator/dice/operator/list/Concat.java | 12 +- .../evaluator/dice/operator/list/Count.java | 14 +- .../dice/operator/list/EqualFilter.java | 16 +- .../operator/list/GreaterEqualThanFilter.java | 18 +- .../dice/operator/list/GreaterThanFilter.java | 18 +- .../dice/operator/list/KeepHighest.java | 18 +- .../dice/operator/list/KeepLowest.java | 21 +- .../operator/list/LesserEqualThanFilter.java | 18 +- .../dice/operator/list/LesserThanFilter.java | 18 +- .../evaluator/dice/operator/list/Repeat.java | 25 +- .../dice/operator/list/RepeatList.java | 22 +- .../evaluator/dice/operator/list/Sum.java | 16 +- .../dice/operator/math/DecimalDivide.java | 29 +- .../dice/operator/math/IntegerDivide.java | 32 +- .../evaluator/dice/operator/math/Modulo.java | 32 +- .../dice/operator/math/Multiply.java | 20 +- .../dice/operator/math/NegateAddRemove.java | 24 +- .../dice/random/GivenDiceNumberSupplier.java | 38 + .../dice/random/GivenNumberSupplier.java | 4 +- .../evaluator/dice/random/NumberSupplier.java | 5 +- .../dice/random/RandomNumberSupplier.java | 10 +- .../evaluator/dice/DiceEvaluatorTest.java | 677 ++++-- .../janno/evaluator/dice/ProdExampleTest.java | 4 +- .../dice/RandomDiceEvaluatorTest.java | 2 +- .../de/janno/evaluator/dice/RollTest.java | 21 + .../janno/evaluator/dice/TokenizerTest.java | 43 +- .../dice/random/RandomNumberSupplierTest.java | 47 +- src/test/resources/expressionsAndResults.csv | 1869 ++++++++--------- 84 files changed, 2758 insertions(+), 2079 deletions(-) create mode 100644 src/main/java/de/janno/evaluator/dice/DieId.java create mode 100644 src/main/java/de/janno/evaluator/dice/ExpressionPosition.java delete mode 100644 src/main/java/de/janno/evaluator/dice/RandomElements.java create mode 100644 src/main/java/de/janno/evaluator/dice/RandomElementsBuilder.java create mode 100644 src/main/java/de/janno/evaluator/dice/RollContext.java create mode 100644 src/main/java/de/janno/evaluator/dice/RollId.java create mode 100644 src/main/java/de/janno/evaluator/dice/RollResult.java delete mode 100644 src/main/java/de/janno/evaluator/dice/UniqueRandomElements.java create mode 100644 src/main/java/de/janno/evaluator/dice/random/GivenDiceNumberSupplier.java create mode 100644 src/test/java/de/janno/evaluator/dice/RollTest.java diff --git a/README.adoc b/README.adoc index 3f2fae4..95b2957 100644 --- a/README.adoc +++ b/README.adoc @@ -51,7 +51,7 @@ For example `1d4+3d6` is the appending of roll of 1d4 and 3d6, but `(1d4+3=)d6)` The number of dice is limited to 1000 and every number approve 9 digits or with more than 9 digit after the decimal dot result in an error. -Boolean values will be represented by `'true'` and `'false'`. +Boolean values will be represented by `'true'` (or `1`) and `'false'` (or `0`) . It is possible to set tags and color. Colors have no direct effect and will be also set to all random elements of the expression. diff --git a/src/main/java/de/janno/evaluator/dice/DiceEvaluator.java b/src/main/java/de/janno/evaluator/dice/DiceEvaluator.java index 979bbe4..23f5459 100644 --- a/src/main/java/de/janno/evaluator/dice/DiceEvaluator.java +++ b/src/main/java/de/janno/evaluator/dice/DiceEvaluator.java @@ -131,61 +131,69 @@ private static boolean hasStackTokenPrecedence(Token currentToken, Token stackTo (currentToken.getOperatorPrecedence().orElseThrow() < stackToken.getOperatorPrecedence().orElseThrow())); } - public Roller createRollSupplier(List rollBuilders) { + private Roller createRollSupplier(String expression, List rollBuilders) { return () -> { - Map variableMap = new HashMap<>(); - List rolls = RollBuilder.extendAllBuilder(rollBuilders, variableMap); - if (!variableMap.isEmpty()) { + RollContext rollContext = new RollContext(); + ImmutableList rolls = RollBuilder.extendAllBuilder(rollBuilders, rollContext); + Optional expressionPrefix = rollContext.getExpressionPrefixString(); + if (expressionPrefix.isPresent()) { //we need to add the val expression in front of the expression - String variablestring = variableMap.values().stream().map(Roll::getExpression).collect(Collectors.joining(", ")); ImmutableList.Builder rollBuilder = ImmutableList.builder(); for (Roll r : rolls) { - rollBuilder.add(new Roll("%s, %s".formatted(variablestring, r.getExpression()), r.getElements(), r.getRandomElementsInRoll(), r.getChildrenRolls(), maxNumberOfElements, keepChildrenRolls)); + String newExpressionString = "%s, %s".formatted(expressionPrefix.get(), r.getExpression()); + rollBuilder.add(new Roll(newExpressionString, + r.getElements(), + r.getRandomElementsInRoll(), + r.getChildrenRolls(), + r.getExpressionPosition(), + maxNumberOfElements, + keepChildrenRolls)); } rolls = rollBuilder.build(); } - return rolls; + return new RollResult(expression, rolls); }; } - private @NonNull RollBuilder toValue(@NonNull String literal, @NonNull String inputValue) { + private @NonNull RollBuilder toValue(@NonNull String literal, @NonNull ExpressionPosition expressionPosition) { Matcher listMatcher = LIST_REGEX.matcher(literal); if (listMatcher.find()) { List list = Arrays.asList(listMatcher.group(1).split("[%s%s]".formatted(SEPARATOR, LEGACY_LIST_SEPARATOR))); return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variableMap) throws ExpressionException { + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { return Optional.of(ImmutableList.of(new Roll(toExpression(), list.stream() .map(String::trim) .map(s -> new RollElement(s, RollElement.NO_TAG, RollElement.NO_COLOR)) - .collect(ImmutableList.toImmutableList()), UniqueRandomElements.empty(), ImmutableList.of(), + .collect(ImmutableList.toImmutableList()), ImmutableList.of(), ImmutableList.of(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return inputValue; + return expressionPosition.toStringWithExtension(); } }; } return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - if (variables.containsKey(literal)) { - Roll variableValue = variables.get(literal); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + Optional variableRoll = rollContext.getVariable(literal); + if (variableRoll.isPresent()) { + Roll variableValue = variableRoll.get(); //set the input as expression - Roll replacedValue = new Roll(toExpression(), variableValue.getElements(), variableValue.getRandomElementsInRoll(), variableValue.getChildrenRolls(), maxNumberOfElements, keepChildrenRolls); + Roll replacedValue = new Roll(toExpression(), variableValue.getElements(), variableValue.getRandomElementsInRoll(), variableValue.getChildrenRolls(), expressionPosition, maxNumberOfElements, keepChildrenRolls); return Optional.of(ImmutableList.of(replacedValue)); } if (literal.isEmpty()) { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(), UniqueRandomElements.empty(), ImmutableList.of(), maxNumberOfElements, keepChildrenRolls))); + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(), ImmutableList.of(), ImmutableList.of(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement(literal, RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), maxNumberOfElements, keepChildrenRolls))); + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement(literal, RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return inputValue; + return expressionPosition.toStringWithExtension(); } }; } @@ -193,22 +201,22 @@ public Roller createRollSupplier(List rollBuilders) { private void processTokenToValues(Deque values, Token token) throws ExpressionException { if (token.getLiteral().isPresent()) { // If the token is a literal, a constant, or a variable name String literal = token.getLiteral().get(); - values.push(toValue(literal, token.getInputValue())); + values.push(toValue(literal, token.getExpressionPosition())); } else if (token.getOperator().isPresent()) { // If the token is an operator Operator operator = token.getOperator().get(); int argumentCount = token.getOperatorType().orElseThrow().argumentCount; if (values.size() < argumentCount) { - throw new ExpressionException("Not enough values, %s needs %d".formatted(operator.getName(), argumentCount)); + throw new ExpressionException("Not enough values, %s needs %d".formatted(operator.getName(), argumentCount), token.getExpressionPosition()); } - values.push(operator.evaluate(getArguments(values, argumentCount), token.getInputValue())); + values.push(operator.evaluate(getArguments(values, argumentCount), token.getExpressionPosition())); } else { - throw new ExpressionException(token.toString()); + throw new ExpressionException(token.toString(), token.getExpressionPosition()); } } - private void doFunction(Deque values, Function function, int argumentCount, String inputValue) throws ExpressionException { - final RollBuilder res = function.evaluate(getArguments(values, argumentCount), inputValue); + private void doFunction(Deque values, Function function, int argumentCount, ExpressionPosition expressionPosition) throws ExpressionException { + final RollBuilder res = function.evaluate(getArguments(values, argumentCount), expressionPosition); values.push(res); } @@ -240,10 +248,10 @@ public boolean expressionContainsOperatorOrFunction(String expression) { * Evaluates an expression. * * @param expression The expression to evaluate - * @return The result of the evaluation. This can be multiple values, if the expression can't be reduced to a single value. + * @return The result of the evaluation. * @throws ExpressionException if the expression is not correct. */ - public List evaluate(String expression) throws ExpressionException { + public RollResult evaluate(String expression) throws ExpressionException { return buildRollSupplier(expression).roll(); } @@ -251,14 +259,19 @@ public List evaluate(String expression) throws ExpressionException { * Create a roller for an expression. The roller is the expression as function can be used again to roll the expression * again. Each execution of the roller will generate new random elements. * - * @param expression The expression to evaluate + * @param inputExpression The expression to evaluate * @return A roller that executes the expression * @throws ExpressionException if the expression is not correct. */ - public Roller buildRollSupplier(String expression) throws ExpressionException { - expression = expression.trim(); + public Roller buildRollSupplier(final String inputExpression) throws ExpressionException { + final String expression = inputExpression.trim(); if (Strings.isNullOrEmpty(expression)) { - return ImmutableList::of; + return new Roller() { + @Override + public @NonNull RollResult roll() { + return new RollResult(expression, ImmutableList.of()); + } + }; } final List tokens = tokenizer.tokenize(expression); @@ -271,7 +284,7 @@ public Roller buildRollSupplier(String expression) throws ExpressionException { if (previous.flatMap(Token::getFunction).isPresent() && !isFunctionOpenBracket(token)) { String functionName = previous.flatMap(Token::getFunction).map(Function::getName).orElseThrow(); String allowedBrackets = parameters.getFunctionBrackets().stream().map(BracketPair::getOpen).collect(Collectors.joining(" or ")); - throw new ExpressionException("A function, in this case '%s', must be followed a open function bracket: %s".formatted(functionName, allowedBrackets)); + throw new ExpressionException("A function, in this case '%s', must be followed a open function bracket: %s".formatted(functionName, allowedBrackets), token.getExpressionPosition()); } if (token.getBrackets().isPresent() && token.isOpenBracket()) { @@ -279,21 +292,21 @@ public Roller buildRollSupplier(String expression) throws ExpressionException { stack.push(token); if (previous.flatMap(Token::getFunction).isPresent()) { if (!parameters.getFunctionBrackets().contains(token.getBrackets().get())) { - throw new ExpressionException("Invalid bracket after function: %s".formatted(token)); + throw new ExpressionException("Invalid bracket after function: %s".formatted(token), token.getExpressionPosition()); } } else { if (!parameters.getExpressionBrackets().contains(token.getBrackets().get())) { - throw new ExpressionException("Invalid bracket in expression: %s".formatted(token)); + throw new ExpressionException("Invalid bracket in expression: %s".formatted(token), token.getExpressionPosition()); } } } else if (token.isCloseBracket()) { if (previous.isEmpty()) { - throw new ExpressionException("expression can't start with a close bracket"); + throw new ExpressionException("expression can't start with a close bracket", token.getExpressionPosition()); } else if (previous.get().isOpenBracket()) { - throw new ExpressionException("empty brackets are not allowed"); + throw new ExpressionException("empty brackets are not allowed", token.getExpressionPosition()); } if (previous.map(Token::isSeparator).get()) { - throw new ExpressionException("argument is missing"); + throw new ExpressionException("argument is missing", token.getExpressionPosition()); } BracketPair brackets = token.getBrackets().get(); // If the token is a right parenthesis: @@ -307,7 +320,7 @@ public Roller buildRollSupplier(String expression) throws ExpressionException { if (stackToken.getBrackets().get().equals(brackets)) { openBracketFound = true; } else { - throw new ExpressionException("Invalid parenthesis match %s%s".formatted(stackToken.getBrackets().get().getOpen(), brackets.getClose())); + throw new ExpressionException("Invalid parenthesis match %s%s".formatted(stackToken.getBrackets().get().getOpen(), brackets.getClose()), token.getExpressionPosition()); } } else { processTokenToValues(values, stackToken); @@ -316,22 +329,22 @@ public Roller buildRollSupplier(String expression) throws ExpressionException { if (!openBracketFound) { // If the stack runs out without finding a left parenthesis, then // there are mismatched parentheses. - throw new ExpressionException("Parentheses mismatched"); + throw new ExpressionException("Parentheses mismatched", token.getExpressionPosition()); } if (!stack.isEmpty() && stack.peek().getFunction().isPresent()) { // If the token at the top of the stack is a function token, pop it // onto the output queue. int argumentCount = values.size() - previousValuesSize.pop(); final Token functionToken = stack.pop(); - doFunction(values, functionToken.getFunction().orElseThrow(), argumentCount, functionToken.getInputValue()); + doFunction(values, functionToken.getFunction().orElseThrow(), argumentCount, functionToken.getExpressionPosition()); } } else if (token.isSeparator()) { if (previous.isEmpty()) { - throw new ExpressionException("expression can't start with a separator"); + throw new ExpressionException("expression can't start with a separator", token.getExpressionPosition()); } // Verify that there was an argument before this separator if (previous.get().isOpenBracket() || previous.get().isSeparator()) { - throw new ExpressionException("A separator can't be followed by another separator or open bracket"); + throw new ExpressionException("A separator can't be followed by another separator or open bracket", token.getExpressionPosition()); } boolean openBracketOnStackReached = false; @@ -342,7 +355,7 @@ public Roller buildRollSupplier(String expression) throws ExpressionException { throw new ExpressionException("Separator '%s' in bracket '%s' without leading function is not allowed" .formatted(parameters.getSeparator(), parameters.getExpressionBrackets().stream() .map(Object::toString) - .collect(Collectors.joining(",")))); + .collect(Collectors.joining(","))), token.getExpressionPosition()); } } else { // Until the token at the top of the stack is a left parenthesis, @@ -378,7 +391,7 @@ public Roller buildRollSupplier(String expression) throws ExpressionException { if (!stack.peek().isOpenBracket()) { //no unfinished bracket processTokenToValues(values, stack.pop()); } else { - throw new ExpressionException("All brackets need to be closed be for starting a new expression or missing ','"); + throw new ExpressionException("All brackets need to be closed be for starting a new expression or missing ','", token.getExpressionPosition()); } } // If the token is literal then add its value to the output queue. @@ -392,10 +405,10 @@ public Roller buildRollSupplier(String expression) throws ExpressionException { // While there are still operator tokens in the stack: for (Token stackToken : stack) { if (stackToken.isOpenBracket() || stackToken.isCloseBracket()) { - throw new ExpressionException("Parentheses mismatched"); + throw new ExpressionException("Parentheses mismatched", stackToken.getExpressionPosition()); } processTokenToValues(values, stackToken); } - return createRollSupplier(reverse(values)); + return createRollSupplier(expression, reverse(values)); } } diff --git a/src/main/java/de/janno/evaluator/dice/DiceHelper.java b/src/main/java/de/janno/evaluator/dice/DiceHelper.java index 3b1c380..ead429e 100644 --- a/src/main/java/de/janno/evaluator/dice/DiceHelper.java +++ b/src/main/java/de/janno/evaluator/dice/DiceHelper.java @@ -3,100 +3,75 @@ import com.google.common.collect.ImmutableList; import de.janno.evaluator.dice.random.NumberSupplier; import lombok.NonNull; -import lombok.Value; +import java.util.ArrayList; import java.util.List; public final class DiceHelper { - public static @NonNull ImmutableList explodingDice(int number, int sides, @NonNull NumberSupplier numberSupplier) throws ExpressionException { + public static @NonNull ImmutableList explodingDice(int number, + int sides, + @NonNull NumberSupplier numberSupplier, + @NonNull RollId rollId, + int maxNumberOfElements, + String expression) throws ExpressionException { if (sides == 0) { return ImmutableList.of(); } if (sides < 0) { - throw new ExpressionException("Sides of dice to roll must be positive"); + throw new ExpressionException("Sides of dice to roll must be positive", rollId.getExpressionPosition()); } - ImmutableList.Builder resultBuilder = ImmutableList.builder(); - int diceToRoll = number; - while (diceToRoll > 0) { - List roll = rollDice(diceToRoll, sides, numberSupplier); - resultBuilder.addAll(roll); - diceToRoll = (int) roll.stream().filter(i -> i == sides).count(); - } - return resultBuilder.build(); - } - - public static @NonNull ImmutableList explodedAddDie2RollElements(@NonNull List in) { - return in.stream() - .map(ExplodedAddDie::getValue) - .map(String::valueOf) - .map(i -> new RollElement(i, RollElement.NO_TAG, RollElement.NO_COLOR)) - .collect(ImmutableList.toImmutableList()); - } - - public static @NonNull ImmutableList explodedAddDie2RandomElements(@NonNull List in) { - return in.stream() - .flatMap(r -> r.getDiceThrowResults().stream().map(String::valueOf) - .map(i -> new RollElement(i, RollElement.NO_TAG, RollElement.NO_COLOR)) - .map(re -> new RandomElement(re, 1, r.getSidesOfDie()))) - .collect(ImmutableList.toImmutableList()); - } - - public static @NonNull ImmutableList toRollElements(@NonNull List in) { - return in.stream() - .map(String::valueOf) - .map(i -> new RollElement(i, RollElement.NO_TAG, RollElement.NO_COLOR)) - .collect(ImmutableList.toImmutableList()); - } - - public static @NonNull ImmutableList explodingAddDice(int number, int sides, @NonNull NumberSupplier numberSupplier) throws ExpressionException { - if (sides == 0) { - return ImmutableList.of(); - } - if (sides < 0) { - throw new ExpressionException("Sides of dice to roll must be positive"); - } - ImmutableList.Builder resultBuilder = ImmutableList.builder(); + List resultBuilder = new ArrayList<>(); + //order of the exploded dice is not relevant, the random elements get sorted later for (int i = 0; i < number; i++) { - resultBuilder.add(rollExplodingAddDie(sides, numberSupplier)); + resultBuilder.addAll(rollExplodingDie(sides, numberSupplier, rollId, i, maxNumberOfElements, expression)); + if (resultBuilder.size() > maxNumberOfElements) { + throw new ExpressionException("To many elements in roll '%s', max is %d but there where %d".formatted(expression, maxNumberOfElements, resultBuilder.size()), rollId.getExpressionPosition()); + } } - return resultBuilder.build(); + return ImmutableList.copyOf(resultBuilder); } - public static ExplodedAddDie rollExplodingAddDie(int sides, @NonNull NumberSupplier numberSupplier) throws ExpressionException { - int current = numberSupplier.get(0, sides); - int res = current; - ImmutableList.Builder resultBuilder = ImmutableList.builder(); - resultBuilder.add(current); - while (current == sides) { - current = numberSupplier.get(0, sides); - res += current; - resultBuilder.add(current); + private static List rollExplodingDie(int sides, NumberSupplier numberSupplier, RollId rollId, int index, int maxNumberOfElements, String expression) throws ExpressionException { + List resultBuilder = new ArrayList<>(); + int rerollCounter = 0; + RandomElement currentRoll = rollDie(sides, numberSupplier, rollId, index, rerollCounter++); + final String rerollValue = String.valueOf(sides); + resultBuilder.add(currentRoll); + while (currentRoll.getRollElement().getValue().equals(rerollValue)) { + currentRoll = rollDie(sides, numberSupplier, rollId, index, rerollCounter++); + resultBuilder.add(currentRoll); + if (resultBuilder.size() > maxNumberOfElements) { + throw new ExpressionException("To many elements in roll '%s', max is %d but there where %d".formatted(expression, maxNumberOfElements, resultBuilder.size()), rollId.getExpressionPosition()); + } } - return new ExplodedAddDie(res, sides, resultBuilder.build()); + return ImmutableList.copyOf(resultBuilder); } - public static @NonNull ImmutableList rollDice(int number, int sides, @NonNull NumberSupplier numberSupplier) throws ExpressionException { + public static @NonNull ImmutableList rollDice(int number, int sides, @NonNull NumberSupplier numberSupplier, @NonNull RollId rollId) throws ExpressionException { if (sides == 0) { return ImmutableList.of(); } if (sides < 0) { - throw new ExpressionException("Sides of dice to roll must be positive"); + throw new ExpressionException("Sides of dice to roll must be positive", rollId.getExpressionPosition()); } - ImmutableList.Builder resultBuilder = ImmutableList.builder(); + ImmutableList.Builder randomElementBuilder = ImmutableList.builder(); for (int i = 0; i < number; i++) { - resultBuilder.add(numberSupplier.get(0, sides)); + randomElementBuilder.add(rollDie(sides, numberSupplier, rollId, i, 0)); } - return resultBuilder.build(); + return randomElementBuilder.build(); } - public static @NonNull RollElement pickOneOf(List list, @NonNull NumberSupplier numberSupplier) throws ExpressionException { - return list.get(numberSupplier.get(0, list.size()) - 1); + private static RandomElement rollDie(int sides, @NonNull NumberSupplier numberSupplier, @NonNull RollId rollId, int index, int reroll) throws ExpressionException { + final DieId dieId = DieId.of(rollId, index, reroll); + final int value = numberSupplier.get(0, sides, dieId); + return new RandomElement(new RollElement(String.valueOf(value), RollElement.NO_TAG, RollElement.NO_COLOR), 1, sides, dieId); + } - @Value - public static class ExplodedAddDie { - int value; - int sidesOfDie; - ImmutableList diceThrowResults; + public static @NonNull RandomElement pickOneOf(List list, @NonNull NumberSupplier numberSupplier, @NonNull DieId dieId) throws ExpressionException { + return new RandomElement(list.get(numberSupplier.get(0, list.size(), dieId) - 1), list.stream() + .map(RollElement::getValue) + .collect(ImmutableList.toImmutableList()), dieId); } + } diff --git a/src/main/java/de/janno/evaluator/dice/DieId.java b/src/main/java/de/janno/evaluator/dice/DieId.java new file mode 100644 index 0000000..043dcb5 --- /dev/null +++ b/src/main/java/de/janno/evaluator/dice/DieId.java @@ -0,0 +1,33 @@ +package de.janno.evaluator.dice; + +import com.google.common.annotations.VisibleForTesting; +import lombok.NonNull; +import lombok.Value; + +@Value(staticConstructor = "of") +public class DieId implements Comparable { + @NonNull + RollId rollId; + int dieIndex; + int reroll; + + @VisibleForTesting + public static DieId of(int expressionPositionStartInc, String value, int reEvaluateCounter, int dieIndex, int reroll) { + return new DieId(RollId.of(ExpressionPosition.of(expressionPositionStartInc, value), reEvaluateCounter), dieIndex, reroll); + } + + @Override + public String toString() { + return rollId + "i" + dieIndex + "r" + reroll; + } + + @Override + public int compareTo(DieId o) { + if (!this.rollId.equals(o.getRollId())) { + return this.rollId.compareTo(o.getRollId()); + } else if (this.dieIndex != o.getDieIndex()) { + return Integer.compare(this.dieIndex, o.getDieIndex()); + } + return Integer.compare(this.reroll, o.reroll); + } +} \ No newline at end of file diff --git a/src/main/java/de/janno/evaluator/dice/ExpressionException.java b/src/main/java/de/janno/evaluator/dice/ExpressionException.java index 4b1c86b..3c6af52 100644 --- a/src/main/java/de/janno/evaluator/dice/ExpressionException.java +++ b/src/main/java/de/janno/evaluator/dice/ExpressionException.java @@ -1,7 +1,16 @@ package de.janno.evaluator.dice; -public class ExpressionException extends Exception{ - public ExpressionException(String message) { +import lombok.Getter; +import lombok.NonNull; + +@Getter +public class ExpressionException extends Exception { + + @NonNull + private final ExpressionPosition expressionPosition; + + public ExpressionException(@NonNull String message, @NonNull ExpressionPosition expressionPosition) { super(message); + this.expressionPosition = expressionPosition; } } diff --git a/src/main/java/de/janno/evaluator/dice/ExpressionPosition.java b/src/main/java/de/janno/evaluator/dice/ExpressionPosition.java new file mode 100644 index 0000000..ef363f1 --- /dev/null +++ b/src/main/java/de/janno/evaluator/dice/ExpressionPosition.java @@ -0,0 +1,51 @@ +package de.janno.evaluator.dice; + +import com.google.common.base.Joiner; +import lombok.NonNull; +import lombok.Value; + +import javax.annotation.Nullable; + + +@Value +public class ExpressionPosition implements Comparable { + int startInc; + @NonNull + String value; + /** + * A non operator/function extension on the left, like a parentheses. Needed to build the expression back together. + */ + @Nullable + String leftExtension; + /** + * A non operator/function extension on the right, like a parentheses. Needed to build the expression back together. + */ + @Nullable + String rightExtension; + + public static ExpressionPosition of(final int startInc, final String value) { + return new ExpressionPosition(startInc, value, null, null); + } + + public ExpressionPosition extendLeft(final String leftValue) { + return new ExpressionPosition(this.startInc, this.value, leftValue, this.rightExtension); + } + + public ExpressionPosition extendRight(final String rightValue) { + return new ExpressionPosition(this.startInc, this.value, this.leftExtension, rightValue); + } + + @Override + public String toString() { + return startInc + value; + } + + public String toStringWithExtension() { + return Joiner.on("").skipNulls().join(leftExtension, value, rightExtension); + } + + @Override + public int compareTo(ExpressionPosition o) { + return Integer.compare(startInc, o.startInc); + } +} diff --git a/src/main/java/de/janno/evaluator/dice/Function.java b/src/main/java/de/janno/evaluator/dice/Function.java index ffb7543..156c788 100644 --- a/src/main/java/de/janno/evaluator/dice/Function.java +++ b/src/main/java/de/janno/evaluator/dice/Function.java @@ -54,16 +54,16 @@ public Function(@NonNull String name, int minArgumentCount, int maxArgumentCount } - protected static String getExpression(String name, List arguments) { - return "%s%s".formatted(name, arguments.stream().map(RollBuilder::toExpression).collect(Collectors.joining(","))); + protected static String getExpression(ExpressionPosition expressionPosition, List arguments) { + return "%s%s".formatted(expressionPosition.toStringWithExtension(), arguments.stream().map(RollBuilder::toExpression).collect(Collectors.joining(","))); } /** * Creates a RollBuilder for the arguments * * @param arguments all function arguments - * @param inputValue the given input for the function name, is needed the get the used upper/lower case in the result expression + * @param expressionPosition the part of the expression for this function, is needed the get the used upper/lower case in the result expression * @return the RollBuilder that can be called to get result rolls */ - public abstract @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException; + public abstract @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException; } \ No newline at end of file diff --git a/src/main/java/de/janno/evaluator/dice/Operator.java b/src/main/java/de/janno/evaluator/dice/Operator.java index 7cfb8a4..3167de7 100644 --- a/src/main/java/de/janno/evaluator/dice/Operator.java +++ b/src/main/java/de/janno/evaluator/dice/Operator.java @@ -83,30 +83,30 @@ private static Optional getIndexIfExists(List list, int index) { return Optional.ofNullable(list.get(index)); } - protected static String getBinaryOperatorExpression(String name, List operands) { + protected static String getBinaryOperatorExpression(ExpressionPosition expressionPosition, List operands) { String left = getIndexIfExists(operands, 0).map(RollBuilder::toExpression).orElse(""); String right = getIndexIfExists(operands, 1).map(RollBuilder::toExpression).orElse(""); - return String.format("%s%s%s", left, name, right); + return String.format("%s%s%s", left, expressionPosition.toStringWithExtension(), right); } - protected static String getLeftUnaryExpression(String name, List operands) { + protected static String getLeftUnaryExpression(ExpressionPosition expressionPosition, List operands) { String left = getIndexIfExists(operands, 0).map(RollBuilder::toExpression).orElse(""); - return String.format("%s%s", left, name); + return String.format("%s%s", left, expressionPosition.toStringWithExtension()); } - protected static String getRightUnaryExpression(String name, List operands) { + protected static String getRightUnaryExpression(ExpressionPosition expressionPosition, List operands) { String right = getIndexIfExists(operands, 0).map(RollBuilder::toExpression).orElse(""); - return String.format("%s%s", name, right); + return String.format("%s%s", expressionPosition.toStringWithExtension(), right); } /** * Creates a RollBuilder for the arguments * - * @param operands 1 or 2 operants - * @param inputValue the given input for the operant, is needed the get the used upper/lower case in the result expression + * @param operands 1 or 2 operants + * @param expressionPosition the part of the expression for this operant, is needed the get the used upper/lower case in the result expression * @return the RollBuilder that can be called to get result rolls */ - public abstract @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException; + public abstract @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException; public boolean supportUnaryOperation() { return unaryAssociativity != null; diff --git a/src/main/java/de/janno/evaluator/dice/RandomElement.java b/src/main/java/de/janno/evaluator/dice/RandomElement.java index 8426ece..1d7913e 100644 --- a/src/main/java/de/janno/evaluator/dice/RandomElement.java +++ b/src/main/java/de/janno/evaluator/dice/RandomElement.java @@ -3,7 +3,7 @@ import com.google.common.collect.ImmutableList; import lombok.NonNull; import lombok.Value; -import org.checkerframework.checker.nullness.qual.Nullable; +import javax.annotation.Nullable; @Value @@ -15,40 +15,45 @@ public class RandomElement { @Nullable ImmutableList randomSelectedFrom; + @NonNull + DieId dieId; + @Nullable Integer minInc; @Nullable Integer maxInc; - public RandomElement(@NonNull RollElement rollElement, @NonNull ImmutableList randomSelectedFrom) { - this(rollElement, randomSelectedFrom, null, null); + public RandomElement(@NonNull RollElement rollElement, @NonNull ImmutableList randomSelectedFrom, @NonNull DieId dieId) { + this(rollElement, randomSelectedFrom, null, null, dieId); } - public RandomElement(@NonNull RollElement rollElement, int minInc, int maxInc) { - this(rollElement, null, minInc, maxInc); + public RandomElement(@NonNull RollElement rollElement, int minInc, int maxInc, @NonNull DieId dieId) { + this(rollElement, null, minInc, maxInc, dieId); } private RandomElement(@NonNull RollElement rollElement, @Nullable ImmutableList randomSelectedFrom, @Nullable Integer minInc, - @Nullable Integer maxInc) { + @Nullable Integer maxInc, + @NonNull DieId dieId) { this.rollElement = rollElement; this.randomSelectedFrom = randomSelectedFrom; this.minInc = minInc; this.maxInc = maxInc; + this.dieId = dieId; } public RandomElement copyWithTagAndColor(@NonNull String color) { - return new RandomElement(new RollElement(this.rollElement.getValue(), this.rollElement.getTag(), color), this.randomSelectedFrom, this.minInc, this.maxInc); + return new RandomElement(new RollElement(this.rollElement.getValue(), this.rollElement.getTag(), color), this.randomSelectedFrom, this.minInc, this.maxInc, this.dieId); } public String toString() { if (randomSelectedFrom != null) { - return "%s∈%s".formatted(rollElement.toString(), randomSelectedFrom); + return "%s=%s∈%s".formatted(dieId, rollElement.toString(), randomSelectedFrom); } else { - return "%s∈[%d...%d]".formatted(rollElement.toString(), minInc, maxInc); + return "%s=%s∈[%d...%d]".formatted(dieId, rollElement.toString(), minInc, maxInc); } } } diff --git a/src/main/java/de/janno/evaluator/dice/RandomElements.java b/src/main/java/de/janno/evaluator/dice/RandomElements.java deleted file mode 100644 index 99fda52..0000000 --- a/src/main/java/de/janno/evaluator/dice/RandomElements.java +++ /dev/null @@ -1,33 +0,0 @@ -package de.janno.evaluator.dice; - -import com.google.common.collect.ImmutableList; -import lombok.Value; - -import java.util.UUID; - -@Value -public class RandomElements { - //we need an id because we don't want to add RollRandomElements from values multiple times - UUID uuid; - ImmutableList randomElements; - - public RandomElements(ImmutableList randomElements) { - this(UUID.randomUUID(), randomElements); - } - - private RandomElements(UUID uuid, ImmutableList randomElements) { - this.uuid = uuid; - this.randomElements = randomElements; - } - - public String toString() { - return randomElements.stream().map(RandomElement::toString).collect(ImmutableList.toImmutableList()).toString(); - } - - public RandomElements copyWithColor(String color) { - //color should overwrite existing RandomElements with the color and should not add a new on. Therefore, the uuid must be copied. - return new RandomElements(this.getUuid(), randomElements.stream() - .map(r -> r.copyWithTagAndColor(color)) - .collect(ImmutableList.toImmutableList())); - } -} diff --git a/src/main/java/de/janno/evaluator/dice/RandomElementsBuilder.java b/src/main/java/de/janno/evaluator/dice/RandomElementsBuilder.java new file mode 100644 index 0000000..9002049 --- /dev/null +++ b/src/main/java/de/janno/evaluator/dice/RandomElementsBuilder.java @@ -0,0 +1,90 @@ +package de.janno.evaluator.dice; + + +import com.google.common.collect.ImmutableList; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NonNull; + +import java.util.*; +import java.util.stream.Collectors; + +/** + * Combines random elements of multiple sources. Random elements with the will overwrite elements with the diceId that where added bevor + */ +@EqualsAndHashCode +@Getter +public class RandomElementsBuilder { + private final List randomElements = new ArrayList<>(); + + private RandomElementsBuilder() { + } + + public static ImmutableList> fromRolls(@NonNull Collection rolls) { + return ofRolls(rolls).build(); + } + + public static RandomElementsBuilder empty() { + return new RandomElementsBuilder(); + } + + public static RandomElementsBuilder ofRoll(@NonNull Roll roll) { + return ofRolls(List.of(roll)); + } + + public static RandomElementsBuilder ofRolls(@NonNull Collection rolls) { + RandomElementsBuilder builder = new RandomElementsBuilder(); + rolls.forEach(r -> builder.addRandomElements(r.getRandomElementsInRoll().stream().flatMap(Collection::stream).toList())); + return builder; + } + + public RandomElementsBuilder addRandomElements(@NonNull Collection randomElements) { + this.randomElements.addAll(randomElements); + return this; + } + + public RandomElementsBuilder addRoll(@NonNull Roll roll) { + this.randomElements.addAll(roll.getRandomElementsInRoll().stream().flatMap(Collection::stream).toList()); + return this; + } + + public RandomElementsBuilder addWithColor(@NonNull Roll roll, @NonNull String color) { + this.randomElements.addAll(roll.getRandomElementsInRoll().stream().flatMap(Collection::stream) + .map(r -> r.copyWithTagAndColor(color)) + .toList()); + return this; + } + + public ImmutableList> build() { + + //This ensures that the last color application will overwrite the randomElements color + List uniqueList = new ArrayList<>(); + Map dieIdIndexMap = new HashMap<>(); + for (RandomElement re : randomElements) { + if (dieIdIndexMap.containsKey(re.getDieId())) { + int index = dieIdIndexMap.get(re.getDieId()); + uniqueList.set(index, re); + } else { + int index = uniqueList.size(); + uniqueList.add(re); + dieIdIndexMap.put(re.getDieId(), index); + } + } + + List rollIds = uniqueList.stream() + .map(RandomElement::getDieId) + .map(DieId::getRollId) + .distinct() + .sorted() + .toList(); + + Map> rollIdListMap = uniqueList.stream() + .collect(Collectors.groupingBy(r -> r.getDieId().getRollId())); + + return rollIds.stream() + .map(rid -> rollIdListMap.get(rid).stream().sorted(Comparator.comparing(RandomElement::getDieId)).collect(ImmutableList.toImmutableList())) + .collect(ImmutableList.toImmutableList()); + } + + +} diff --git a/src/main/java/de/janno/evaluator/dice/Roll.java b/src/main/java/de/janno/evaluator/dice/Roll.java index c3f0dce..c96fc67 100644 --- a/src/main/java/de/janno/evaluator/dice/Roll.java +++ b/src/main/java/de/janno/evaluator/dice/Roll.java @@ -1,16 +1,19 @@ package de.janno.evaluator.dice; import com.google.common.collect.ImmutableList; -import lombok.*; +import lombok.AccessLevel; +import lombok.EqualsAndHashCode; +import lombok.Getter; +import lombok.NonNull; import lombok.experimental.FieldDefaults; import java.math.BigDecimal; -import java.util.AbstractCollection; +import java.util.Collection; +import java.util.List; import java.util.Optional; import java.util.stream.Collectors; @Getter -@ToString @EqualsAndHashCode @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) public class Roll { @@ -19,29 +22,57 @@ public class Roll { String expression; @NonNull ImmutableList elements; + + /** + * all random elements that were involved in this roll, this can be more than the elements, because it includes also filtered elements + * The random elements are grouped by rollId + */ @NonNull - //all random elements that were involved in this roll, this can be more than the elements, because it includes also filtered elements - UniqueRandomElements randomElementsInRoll; - //all rolls that produced this roll + ImmutableList> randomElementsInRoll; + /** + * all rolls that produced this roll. The collection of the childrenRolls can be disabled and the list is then empty + */ + @NonNull ImmutableList childrenRolls; + /** + * The last expression position that created this roll + */ + @NonNull + ExpressionPosition expressionPosition; public Roll(@NonNull String expression, @NonNull ImmutableList elements, - @NonNull UniqueRandomElements randomElementsInRoll, + @NonNull ImmutableList> randomElementsInRoll, @NonNull ImmutableList childrenRolls, + @NonNull ExpressionPosition expressionPosition, int maxNumberOfElements, boolean keepChildRolls) throws ExpressionException { this.expression = expression; this.elements = elements; + validate(randomElementsInRoll); this.randomElementsInRoll = randomElementsInRoll; this.childrenRolls = keepChildRolls ? childrenRolls : ImmutableList.of(); + this.expressionPosition = expressionPosition; if (elements.size() > maxNumberOfElements) { - throw new ExpressionException("To many elements in roll '%s', max is %d but there where %d".formatted(expression, maxNumberOfElements, elements.size())); + throw new ExpressionException("To many elements in roll '%s', max is %d but there where %d".formatted(expression, maxNumberOfElements, elements.size()), expressionPosition); } - long numberOfRandomElementsInRoll = randomElementsInRoll.getRandomElements().stream().map(RandomElements::getRandomElements).mapToLong(AbstractCollection::size).sum(); + long numberOfRandomElementsInRoll = randomElementsInRoll.stream().mapToLong(List::size).sum(); if (numberOfRandomElementsInRoll > maxNumberOfElements) { - throw new ExpressionException("To many random elements in roll '%s', max is %d but there where %d".formatted(expression, maxNumberOfElements, numberOfRandomElementsInRoll)); + throw new ExpressionException("To many random elements in roll '%s', max is %d but there where %d".formatted(expression, maxNumberOfElements, numberOfRandomElementsInRoll), expressionPosition); + } + } + + private void validate(ImmutableList> randomElements) { + List diceIdsWithDuplicatedRandomElements = randomElements.stream() + .flatMap(Collection::stream) + .collect(Collectors.groupingBy(RandomElement::getDieId)).values().stream() + .filter(l -> l.size() > 1) + .map(r -> r.getFirst().getDieId()) + .toList(); + + if (!diceIdsWithDuplicatedRandomElements.isEmpty()) { + throw new IllegalStateException("Random elements must have unique dice ids but %s occurred more than once".formatted(diceIdsWithDuplicatedRandomElements)); } } @@ -74,10 +105,17 @@ public String getResultString() { return elements.stream().map(RollElement::toString).collect(Collectors.joining(", ")); } - public String getRandomElementsString() { - return randomElementsInRoll.getRandomElements().stream() - .map(l -> l.getRandomElements().stream().map(RandomElement::getRollElement).map(RollElement::toString).toList().toString()) - .collect(Collectors.joining(" ")); + public String getResultStringWithTagAndColor() { + return elements.stream().map(RollElement::toStringWithColorAndTag).collect(Collectors.joining(", ")); + } + + @Override + public String toString() { + return "Roll{" + + "expression='" + expression + '\'' + + ", randomElementsInRoll=" + randomElementsInRoll + + ", elements=" + elements + + '}'; } public boolean equalForValueAndTag(Roll other) { diff --git a/src/main/java/de/janno/evaluator/dice/RollBuilder.java b/src/main/java/de/janno/evaluator/dice/RollBuilder.java index b2dc302..18c2f65 100644 --- a/src/main/java/de/janno/evaluator/dice/RollBuilder.java +++ b/src/main/java/de/janno/evaluator/dice/RollBuilder.java @@ -4,20 +4,19 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; public interface RollBuilder { - static List extendAllBuilder(List rollBuilders, Map variableMap) throws ExpressionException { + static ImmutableList extendAllBuilder(@NonNull List rollBuilders, @NonNull RollContext rollContext) throws ExpressionException { ImmutableList.Builder builder = ImmutableList.builder(); for (RollBuilder rs : rollBuilders) { - extendRollBuilder(variableMap, rs, builder); + extendRollBuilder(rollContext, rs, builder); } return builder.build(); } - static void extendRollBuilder(@NonNull Map variableMap, RollBuilder rs, ImmutableList.Builder builder) throws ExpressionException { - Optional> r = rs.extendRoll(variableMap); + static void extendRollBuilder(@NonNull RollContext rollContext, @NonNull RollBuilder rs, @NonNull ImmutableList.Builder builder) throws ExpressionException { + Optional> r = rs.extendRoll(rollContext); //don't add empty rolls, they are the result from the value function and change the number of rolls (and then the operator/function //uses the roll with the wrong index r.ifPresent(builder::addAll); @@ -29,7 +28,9 @@ static void extendRollBuilder(@NonNull Map variableMap, RollBuilde * Some functions or operators (e.g. val repeatList) produces empty results, they musst be filtered out or the argument count in functions are not correct. * This is not a problem in operators because there the number of arguments is always correct because val is already pushed on the result stack */ - @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException; + @NonNull + Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException; - @NonNull String toExpression(); + @NonNull + String toExpression(); } diff --git a/src/main/java/de/janno/evaluator/dice/RollContext.java b/src/main/java/de/janno/evaluator/dice/RollContext.java new file mode 100644 index 0000000..a03aa57 --- /dev/null +++ b/src/main/java/de/janno/evaluator/dice/RollContext.java @@ -0,0 +1,62 @@ +package de.janno.evaluator.dice; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.atomic.AtomicInteger; + + +public class RollContext { + + private final List expressionPrefix = new ArrayList<>(); + private final Map currentVariables; + private final Map reEvaluationNumber; + + public RollContext() { + this(new ConcurrentHashMap<>(), new ConcurrentHashMap<>()); + } + + private RollContext(Map variables, Map reEvaluationNumber) { + this.currentVariables = variables; + this.reEvaluationNumber = reEvaluationNumber; + } + + + public int getNextReEvaluationNumber(ExpressionPosition expressionPosition) { + return reEvaluationNumber.computeIfAbsent(expressionPosition, s -> new AtomicInteger(0)).getAndIncrement(); + } + + + public RollContext copy() { + return new RollContext(new ConcurrentHashMap<>(currentVariables), new ConcurrentHashMap<>(reEvaluationNumber)); + } + + public RollContext copyWithEmptyVariables() { + return new RollContext(new ConcurrentHashMap<>(), new ConcurrentHashMap<>(reEvaluationNumber)); + } + + public void merge(RollContext rollContext) { + this.currentVariables.putAll(rollContext.currentVariables); + this.reEvaluationNumber.putAll(rollContext.reEvaluationNumber); + this.expressionPrefix.addAll(rollContext.expressionPrefix); + } + + public void putVariable(String name, Roll roll) { + this.expressionPrefix.add(roll.getExpression()); + this.currentVariables.put(name, roll); + } + + public Optional getVariable(String name) { + return Optional.ofNullable(this.currentVariables.get(name)); + } + + public Optional getExpressionPrefixString() { + if (expressionPrefix.isEmpty()) { + return Optional.empty(); + } + return Optional.of(String.join(", ", expressionPrefix)); + } + +} \ No newline at end of file diff --git a/src/main/java/de/janno/evaluator/dice/RollElement.java b/src/main/java/de/janno/evaluator/dice/RollElement.java index 1646dd8..56ae16d 100644 --- a/src/main/java/de/janno/evaluator/dice/RollElement.java +++ b/src/main/java/de/janno/evaluator/dice/RollElement.java @@ -1,5 +1,6 @@ package de.janno.evaluator.dice; +import com.google.common.base.Strings; import lombok.NonNull; import lombok.RequiredArgsConstructor; import lombok.Value; @@ -7,6 +8,8 @@ import java.math.BigDecimal; import java.util.Objects; import java.util.Optional; +import java.util.stream.Collectors; +import java.util.stream.Stream; @Value @RequiredArgsConstructor @@ -39,10 +42,10 @@ public Optional asDecimal() { } public Optional asBoolean() { - if (value.equals(String.valueOf(true))) { + if (value.equals(String.valueOf(true)) || value.equals("1")) { return Optional.of(true); } - if (value.equals(String.valueOf(false))) { + if (value.equals(String.valueOf(false)) || value.equals("0")) { return Optional.of(false); } return Optional.empty(); @@ -70,4 +73,12 @@ public String toString() { String outputTag = NO_TAG.equals(tag) ? "" : "%s:".formatted(tag); return "%s%s".formatted(outputTag, value); } + + public String toStringWithColorAndTag() { + String outputTag = NO_TAG.equals(tag) ? "" : "t:%s".formatted(tag); + String outputColor = NO_COLOR.equals(color) ? "" : "c:%s".formatted(color); + return Stream.of(value, outputTag, outputColor) + .filter(s -> !Strings.isNullOrEmpty(s)) + .collect(Collectors.joining("-")); + } } diff --git a/src/main/java/de/janno/evaluator/dice/RollId.java b/src/main/java/de/janno/evaluator/dice/RollId.java new file mode 100644 index 0000000..3745a7e --- /dev/null +++ b/src/main/java/de/janno/evaluator/dice/RollId.java @@ -0,0 +1,25 @@ +package de.janno.evaluator.dice; + +import lombok.NonNull; +import lombok.Value; + + +@Value(staticConstructor = "of") +public class RollId implements Comparable { + @NonNull + ExpressionPosition expressionPosition; + int reevaluate; + + @Override + public String toString() { + return expressionPosition + "e" + reevaluate; + } + + @Override + public int compareTo(RollId o) { + if (!expressionPosition.equals(o.expressionPosition)) { + return expressionPosition.compareTo(o.expressionPosition); + } + return Integer.compare(reevaluate, o.reevaluate); + } +} diff --git a/src/main/java/de/janno/evaluator/dice/RollResult.java b/src/main/java/de/janno/evaluator/dice/RollResult.java new file mode 100644 index 0000000..af373ab --- /dev/null +++ b/src/main/java/de/janno/evaluator/dice/RollResult.java @@ -0,0 +1,19 @@ +package de.janno.evaluator.dice; + +import com.google.common.collect.ImmutableList; +import lombok.Value; + +import javax.annotation.concurrent.Immutable; +import java.util.List; + +@Value +public class RollResult { + /** + * The expression that was the input for the roll. + */ + String expression; + /** + * The result of the expression roll. This can be multiple values, if the expression can't be reduced to a single value. + */ + ImmutableList rolls; +} diff --git a/src/main/java/de/janno/evaluator/dice/Roller.java b/src/main/java/de/janno/evaluator/dice/Roller.java index ca14b81..fa06893 100644 --- a/src/main/java/de/janno/evaluator/dice/Roller.java +++ b/src/main/java/de/janno/evaluator/dice/Roller.java @@ -6,5 +6,5 @@ @FunctionalInterface public interface Roller { - @NonNull List roll() throws ExpressionException; + @NonNull RollResult roll() throws ExpressionException; } diff --git a/src/main/java/de/janno/evaluator/dice/Token.java b/src/main/java/de/janno/evaluator/dice/Token.java index 6f0d0bc..d54c9b5 100644 --- a/src/main/java/de/janno/evaluator/dice/Token.java +++ b/src/main/java/de/janno/evaluator/dice/Token.java @@ -1,16 +1,16 @@ package de.janno.evaluator.dice; -import lombok.EqualsAndHashCode; +import lombok.Getter; import lombok.NonNull; import java.util.Optional; -@EqualsAndHashCode public class Token { + @Getter @NonNull - private final Kind kind; + private final ExpressionPosition expressionPosition; @NonNull - private final String inputValue; + private final Kind kind; private final Operator operator; private final Function function; private final String literal; @@ -19,9 +19,9 @@ public class Token { private final Operator.OperatorType operatorType; - private Token(@NonNull Kind kind, @NonNull String inputValue, Operator operator, Function function, String literal, Operator.OperatorType operatorType, BracketPair bracketPair) { + private Token(@NonNull Kind kind, @NonNull ExpressionPosition expressionPosition, Operator operator, Function function, String literal, Operator.OperatorType operatorType, BracketPair bracketPair) { this.kind = kind; - this.inputValue = inputValue; + this.expressionPosition = expressionPosition; this.operator = operator; this.function = function; this.literal = literal; @@ -29,46 +29,46 @@ private Token(@NonNull Kind kind, @NonNull String inputValue, Operator operator, this.bracketPair = bracketPair; } - public static Token addOpenBracket(Token token, String brackets) { - return new Token(token.kind, brackets + token.getInputValue(), token.operator, token.function, token.literal, token.operatorType, token.bracketPair); + public static Token addOpenBracket(@NonNull Token token, @NonNull String brackets) { + return new Token(token.kind, token.expressionPosition.extendLeft(brackets), token.operator, token.function, token.literal, token.operatorType, token.bracketPair); } - public static Token addCloseBracket(Token token, String brackets) { - return new Token(token.kind, token.getInputValue() + brackets, token.operator, token.function, token.literal, token.operatorType, token.bracketPair); + public static Token addCloseBracket(@NonNull Token token, @NonNull String brackets) { + return new Token(token.kind, token.expressionPosition.extendRight(brackets), token.operator, token.function, token.literal, token.operatorType, token.bracketPair); } - public static Token of(Operator operator, String inputValue) { - return new Token(Kind.OPERATOR, inputValue, operator, null, null, null, null); + public static Token of(@NonNull Operator operator, @NonNull ExpressionPosition expressionPosition) { + return new Token(Kind.OPERATOR, expressionPosition, operator, null, null, null, null); } - public static Token of(Operator operator, Operator.OperatorType operatorType, String inputValue) { + public static Token of(@NonNull Operator operator, @NonNull Operator.OperatorType operatorType, @NonNull ExpressionPosition expressionPosition) { if (operatorType == Operator.OperatorType.UNARY && !operator.supportUnaryOperation()) { throw new IllegalArgumentException(operator + "only supports binary operation"); } if (operatorType == Operator.OperatorType.BINARY && !operator.supportBinaryOperation()) { throw new IllegalArgumentException(operator + "only supports unary operation"); } - return new Token(Kind.OPERATOR, inputValue, operator, null, null, operatorType, null); + return new Token(Kind.OPERATOR, expressionPosition, operator, null, null, operatorType, null); } - public static Token of(Function function, String inputValue) { - return new Token(Kind.FUNCTION, inputValue, null, function, null, null, null); + public static Token of(@NonNull Function function, @NonNull ExpressionPosition expressionPosition) { + return new Token(Kind.FUNCTION, expressionPosition, null, function, null, null, null); } - public static Token of(String literal, String inputValue) { - return new Token(Kind.LITERAL, inputValue, null, null, literal, null, null); + public static Token of(@NonNull String literal, @NonNull ExpressionPosition expressionPosition) { + return new Token(Kind.LITERAL, expressionPosition, null, null, literal, null, null); } - public static Token openTokenOf(BracketPair bracketPair, String inputValue) { - return new Token(Kind.OPEN_BRACKET, inputValue, null, null, null, null, bracketPair); + public static Token openTokenOf(@NonNull BracketPair bracketPair, @NonNull ExpressionPosition expressionPosition) { + return new Token(Kind.OPEN_BRACKET, expressionPosition, null, null, null, null, bracketPair); } - public static Token closeTokenOf(BracketPair bracketPair, String inputValue) { - return new Token(Kind.CLOSE_BRACKET, inputValue, null, null, null, null, bracketPair); + public static Token closeTokenOf(@NonNull BracketPair bracketPair, @NonNull ExpressionPosition expressionPosition) { + return new Token(Kind.CLOSE_BRACKET, expressionPosition, null, null, null, null, bracketPair); } - public static Token separator(String inputValue) { - return new Token(Kind.SEPARATOR, inputValue, null, null, null, null, null); + public static Token separator(@NonNull ExpressionPosition expressionPosition) { + return new Token(Kind.SEPARATOR, expressionPosition, null, null, null, null, null); } public Optional getBrackets() { @@ -111,10 +111,6 @@ public Optional getOperatorPrecedence() { return getOperator().map(o -> o.getPrecedenceForOperantType(operatorType)); } - public @NonNull String getInputValue() { - return inputValue; - } - @Override public String toString() { return switch (kind) { diff --git a/src/main/java/de/janno/evaluator/dice/Tokenizer.java b/src/main/java/de/janno/evaluator/dice/Tokenizer.java index d06f1f2..88bac79 100644 --- a/src/main/java/de/janno/evaluator/dice/Tokenizer.java +++ b/src/main/java/de/janno/evaluator/dice/Tokenizer.java @@ -2,8 +2,8 @@ import com.google.common.collect.ImmutableList; import lombok.NonNull; -import org.checkerframework.checker.nullness.qual.Nullable; +import javax.annotation.Nullable; import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -29,18 +29,18 @@ public Tokenizer(Parameters parameters) { Stream.concat(parameters.getExpressionBrackets().stream(), parameters.getFunctionBrackets().stream()) .distinct() //expression and function brackets are allowed to contain the same elements .forEach(c -> { - builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(c.getOpen()), s -> Token.openTokenOf(c, s), false)); - builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(c.getClose()), s -> Token.closeTokenOf(c, s), false)); + builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(c.getOpen()), expressionPosition -> Token.openTokenOf(c, expressionPosition), false)); + builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(c.getClose()), expressionPosition -> Token.closeTokenOf(c, expressionPosition), false)); }); - parameters.getFunctions().forEach(function -> builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(function.getName()), s -> Token.of(function, s), false))); - parameters.getOperators().forEach(operator -> builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(operator.getName()), s -> Token.of(operator, s), false))); + parameters.getFunctions().forEach(function -> builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(function.getName()), expressionPosition -> Token.of(function, expressionPosition), false))); + parameters.getOperators().forEach(operator -> builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(operator.getName()), expressionPosition -> Token.of(operator, expressionPosition), false))); builder.add(new TokenBuilder(escapeForRegexAndAddCaseInsensitivity(parameters.getSeparator()), Token::separator, false)); - parameters.getEscapeBrackets().forEach(b -> builder.add(new TokenBuilder(buildEscapeBracketsRegex(b), s -> Token.of(s.substring(1, s.length() - 1), s), true))); - builder.add(new TokenBuilder(ALL_NUMBER_REGEX, s -> { - if (SMALL_INTEGER_PATTERN.matcher(s).matches() || SMALL_DECIMAL_PATTERN.matcher(s).matches()) { - return Token.of(s, s); + parameters.getEscapeBrackets().forEach(b -> builder.add(new TokenBuilder(buildEscapeBracketsRegex(b), expressionPosition -> Token.of(expressionPosition.getValue().substring(1, expressionPosition.getValue().length() - 1), expressionPosition), true))); + builder.add(new TokenBuilder(ALL_NUMBER_REGEX, expressionPosition -> { + if (SMALL_INTEGER_PATTERN.matcher(expressionPosition.getValue()).matches() || SMALL_DECIMAL_PATTERN.matcher(expressionPosition.getValue()).matches()) { + return Token.of(expressionPosition.getValue(), expressionPosition); } - throw new ExpressionException("The number '%s' is too big".formatted(s)); + throw new ExpressionException("The number '%s' is too big".formatted(expressionPosition.getValue()), expressionPosition); }, false)); tokenBuilders = builder.build(); @@ -68,21 +68,38 @@ private static String escapeForRegexAndAddCaseInsensitivity(String in) { return "(?i)\\Q%s\\E(?-i)".formatted(in); } + private static int countLeadingWhitespaces(String input) { + int spaceCount = 0; + for (char c : input.toCharArray()) { + if (c == ' ') { + spaceCount++; + } else { + break; + } + } + return spaceCount; + } + public List tokenize(final String input) throws ExpressionException { List preTokens = new ArrayList<>(); String current = input.trim(); - Optional currentMatch; + //input it trimmed and has never leading spaces + int currentPositionWithSpace = 0; + Optional currentMatch; do { - currentMatch = getBestMatch(current); + currentMatch = getBestMatch(current, currentPositionWithSpace); if (currentMatch.isPresent()) { - Match match = currentMatch.get(); - Token token = match.token(); + Token token = currentMatch.get(); preTokens.add(token); - current = current.substring(match.match().length()).trim(); + int matchLength = token.getExpressionPosition().getValue().length(); + currentPositionWithSpace += matchLength; + String substringWithSpace = current.substring(matchLength); + currentPositionWithSpace += countLeadingWhitespaces(substringWithSpace); + current = substringWithSpace.trim(); } } while (currentMatch.isPresent()); if (!current.isEmpty()) { - throw new ExpressionException("No matching operator for '%s', non-functional text and value names must to be surrounded by %s".formatted(current, escapeCharacter)); + throw new ExpressionException("No matching operator for '%s', non-functional text and value names must to be surrounded by %s".formatted(current, escapeCharacter), ExpressionPosition.of(currentPositionWithSpace, current)); } return setOperatorType(preTokens); @@ -104,8 +121,8 @@ private List setOperatorType(List in) throws ExpressionException { if (token.getOperator().isPresent()) { Token left = i == 0 ? null : in.get(i - 1); Token right = i == in.size() - 1 ? null : in.get(i + 1); - Operator.OperatorType type = determineAndValidateOperatorType(token.getOperator().get(), left, right, lastOperatorWasUnaryLeft); - builder.add(Token.of(token.getOperator().get(), type, token.getInputValue())); + Operator.OperatorType type = determineAndValidateOperatorType(token, left, right, lastOperatorWasUnaryLeft); + builder.add(Token.of(token.getOperator().get(), type, token.getExpressionPosition())); lastOperatorWasUnaryLeft = type == Operator.OperatorType.UNARY && token.getOperator().get().getAssociativityForOperantType(Operator.OperatorType.UNARY) == Operator.Associativity.LEFT; } else { builder.add(token); @@ -149,8 +166,11 @@ private Optional getFollowingCloseBrackets(List in, int index) { return Optional.of(brackets.toString()); } - private Operator.OperatorType determineAndValidateOperatorType(@NonNull Operator operator, @Nullable Token left, @Nullable Token right, boolean lastOperatorWasUnaryLeft) throws ExpressionException { + private Operator.OperatorType determineAndValidateOperatorType(@NonNull Token token, @Nullable Token left, @Nullable Token right, boolean lastOperatorWasUnaryLeft) throws ExpressionException { //todo cleanup + + //has operator is already checked + Operator operator = token.getOperator().orElseThrow(); boolean leftLiteralOrBracket = left != null && (left.getLiteral().isPresent() || left.isCloseBracket() || (left.getOperator().isPresent() && lastOperatorWasUnaryLeft)); boolean rightLiteralOrBracket = right != null && (right.getLiteral().isPresent() || right.isOpenBracket() || (right.getOperator().isPresent() && right.getOperator().get().getAssociativityForOperantType(Operator.OperatorType.UNARY) == Operator.Associativity.RIGHT) @@ -158,57 +178,59 @@ private Operator.OperatorType determineAndValidateOperatorType(@NonNull Operator if (leftLiteralOrBracket && rightLiteralOrBracket) { if (!operator.supportBinaryOperation()) { - throw new ExpressionException("Operator %s does not support binary operations".formatted(operator.getName())); + throw new ExpressionException("Operator %s does not support binary operations".formatted(operator.getName()), token.getExpressionPosition()); } return Operator.OperatorType.BINARY; } if (!operator.supportUnaryOperation()) { - throw new ExpressionException("Operator %s does not support unary operations".formatted(operator.getName())); + throw new ExpressionException("Operator %s does not support unary operations".formatted(operator.getName()), token.getExpressionPosition()); } Operator.Associativity operatorAssociativity = operator.getAssociativityForOperantType(Operator.OperatorType.UNARY); if (operatorAssociativity == Operator.Associativity.LEFT && !leftLiteralOrBracket) { - throw new ExpressionException("Operator %s has left associativity but the left value was: %s".formatted(operator.getName(), Optional.ofNullable(left).map(Object::toString).orElse("empty"))); + throw new ExpressionException("Operator %s has left associativity but the left value was: %s".formatted(operator.getName(), Optional.ofNullable(left).map(Object::toString).orElse("empty")), token.getExpressionPosition()); } if (operatorAssociativity == Operator.Associativity.RIGHT && !rightLiteralOrBracket) { - throw new ExpressionException("Operator %s has right associativity but the right value was: %s".formatted(operator.getName(), Optional.ofNullable(right).map(Object::toString).orElse("empty"))); + throw new ExpressionException("Operator %s has right associativity but the right value was: %s".formatted(operator.getName(), Optional.ofNullable(right).map(Object::toString).orElse("empty")), token.getExpressionPosition()); } return Operator.OperatorType.UNARY; } - private Optional getBestMatch(String input) throws ExpressionException { - List allMatches = getAllMatches(input); + private Optional getBestMatch(String input, int position) throws ExpressionException { + List allMatches = getAllMatches(input, position); int maxLength = allMatches.stream() - .mapToInt(Match::length) + .map(Token::getExpressionPosition) + .map(ExpressionPosition::getValue) + .mapToInt(String::length) .max() .orElse(0); - List maxLengthMatches = allMatches.stream() - .filter(m -> m.length() == maxLength) + List maxLengthMatches = allMatches.stream() + .filter(m -> m.getExpressionPosition().getValue().length() == maxLength) .toList(); if (maxLengthMatches.isEmpty()) { return Optional.empty(); } if (maxLengthMatches.size() > 1) { - throw new IllegalStateException("More then one operator matched the input %s: %s".formatted(input, maxLengthMatches.stream().map(Match::token).map(Token::toString).toList())); + throw new IllegalStateException("More then one operator matched the input %s: %s".formatted(input, maxLengthMatches.stream().map(Token::toString).toList())); } return Optional.of(maxLengthMatches.getFirst()); } - private List getAllMatches(String input) throws ExpressionException { - ImmutableList.Builder matchBuilder = ImmutableList.builder(); + private List getAllMatches(String input, int position) throws ExpressionException { + ImmutableList.Builder matchBuilder = ImmutableList.builder(); for (Tokenizer.TokenBuilder tokenBuilder : tokenBuilders) { - Optional firstMatch = getFirstMatch(input, tokenBuilder); + Optional firstMatch = getFirstMatch(input, tokenBuilder, position); firstMatch.ifPresent(matchBuilder::add); } return matchBuilder.build(); } - private Optional getFirstMatch(String input, TokenBuilder tokenBuilder) throws ExpressionException { + private Optional getFirstMatch(String input, TokenBuilder tokenBuilder, int position) throws ExpressionException { Matcher matcher = tokenBuilder.pattern().matcher(input); if (matcher.find()) { String matchGroup = matcher.group().trim(); - return Optional.of(new Match(matcher.start(), matchGroup, tokenBuilder.toToken().apply(matchGroup))); + return Optional.of(tokenBuilder.toToken().apply(ExpressionPosition.of(position, matchGroup))); } return Optional.empty(); } @@ -218,13 +240,7 @@ public boolean expressionContainsOperatorOrFunction(String expression) { } private interface ToToken { - Token apply(String in) throws ExpressionException; - } - - private record Match(int start, String match, Token token) { - public int length() { - return match.length(); - } + Token apply(ExpressionPosition expressionPosition) throws ExpressionException; } private record TokenBuilder(String regex, ToToken toToken, boolean multiLine) { diff --git a/src/main/java/de/janno/evaluator/dice/UniqueRandomElements.java b/src/main/java/de/janno/evaluator/dice/UniqueRandomElements.java deleted file mode 100644 index 816ebd5..0000000 --- a/src/main/java/de/janno/evaluator/dice/UniqueRandomElements.java +++ /dev/null @@ -1,95 +0,0 @@ -package de.janno.evaluator.dice; - - -import com.google.common.collect.ImmutableList; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.NonNull; - -import java.util.Collection; -import java.util.stream.Collectors; - -@EqualsAndHashCode -@Getter -public class UniqueRandomElements { - private final ImmutableList randomElements; - - public UniqueRandomElements(ImmutableList randomElements) { - ImmutableList uniqueList = ImmutableList.of(); - for (RandomElements re : randomElements) { - uniqueList = addElement(uniqueList, re); - } - this.randomElements = uniqueList; - } - - //the last unique RandomElements remains, not the best option because it depends on the correct order of the list. - //TODO find a better solution to ensure that the last color application will overwrite the randomElements color - private static ImmutableList addElement(ImmutableList randomElements, RandomElements toAdd) { - if (toAdd.getRandomElements().isEmpty()) { - return randomElements; - } - //add the new one if there is none with the same uuid - if (randomElements.stream().noneMatch(re -> toAdd.getUuid().equals(re.getUuid()))) { - return ImmutableList.builder() - .addAll(randomElements) - .add(toAdd) - .build(); - } - //if there is one with the same uuid, it gets replaced (relevant for not changing the color of the random elements) - return randomElements.stream() - .map(re -> { - if (toAdd.getUuid().equals(re.getUuid())) { - return toAdd; - } - return re; - }) - .collect(ImmutableList.toImmutableList()); - - } - - public static UniqueRandomElements from(Collection rolls) { - UniqueRandomElements.Builder builder = UniqueRandomElements.builder(); - rolls.forEach(r -> builder.add(r.getRandomElementsInRoll())); - return builder.build(); - } - - public static Builder builder() { - return new Builder(); - } - - public static UniqueRandomElements empty() { - return new UniqueRandomElements(ImmutableList.of()); - } - - public String toString() { - return randomElements.stream().map(RandomElements::toString).collect(Collectors.joining(", ")); - } - - public static class Builder { - private final ImmutableList.Builder randomElements = ImmutableList.builder(); - - public Builder add(@NonNull RandomElements randomElements) { - this.randomElements.add(randomElements); - return this; - } - - public Builder addAsRandomElements(@NonNull Collection randomElements) { - this.randomElements.add(new RandomElements(ImmutableList.copyOf(randomElements))); - return this; - } - - public Builder add(@NonNull UniqueRandomElements randomElements) { - this.randomElements.addAll(randomElements.getRandomElements()); - return this; - } - - public Builder addWithColor(@NonNull UniqueRandomElements randomElements, @NonNull String color) { - randomElements.getRandomElements().forEach(re -> this.add(re.copyWithColor(color))); - return this; - } - - public UniqueRandomElements build() { - return new UniqueRandomElements(randomElements.build()); - } - } -} diff --git a/src/main/java/de/janno/evaluator/dice/ValidatorUtil.java b/src/main/java/de/janno/evaluator/dice/ValidatorUtil.java index 05e6bdc..46fc2a6 100644 --- a/src/main/java/de/janno/evaluator/dice/ValidatorUtil.java +++ b/src/main/java/de/janno/evaluator/dice/ValidatorUtil.java @@ -9,23 +9,23 @@ import java.util.stream.Collectors; public final class ValidatorUtil { - public static ExpressionException throwNotIntegerExpression(@NonNull String inputName, @NonNull Roll roll, @NonNull String location) { - return new ExpressionException(String.format("'%s' requires as %s input a single integer but was '%s'%s", inputName, location, roll.getElements().stream() + public static ExpressionException throwNotIntegerExpression(@NonNull ExpressionPosition expressionPosition, @NonNull Roll roll, @NonNull String location) { + return new ExpressionException(String.format("'%s' requires as %s input a single integer but was '%s'%s", expressionPosition.getValue(), location, roll.getElements().stream() .map(RollElement::getValue) - .toList(), getSumHelp(roll))); + .toList(), getSumHelp(roll)), expressionPosition); } - public static ExpressionException throwNotBoolean(@NonNull String inputName, @NonNull Roll roll, @NonNull String location) { - return new ExpressionException(String.format("'%s' requires as %s input a single boolean but was '%s'", inputName, location, roll.getElements().stream() + public static ExpressionException throwNotBoolean(@NonNull ExpressionPosition expressionPosition, @NonNull Roll roll, @NonNull String location) { + return new ExpressionException(String.format("'%s' requires as %s input a single boolean but was '%s'", expressionPosition.getValue(), location, roll.getElements().stream() .map(RollElement::getValue) - .toList())); + .toList()), expressionPosition); } - public static ExpressionException throwNotDecimalExpression(@NonNull String inputName, @NonNull Roll roll, @NonNull String location) { - return new ExpressionException(String.format("'%s' requires as %s input a single decimal but was '%s'%s", inputName, location, roll.getElements().stream() + public static ExpressionException throwNotDecimalExpression(@NonNull ExpressionPosition expressionPosition, @NonNull Roll roll, @NonNull String location) { + return new ExpressionException(String.format("'%s' requires as %s input a single decimal but was '%s'%s", expressionPosition.getValue(), location, roll.getElements().stream() .map(RollElement::getValue) - .toList(), getSumHelp(roll))); + .toList(), getSumHelp(roll)), expressionPosition); } @@ -34,35 +34,35 @@ private static String getSumHelp(@NonNull Roll roll) { return numberList ? ". Try to sum the numbers together like (%s=)".formatted(roll.getExpression()) : ""; } - public static void checkContainsOnlyDecimal(@NonNull String inputName, @NonNull Roll roll, @NonNull String location) throws ExpressionException { + public static void checkContainsOnlyDecimal(@NonNull ExpressionPosition expressionPosition, @NonNull Roll roll, @NonNull String location) throws ExpressionException { if (!roll.containsOnlyDecimals()) { - throw new ExpressionException(String.format("'%s' requires as %s input only decimals but was '%s'", inputName, location, roll.getElements().stream() - .map(RollElement::getValue).toList())); + throw new ExpressionException(String.format("'%s' requires as %s input only decimals but was '%s'", expressionPosition.getValue(), location, roll.getElements().stream() + .map(RollElement::getValue).toList()), expressionPosition); } } - public static void checkContainsSingleElement(@NonNull String inputName, @NonNull Roll roll, @NonNull String location) throws ExpressionException { + public static void checkContainsSingleElement(@NonNull ExpressionPosition expressionPosition, @NonNull Roll roll, @NonNull String location) throws ExpressionException { if (roll.getElements().size() != 1) { - throw new ExpressionException(String.format("'%s' requires as %s a single element but was '%s'%s", inputName, location, roll.getElements().stream() + throw new ExpressionException(String.format("'%s' requires as %s a single element but was '%s'%s", expressionPosition.getValue(), location, roll.getElements().stream() .map(RollElement::getValue).toList(), getSumHelp(roll) - )); + ), expressionPosition); } } - public static void checkRollSize(@NonNull String inputName, @NonNull List rolls, int minInc, int maxInc) throws ExpressionException { + public static void checkRollSize(@NonNull ExpressionPosition expressionPosition, @NonNull List rolls, int minInc, int maxInc) throws ExpressionException { if (rolls.size() < minInc || rolls.size() > maxInc) { String range = minInc == maxInc ? String.valueOf(minInc) : "%d-%d".formatted(minInc, maxInc); - throw new ExpressionException(String.format("'%s' requires as %s inputs but was '%s'", inputName, range, rolls.stream() + throw new ExpressionException(String.format("'%s' requires as %s inputs but was '%s'", expressionPosition.getValue(), range, rolls.stream() .map(Roll::getElements).toList() - )); + ), expressionPosition); } } - public static void checkAllElementsAreSameTag(@NonNull String operatorName, @NonNull Roll... rolls) throws ExpressionException { + public static void checkAllElementsAreSameTag(@NonNull ExpressionPosition expressionPosition, @NonNull Roll... rolls) throws ExpressionException { Set allElementTags = Arrays.stream(rolls).flatMap(r -> r.getElements().stream()).map(RollElement::getTag).collect(Collectors.toSet()); if (allElementTags.size() != 1) { - throw new ExpressionException(String.format("'%s' requires all elements to be the same tag, the tags where '%s'", operatorName, allElementTags)); + throw new ExpressionException(String.format("'%s' requires all elements to be the same tag, the tags where '%s'", expressionPosition.getValue(), allElementTags), expressionPosition); } } } diff --git a/src/main/java/de/janno/evaluator/dice/function/AbstractIf.java b/src/main/java/de/janno/evaluator/dice/function/AbstractIf.java index 21f184f..5d6182c 100644 --- a/src/main/java/de/janno/evaluator/dice/function/AbstractIf.java +++ b/src/main/java/de/janno/evaluator/dice/function/AbstractIf.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -18,31 +17,30 @@ public AbstractIf(@NonNull String name, int maxNumberOfElements, boolean keepChi } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); Roll input = rolls.getFirst(); int counter = 1; - UniqueRandomElements.Builder randomElements = UniqueRandomElements.builder(); - randomElements.add(input.getRandomElementsInRoll()); + RandomElementsBuilder randomElementsBuilder = RandomElementsBuilder.ofRoll(input); while (counter < rolls.size() - 1) { Roll compareTo = rolls.get(counter); Roll trueResult = rolls.get(counter + 1); - randomElements.add(compareTo.getRandomElementsInRoll()); - if (compare(input, counter, compareTo, counter + 1)) { - randomElements.add(trueResult.getRandomElementsInRoll()); + randomElementsBuilder.addRoll(compareTo); + if (compare(input, counter, compareTo, counter + 1, expressionPosition)) { + randomElementsBuilder.addRoll(trueResult); return Optional.of(ImmutableList.of(new Roll(toExpression(), trueResult.getElements(), - randomElements.build(), + randomElementsBuilder.build(), ImmutableList.builder() .addAll(input.getChildrenRolls()) .addAll(trueResult.getChildrenRolls()) - .build(), maxNumberOfElements, keepChildrenRolls))); + .build(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } counter += 2; } @@ -51,27 +49,27 @@ public AbstractIf(@NonNull String name, int maxNumberOfElements, boolean keepChi //there is a last element in the arguments, which is the default result if (counter != rolls.size()) { result = rolls.getLast(); - randomElements.add(result.getRandomElementsInRoll()); + randomElementsBuilder.addRoll(result); } else { //if there is no default result, the result is the input result = input; } return Optional.of(ImmutableList.of(new Roll(toExpression(), result.getElements(), - randomElements.build(), + randomElementsBuilder.build(), ImmutableList.builder() .addAll(input.getChildrenRolls()) .addAll(result.getChildrenRolls()) - .build(), maxNumberOfElements, keepChildrenRolls))); + .build(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } - protected abstract boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition) throws ExpressionException; + protected abstract boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition, ExpressionPosition expressionPosition) throws ExpressionException; } diff --git a/src/main/java/de/janno/evaluator/dice/function/Cancel.java b/src/main/java/de/janno/evaluator/dice/function/Cancel.java index c052820..56a9060 100644 --- a/src/main/java/de/janno/evaluator/dice/function/Cancel.java +++ b/src/main/java/de/janno/evaluator/dice/function/Cancel.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -17,12 +16,12 @@ public Cancel(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); Roll input = rolls.getFirst(); Roll typeA = rolls.get(1); Roll typeB = rolls.get(2); @@ -47,17 +46,17 @@ public Cancel(int maxNumberOfElements, boolean keepChildrenRolls) { } return Optional.of(ImmutableList.of(new Roll(toExpression(), resultBuilder.build(), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.builder() .addAll(input.getChildrenRolls()) .addAll(typeA.getChildrenRolls()) .addAll(typeB.getChildrenRolls()) - .build(), maxNumberOfElements, keepChildrenRolls))); + .build(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/ColorFunction.java b/src/main/java/de/janno/evaluator/dice/function/ColorFunction.java index 12f1e9f..ed342ae 100644 --- a/src/main/java/de/janno/evaluator/dice/function/ColorFunction.java +++ b/src/main/java/de/janno/evaluator/dice/function/ColorFunction.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -23,30 +22,30 @@ public ColorFunction(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); Roll p1 = rolls.getFirst(); Roll p2 = rolls.get(1); - checkContainsSingleElement(inputValue, p2, "second argument"); + checkContainsSingleElement(expressionPosition, p2, "second argument"); String color = p2.getElements().getFirst().getValue(); - UniqueRandomElements.Builder builder = new UniqueRandomElements.Builder(); - rolls.forEach(r -> builder.addWithColor(r.getRandomElementsInRoll(), color)); + RandomElementsBuilder builder = RandomElementsBuilder.empty(); + rolls.forEach(r -> builder.addWithColor(r, color)); return Optional.of(ImmutableList.of(new Roll(toExpression(), p1.getElements().stream() .map(r -> new RollElement(r.getValue(), color, color)) .collect(ImmutableList.toImmutableList()), builder.build(), - p1.getChildrenRolls(), maxNumberOfElements, keepChildrenRolls))); + p1.getChildrenRolls(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/ConcatFunction.java b/src/main/java/de/janno/evaluator/dice/function/ConcatFunction.java index 0e5c77c..d355930 100644 --- a/src/main/java/de/janno/evaluator/dice/function/ConcatFunction.java +++ b/src/main/java/de/janno/evaluator/dice/function/ConcatFunction.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; @@ -17,11 +16,11 @@ public ConcatFunction(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); if (rolls.isEmpty()) { return Optional.empty(); } @@ -30,13 +29,13 @@ public ConcatFunction(int maxNumberOfElements, boolean keepChildrenRolls) { .collect(Collectors.joining()); return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement(joined, RollElement.NO_TAG, RollElement.NO_COLOR)), - UniqueRandomElements.from(rolls), - ImmutableList.copyOf(rolls), maxNumberOfElements, keepChildrenRolls))); + RandomElementsBuilder.fromRolls(rolls), + ImmutableList.copyOf(rolls), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/Double.java b/src/main/java/de/janno/evaluator/dice/function/Double.java index d5180ce..7335702 100644 --- a/src/main/java/de/janno/evaluator/dice/function/Double.java +++ b/src/main/java/de/janno/evaluator/dice/function/Double.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -22,12 +21,12 @@ public Double(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); Roll input = rolls.getFirst(); Roll toDuplicate = rolls.get(1); @@ -43,18 +42,18 @@ public Double(int maxNumberOfElements, boolean keepChildrenRolls) { return Optional.of(ImmutableList.of(new Roll(toExpression(), rollElements, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.builder() .addAll(input.getChildrenRolls()) .addAll(toDuplicate.getChildrenRolls()) - .build(), maxNumberOfElements, keepChildrenRolls))); + .build(), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; - + } } diff --git a/src/main/java/de/janno/evaluator/dice/function/Explode.java b/src/main/java/de/janno/evaluator/dice/function/Explode.java index 89aa3e2..c638c26 100644 --- a/src/main/java/de/janno/evaluator/dice/function/Explode.java +++ b/src/main/java/de/janno/evaluator/dice/function/Explode.java @@ -6,7 +6,6 @@ import java.util.Collections; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; @@ -18,40 +17,40 @@ public Explode(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { if (arguments.size() != 2 && arguments.size() != 3) { - throw new ExpressionException(String.format("'%s' requires 2 or 3 arguments but was %d", getName(), arguments.size())); + throw new ExpressionException(String.format("'%s' requires 2 or 3 arguments but was %d", getName(), arguments.size()), expressionPosition); } ImmutableList.Builder allChildrenRollBuilder = ImmutableList.builder(); ImmutableList.Builder rollExpression = ImmutableList.builder(); RollBuilder inputRoll = arguments.getFirst(); - final List firstRoll = inputRoll.extendRoll(variables).orElse(Collections.emptyList()); + final List firstRoll = inputRoll.extendRoll(rollContext).orElse(Collections.emptyList()); rollExpression.addAll(firstRoll); allChildrenRollBuilder.addAll(firstRoll); - Optional> compareToRoll = arguments.get(1).extendRoll(variables); + Optional> compareToRoll = arguments.get(1).extendRoll(rollContext); if (compareToRoll.isEmpty()) { - throw new ExpressionException(String.format("'%s' requires a non-empty input as second argument", inputValue)); + throw new ExpressionException(String.format("'%s' requires a non-empty input as second argument", expressionPosition.getValue()), expressionPosition); } - checkRollSize(inputValue, compareToRoll.get(), 1, 1); + checkRollSize(expressionPosition, compareToRoll.get(), 1, 1); Roll compareTo = compareToRoll.get().getFirst(); allChildrenRollBuilder.add(compareTo); rollExpression.add(compareTo); final int maxNumberOfRerolls; if (arguments.size() == 3) { - Optional> maxRerollsRoll = arguments.get(2).extendRoll(variables); + Optional> maxRerollsRoll = arguments.get(2).extendRoll(rollContext); if (maxRerollsRoll.isEmpty()) { - throw new ExpressionException(String.format("'%s' requires a non-empty input as third argument", inputValue)); + throw new ExpressionException(String.format("'%s' requires a non-empty input as third argument", expressionPosition.getValue()), expressionPosition); } - checkRollSize(inputValue, maxRerollsRoll.get(), 1, 1); + checkRollSize(expressionPosition, maxRerollsRoll.get(), 1, 1); Roll maxNumberOfRerollsRoll = maxRerollsRoll.get().getFirst(); - maxNumberOfRerolls = maxNumberOfRerollsRoll.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, maxRerollsRoll.get().getFirst(), "third argument")); + maxNumberOfRerolls = maxNumberOfRerollsRoll.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, maxRerollsRoll.get().getFirst(), "third argument")); if (maxNumberOfRerolls > 100 || maxNumberOfRerolls < 0) { - throw new ExpressionException(String.format("'%s' requires as third argument a number between 0 and 100", inputValue)); + throw new ExpressionException(String.format("'%s' requires as third argument a number between 0 and 100", expressionPosition.getValue()), expressionPosition); } allChildrenRollBuilder.add(maxNumberOfRerollsRoll); rollExpression.add(maxNumberOfRerollsRoll); @@ -64,7 +63,7 @@ public Explode(int maxNumberOfElements, boolean keepChildrenRolls) { ImmutableList.Builder allResultRollsBuilder = ImmutableList.builder(); allResultRollsBuilder.addAll(firstRoll); while (rerolls < maxNumberOfRerolls && lastRoll.stream().flatMap(r -> r.getElements().stream()).anyMatch(compareTo::isElementsContainsElementWithValueAndTag)) { - lastRoll = inputRoll.extendRoll(variables).orElse(Collections.emptyList()); + lastRoll = inputRoll.extendRoll(rollContext).orElse(Collections.emptyList()); allResultRollsBuilder.addAll(lastRoll); allChildrenRollBuilder.addAll(lastRoll); rerolls++; @@ -72,14 +71,15 @@ public Explode(int maxNumberOfElements, boolean keepChildrenRolls) { final ImmutableList allResultRolls = allResultRollsBuilder.build(); return Optional.of(ImmutableList.of(new Roll(toExpression(), allResultRolls.stream().flatMap(r -> r.getElements().stream()).collect(ImmutableList.toImmutableList()), - UniqueRandomElements.from(allChildrenRollBuilder.build()), allChildrenRollBuilder.build(), + RandomElementsBuilder.fromRolls(allChildrenRollBuilder.build()), allChildrenRollBuilder.build(), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; diff --git a/src/main/java/de/janno/evaluator/dice/function/GroupCount.java b/src/main/java/de/janno/evaluator/dice/function/GroupCount.java index d3346ef..bb9d6ad 100644 --- a/src/main/java/de/janno/evaluator/dice/function/GroupCount.java +++ b/src/main/java/de/janno/evaluator/dice/function/GroupCount.java @@ -20,12 +20,12 @@ public GroupCount(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); final ImmutableList res = rolls.stream() .flatMap(result -> result.getElements().stream()) .collect(Collectors.groupingBy(e -> new ValueAndTag(e.getValue(), e.getTag()))).entrySet().stream() @@ -35,13 +35,13 @@ public GroupCount(int maxNumberOfElements, boolean keepChildrenRolls) { return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), - ImmutableList.copyOf(rolls), maxNumberOfElements, keepChildrenRolls))); + RandomElementsBuilder.fromRolls(rolls), + ImmutableList.copyOf(rolls), expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/If.java b/src/main/java/de/janno/evaluator/dice/function/If.java index 7c9f07b..64eaf76 100644 --- a/src/main/java/de/janno/evaluator/dice/function/If.java +++ b/src/main/java/de/janno/evaluator/dice/function/If.java @@ -6,9 +6,7 @@ import java.util.Collections; import java.util.List; -import java.util.Map; import java.util.Optional; -import java.util.concurrent.ConcurrentHashMap; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; import static de.janno.evaluator.dice.ValidatorUtil.throwNotBoolean; @@ -19,61 +17,60 @@ public If(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { if (arguments.size() < 2) { - throw new ExpressionException(String.format("'%s' requires as 2 inputs but was '%s'", getName(), arguments.size())); + throw new ExpressionException(String.format("'%s' requires as 2 inputs but was '%s'", getName(), arguments.size()), expressionPosition); } ImmutableList.Builder allRolls = ImmutableList.builder(); - Optional> checkIfTrue = arguments.getFirst().extendRoll(variables); + Optional> checkIfTrue = arguments.getFirst().extendRoll(rollContext); if (checkIfTrue.isEmpty()) { - throw new ExpressionException(String.format("'%s' requires a non-empty input as first argument", inputValue)); + throw new ExpressionException(String.format("'%s' requires a non-empty input as first argument", expressionPosition.getValue()), expressionPosition); } - UniqueRandomElements.Builder booleanRandomElements = UniqueRandomElements.builder(); - Map trueVariable = new ConcurrentHashMap<>(variables); - Optional> returnIfTrue = arguments.get(1).extendRoll(trueVariable); + RandomElementsBuilder booleanRandomElements = RandomElementsBuilder.empty(); + RollContext trueContext = rollContext.copy(); + Optional> returnIfTrue = arguments.get(1).extendRoll(trueContext); int checkIfTrueIndex = 1; while (checkIfTrueIndex < arguments.size()) { if (checkIfTrue.isEmpty()) { - throw new ExpressionException(String.format("'%s' requires a non-empty input as %s argument", inputValue, checkIfTrueIndex)); + throw new ExpressionException(String.format("'%s' requires a non-empty input as %s argument", expressionPosition.getValue(), checkIfTrueIndex), expressionPosition); } - checkRollSize(inputValue, checkIfTrue.get(), 1, 1); + checkRollSize(expressionPosition, checkIfTrue.get(), 1, 1); Roll booleanExpression = checkIfTrue.get().getFirst(); allRolls.addAll(checkIfTrue.get()); allRolls.addAll(returnIfTrue.orElse(Collections.emptyList())); int booleanArgumentIndex = checkIfTrueIndex; final boolean booleanValue = booleanExpression.asBoolean() - .orElseThrow(() -> throwNotBoolean(inputValue, booleanExpression, "position %d".formatted(booleanArgumentIndex))); - booleanRandomElements.add(booleanExpression.getRandomElementsInRoll()); + .orElseThrow(() -> throwNotBoolean(expressionPosition, booleanExpression, "position %d".formatted(booleanArgumentIndex))); + booleanRandomElements.addRoll(booleanExpression); if (booleanValue) { List trueResult = returnIfTrue.orElse(Collections.emptyList()); - variables.putAll(trueVariable); //only the variable of the true result are added - UniqueRandomElements allBooleanRandomElements = booleanRandomElements.build(); + rollContext.merge(trueContext); //only the variable of the true result are added ImmutableList.Builder resultBuilder = ImmutableList.builder(); for (Roll r : trueResult) { resultBuilder.add(new Roll(toExpression(), r.getElements(), - UniqueRandomElements.builder() - .add(allBooleanRandomElements) - .add(r.getRandomElementsInRoll()) + booleanRandomElements + .addRoll(r) .build(), ImmutableList.builder() .addAll(booleanExpression.getChildrenRolls()) .addAll(r.getChildrenRolls()) .build(), + expressionPosition, maxNumberOfElements, keepChildrenRolls)); } return Optional.of(resultBuilder.build()); } checkIfTrueIndex = checkIfTrueIndex + 2; if (checkIfTrueIndex < arguments.size()) { - checkIfTrue = arguments.get(checkIfTrueIndex - 1).extendRoll(variables); - trueVariable = new ConcurrentHashMap<>(variables); //reset the true variables, we only add them to the result if the result was returned - returnIfTrue = arguments.get(checkIfTrueIndex).extendRoll(trueVariable); + checkIfTrue = arguments.get(checkIfTrueIndex - 1).extendRoll(rollContext); + trueContext = rollContext.copy(); //reset the true context, we only add them to the result if the result was returned + returnIfTrue = arguments.get(checkIfTrueIndex).extendRoll(trueContext); } else { //should not be read anymore, but making sure checkIfTrue = Optional.empty(); @@ -84,29 +81,36 @@ public If(int maxNumberOfElements, boolean keepChildrenRolls) { //there is a last element in the arguments, which is the default result and not a check value if (checkIfTrueIndex == arguments.size()) { - Optional> defaultResult = arguments.get(checkIfTrueIndex - 1).extendRoll(variables); + Optional> defaultResult = arguments.get(checkIfTrueIndex - 1).extendRoll(rollContext); if (defaultResult.isPresent()) { allRolls.addAll(defaultResult.get()); ImmutableList.Builder resultBuilder = ImmutableList.builder(); for (Roll r : defaultResult.get()) { resultBuilder.add(new Roll(toExpression(), r.getElements(), - UniqueRandomElements.builder() - .add(booleanRandomElements.build()) - .add(r.getRandomElementsInRoll()) - .build(), r.getChildrenRolls(), + booleanRandomElements + .addRoll(r) + .build(), + r.getChildrenRolls(), + expressionPosition, maxNumberOfElements, keepChildrenRolls)); } return Optional.of(resultBuilder.build()); } } - return Optional.empty(); + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(), + booleanRandomElements + .build(), + //todo child rolls? + ImmutableList.of(), + expressionPosition, + maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; diff --git a/src/main/java/de/janno/evaluator/dice/function/IfEqual.java b/src/main/java/de/janno/evaluator/dice/function/IfEqual.java index f1b6064..293d996 100644 --- a/src/main/java/de/janno/evaluator/dice/function/IfEqual.java +++ b/src/main/java/de/janno/evaluator/dice/function/IfEqual.java @@ -1,5 +1,6 @@ package de.janno.evaluator.dice.function; +import de.janno.evaluator.dice.ExpressionPosition; import de.janno.evaluator.dice.Roll; public class IfEqual extends AbstractIf { @@ -8,7 +9,7 @@ public IfEqual(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition) { + protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition, ExpressionPosition expressionPosition) { return input.equalForValueAndTag(compareTo); } } \ No newline at end of file diff --git a/src/main/java/de/janno/evaluator/dice/function/IfGreater.java b/src/main/java/de/janno/evaluator/dice/function/IfGreater.java index 223a41d..8096af0 100644 --- a/src/main/java/de/janno/evaluator/dice/function/IfGreater.java +++ b/src/main/java/de/janno/evaluator/dice/function/IfGreater.java @@ -1,6 +1,7 @@ package de.janno.evaluator.dice.function; import de.janno.evaluator.dice.ExpressionException; +import de.janno.evaluator.dice.ExpressionPosition; import de.janno.evaluator.dice.Roll; import static de.janno.evaluator.dice.ValidatorUtil.checkContainsSingleElement; @@ -11,9 +12,9 @@ public IfGreater(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition) throws ExpressionException { - checkContainsSingleElement(getName(), input, "%d argument".formatted(inputPosition)); - checkContainsSingleElement(getName(), compareTo, "%d argument".formatted(compareToPosition)); + protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition, ExpressionPosition expressionPosition) throws ExpressionException { + checkContainsSingleElement(expressionPosition, input, "%d argument".formatted(inputPosition)); + checkContainsSingleElement(expressionPosition, compareTo, "%d argument".formatted(compareToPosition)); return input.getElements().getFirst().compareTo(compareTo.getElements().getFirst()) > 0; } diff --git a/src/main/java/de/janno/evaluator/dice/function/IfIn.java b/src/main/java/de/janno/evaluator/dice/function/IfIn.java index 7ee673e..af61194 100644 --- a/src/main/java/de/janno/evaluator/dice/function/IfIn.java +++ b/src/main/java/de/janno/evaluator/dice/function/IfIn.java @@ -1,6 +1,7 @@ package de.janno.evaluator.dice.function; import de.janno.evaluator.dice.ExpressionException; +import de.janno.evaluator.dice.ExpressionPosition; import de.janno.evaluator.dice.Roll; import static de.janno.evaluator.dice.ValidatorUtil.checkContainsSingleElement; @@ -11,8 +12,8 @@ public IfIn(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition) throws ExpressionException { - checkContainsSingleElement(getName(), input, "%d argument".formatted(inputPosition)); + protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition, ExpressionPosition expressionPosition) throws ExpressionException { + checkContainsSingleElement(expressionPosition, input, "%d argument".formatted(inputPosition)); return compareTo.isElementsContainsElementWithValueAndTag(input.getElements().getFirst()); } } \ No newline at end of file diff --git a/src/main/java/de/janno/evaluator/dice/function/IfLesser.java b/src/main/java/de/janno/evaluator/dice/function/IfLesser.java index ba15f27..0788a43 100644 --- a/src/main/java/de/janno/evaluator/dice/function/IfLesser.java +++ b/src/main/java/de/janno/evaluator/dice/function/IfLesser.java @@ -1,6 +1,7 @@ package de.janno.evaluator.dice.function; import de.janno.evaluator.dice.ExpressionException; +import de.janno.evaluator.dice.ExpressionPosition; import de.janno.evaluator.dice.Roll; import static de.janno.evaluator.dice.ValidatorUtil.checkContainsSingleElement; @@ -11,9 +12,9 @@ public IfLesser(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition) throws ExpressionException { - checkContainsSingleElement(getName(), input, "%d argument".formatted(inputPosition)); - checkContainsSingleElement(getName(), compareTo, "%d argument".formatted(compareToPosition)); + protected boolean compare(Roll input, int inputPosition, Roll compareTo, int compareToPosition, ExpressionPosition expressionPosition) throws ExpressionException { + checkContainsSingleElement(expressionPosition, input, "%d argument".formatted(inputPosition)); + checkContainsSingleElement(expressionPosition, compareTo, "%d argument".formatted(compareToPosition)); return input.getElements().getFirst().compareTo(compareTo.getElements().getFirst()) < 0; } } \ No newline at end of file diff --git a/src/main/java/de/janno/evaluator/dice/function/Max.java b/src/main/java/de/janno/evaluator/dice/function/Max.java index 5dab9c7..619861a 100644 --- a/src/main/java/de/janno/evaluator/dice/function/Max.java +++ b/src/main/java/de/janno/evaluator/dice/function/Max.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -17,12 +16,12 @@ public Max(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); final RollElement max = rolls.stream() .flatMap(result -> result.getElements().stream()) @@ -34,14 +33,15 @@ public Max(int maxNumberOfElements, boolean keepChildrenRolls) { .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.copyOf(rolls), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; diff --git a/src/main/java/de/janno/evaluator/dice/function/Min.java b/src/main/java/de/janno/evaluator/dice/function/Min.java index 4887b6a..451939e 100644 --- a/src/main/java/de/janno/evaluator/dice/function/Min.java +++ b/src/main/java/de/janno/evaluator/dice/function/Min.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -17,12 +16,12 @@ public Min(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); final RollElement min = rolls.stream() .flatMap(result -> result.getElements().stream()) @@ -34,14 +33,15 @@ public Min(int maxNumberOfElements, boolean keepChildrenRolls) { .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.copyOf(rolls), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/Replace.java b/src/main/java/de/janno/evaluator/dice/function/Replace.java index 439f324..1734993 100644 --- a/src/main/java/de/janno/evaluator/dice/function/Replace.java +++ b/src/main/java/de/janno/evaluator/dice/function/Replace.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; public class Replace extends Function { @@ -14,16 +13,16 @@ public Replace(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { if (arguments.size() % 2 == 0) { - throw new ExpressionException(String.format("'%s' requires an odd number of arguments but was %d", getName(), arguments.size())); + throw new ExpressionException(String.format("'%s' requires an odd number of arguments but was %d", getName(), arguments.size()), expressionPosition); } - Optional> input = arguments.getFirst().extendRoll(variables); + Optional> input = arguments.getFirst().extendRoll(rollContext); if (input.isEmpty()) { - throw new ExpressionException(String.format("'%s' requires a non-empty input as first argument", inputValue)); + throw new ExpressionException(String.format("'%s' requires a non-empty input as first argument", expressionPosition.getValue()), expressionPosition); } ImmutableList.Builder allRolls = ImmutableList.builder(); ImmutableList.Builder rollExpression = ImmutableList.builder(); @@ -33,7 +32,7 @@ public Replace(int maxNumberOfElements, boolean keepChildrenRolls) { ImmutableList.Builder childrenRollBuilder = ImmutableList.builder() .addAll(input.get()); for (int i = 1; i < arguments.size() - 1; i = i + 2) { - Optional> find = arguments.get(i).extendRoll(variables); + Optional> find = arguments.get(i).extendRoll(rollContext); find.ifPresent(allRolls::addAll); if (find.isPresent() && rollElements.stream().anyMatch(r -> find.get().stream().anyMatch(f -> f.isElementsContainsElementWithValueAndTag(r)))) { childrenRollBuilder.addAll(find.get()); @@ -41,7 +40,7 @@ public Replace(int maxNumberOfElements, boolean keepChildrenRolls) { ImmutableList.Builder newRollElementsList = ImmutableList.builder(); for (RollElement r : rollElements) { if (find.get().stream().anyMatch(f -> f.isElementsContainsElementWithValueAndTag(r))) { - Optional> replace = replaceArgument.extendRoll(variables); + Optional> replace = replaceArgument.extendRoll(rollContext); replace.ifPresent(allRolls::addAll); if (replace.isPresent()) { childrenRollBuilder.addAll(replace.get()); @@ -60,14 +59,15 @@ public Replace(int maxNumberOfElements, boolean keepChildrenRolls) { return Optional.of(ImmutableList.of(new Roll(toExpression(), rollElements, - UniqueRandomElements.from(allRolls.build()), + RandomElementsBuilder.fromRolls(allRolls.build()), childrenRollBuilder.build(), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/SortAsc.java b/src/main/java/de/janno/evaluator/dice/function/SortAsc.java index f1ba082..5d03368 100644 --- a/src/main/java/de/janno/evaluator/dice/function/SortAsc.java +++ b/src/main/java/de/janno/evaluator/dice/function/SortAsc.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -18,26 +17,27 @@ public SortAsc(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); final ImmutableList res = rolls.stream() .flatMap(result -> result.getElements().stream()) .sorted() .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.copyOf(rolls), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/SortDesc.java b/src/main/java/de/janno/evaluator/dice/function/SortDesc.java index c720914..1a0961f 100644 --- a/src/main/java/de/janno/evaluator/dice/function/SortDesc.java +++ b/src/main/java/de/janno/evaluator/dice/function/SortDesc.java @@ -6,7 +6,6 @@ import java.util.Comparator; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -19,12 +18,12 @@ public SortDesc(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(arguments, variables); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(arguments, rollContext); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); final ImmutableList res = rolls.stream() .flatMap(result -> result.getElements().stream()) @@ -32,14 +31,15 @@ public SortDesc(int maxNumberOfElements, boolean keepChildrenRolls) { .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.copyOf(rolls), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/function/Value.java b/src/main/java/de/janno/evaluator/dice/function/Value.java index 33668bc..7491866 100644 --- a/src/main/java/de/janno/evaluator/dice/function/Value.java +++ b/src/main/java/de/janno/evaluator/dice/function/Value.java @@ -5,9 +5,7 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; -import java.util.concurrent.ConcurrentHashMap; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; @@ -17,33 +15,35 @@ public Value(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List arguments, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - if (arguments.size() < 2) { - throw new ExpressionException(String.format("'%s' requires as 2 inputs but was '%s'", getName(), arguments.size())); - } - Map variableNameMap = new ConcurrentHashMap<>(); //don't replace literals in the first argument of the function, but it can use new variables - Optional> valNameRoll = arguments.getFirst().extendRoll(variableNameMap); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + RollContext nameContext = rollContext.copyWithEmptyVariables(); //don't replace literals in the first argument of the function, but it can use new variables + Optional> valNameRoll = arguments.getFirst().extendRoll(nameContext); if (valNameRoll.isEmpty()) { - throw new ExpressionException(String.format("'%s' requires a non-empty input as first argument", inputValue)); + throw new ExpressionException(String.format("'%s' requires a non-empty input as first argument", expressionPosition.getValue()), expressionPosition); } ImmutableList.Builder rollBuilder = ImmutableList.builder() .addAll(valNameRoll.get()); - variables.putAll(variableNameMap); + rollContext.merge(nameContext); List remainingRollBuilder = arguments.subList(1, arguments.size()); - List rolls = rollBuilder.addAll(RollBuilder.extendAllBuilder(remainingRollBuilder, variables)).build(); + List remainingRolls = RollBuilder.extendAllBuilder(remainingRollBuilder, rollContext); - checkRollSize(inputValue, rolls, getMinArgumentCount(), getMaxArgumentCount()); + List rolls = rollBuilder.addAll(remainingRolls).build(); + checkRollSize(expressionPosition, rolls, getMinArgumentCount(), getMaxArgumentCount()); + if (rolls.getFirst().getElements().isEmpty()) { + throw new ExpressionException(String.format("'%s' requires a non-empty input as first argument", expressionPosition.getValue()), expressionPosition); + } String valName = rolls.getFirst().getElements().getFirst().getValue(); String expression = toExpression(); - variables.put(valName, new Roll(expression, + rollContext.putVariable(valName, new Roll(expression, rolls.get(1).getElements(), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), rolls.get(1).getChildrenRolls(), + expressionPosition, maxNumberOfElements, keepChildrenRolls)); return Optional.empty(); @@ -51,7 +51,7 @@ public Value(int maxNumberOfElements, boolean keepChildrenRolls) { @Override public @NonNull String toExpression() { - return getExpression(inputValue, arguments); + return getExpression(expressionPosition, arguments); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/AndBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/AndBool.java index 4e45320..872f201 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/AndBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/AndBool.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -20,31 +19,32 @@ public AndBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final boolean leftBoolValue = left.asBoolean().orElseThrow(() -> throwNotBoolean(inputValue, left, "left")); - final boolean rightBoolValue = right.asBoolean().orElseThrow(() -> throwNotBoolean(inputValue, right, "right")); + final boolean leftBoolValue = left.asBoolean().orElseThrow(() -> throwNotBoolean(expressionPosition, left, "left")); + final boolean rightBoolValue = right.asBoolean().orElseThrow(() -> throwNotBoolean(expressionPosition, right, "right")); ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf((leftBoolValue && rightBoolValue)), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/EqualBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/EqualBool.java index d28cfe9..d294b52 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/EqualBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/EqualBool.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -19,12 +18,12 @@ public EqualBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); @@ -33,14 +32,15 @@ public EqualBool(int maxNumberOfElements, boolean keepChildrenRolls) { ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf(isEqual), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterBool.java index 3553318..8e32387 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterBool.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -21,29 +20,30 @@ public GreaterBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "left")); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "left")); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf(leftNumber.compareTo(rightNumber) > 0), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterEqualBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterEqualBool.java index 36db212..91b0d07 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterEqualBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/GreaterEqualBool.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -21,29 +20,30 @@ public GreaterEqualBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, left, "left")); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, left, "left")); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf(leftNumber.compareTo(rightNumber) >= 0), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/InBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/InBool.java index 1a8c37b..63ddff3 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/InBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/InBool.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -19,12 +18,12 @@ public InBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); @@ -34,14 +33,15 @@ public InBool(int maxNumberOfElements, boolean keepChildrenRolls) { ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf(isTrue), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/LesserBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/LesserBool.java index 605287f..5459c83 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/LesserBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/LesserBool.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -21,29 +20,30 @@ public LesserBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "left")); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "left")); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf(leftNumber.compareTo(rightNumber) < 0), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/LesserEqualBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/LesserEqualBool.java index 710f40a..489947c 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/LesserEqualBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/LesserEqualBool.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -21,29 +20,30 @@ public LesserEqualBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "left")); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "left")); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf(leftNumber.compareTo(rightNumber) <= 0), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/NegateBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/NegateBool.java index 91903bf..f9511a5 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/NegateBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/NegateBool.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -20,28 +19,29 @@ public NegateBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 1); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 1); Roll value = rolls.getFirst(); - final boolean boolValue = value.asBoolean().orElseThrow(() -> throwNotBoolean(inputValue, value, "right")); + final boolean boolValue = value.asBoolean().orElseThrow(() -> throwNotBoolean(expressionPosition, value, "right")); ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf((!boolValue)), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(value), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getRightUnaryExpression(getName(), operands); + return getRightUnaryExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/bool/OrBool.java b/src/main/java/de/janno/evaluator/dice/operator/bool/OrBool.java index a799542..0cb0054 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/bool/OrBool.java +++ b/src/main/java/de/janno/evaluator/dice/operator/bool/OrBool.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -20,30 +19,31 @@ public OrBool(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final boolean leftBoolValue = left.asBoolean().orElseThrow(() -> throwNotBoolean(inputValue, left, "left")); - final boolean rightBoolValue = right.asBoolean().orElseThrow(() -> throwNotBoolean(inputValue, right, "right")); + final boolean leftBoolValue = left.asBoolean().orElseThrow(() -> throwNotBoolean(expressionPosition, left, "left")); + final boolean rightBoolValue = right.asBoolean().orElseThrow(() -> throwNotBoolean(expressionPosition, right, "right")); ImmutableList diceResult = ImmutableList.of(new RollElement(String.valueOf((leftBoolValue || rightBoolValue)), RollElement.NO_TAG, RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/die/Color.java b/src/main/java/de/janno/evaluator/dice/operator/die/Color.java index f698632..f1c8742 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/die/Color.java +++ b/src/main/java/de/janno/evaluator/dice/operator/die/Color.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -18,33 +17,34 @@ public Color(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkAllElementsAreSameTag(inputValue, left, right); - checkContainsSingleElement(inputValue, right, "second argument"); + checkAllElementsAreSameTag(expressionPosition, left, right); + checkContainsSingleElement(expressionPosition, right, "second argument"); String color = right.getElements().getFirst().getValue(); //colors are applied to the random elements, so they can be used for dice images - UniqueRandomElements.Builder builder = new UniqueRandomElements.Builder(); - rolls.forEach(r -> builder.addWithColor(r.getRandomElementsInRoll(), color)); + RandomElementsBuilder builder = RandomElementsBuilder.empty(); + rolls.forEach(r -> builder.addWithColor(r, color)); return Optional.of(ImmutableList.of(new Roll(toExpression(), left.getElements().stream() .map(r -> new RollElement(r.getValue(), r.getTag(), color)) .collect(ImmutableList.toImmutableList()), builder.build(), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingAddDice.java b/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingAddDice.java index 2b7a96e..3a87534 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingAddDice.java +++ b/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingAddDice.java @@ -5,11 +5,12 @@ import de.janno.evaluator.dice.random.NumberSupplier; import lombok.NonNull; +import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Optional; +import java.util.stream.Collectors; -import static de.janno.evaluator.dice.DiceHelper.*; +import static de.janno.evaluator.dice.DiceHelper.explodingDice; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; import static de.janno.evaluator.dice.ValidatorUtil.throwNotIntegerExpression; @@ -26,63 +27,77 @@ public ExplodingAddDice(NumberSupplier numberSupplier, int maxNumberOfDice, int } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { + return new RollBuilder() { + private static ImmutableList sumRerollsTogether(List randomElements) { + return randomElements.stream().collect(Collectors.groupingBy(r -> r.getDieId().getDieIndex())) + .values().stream() + .map(r -> new RollElement(r.stream() + .map(RandomElement::getRollElement) + .map(RollElement::asDecimal) + .flatMap(Optional::stream) + .reduce(BigDecimal.ZERO, BigDecimal::add) + .stripTrailingZeros().toPlainString() + , RollElement.NO_TAG, RollElement.NO_COLOR)) + .collect(ImmutableList.toImmutableList()); + } + @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 2); + + RandomElementsBuilder randomElements = RandomElementsBuilder.empty(); + final RollId rollId = RollId.of(expressionPosition, rollContext.getNextReEvaluationNumber(expressionPosition)); - UniqueRandomElements.Builder randomElements = UniqueRandomElements.builder(); + final int numberOfDice; + final int sidesOfDie; + final ImmutableList childrenRolls; if (rolls.size() == 1) { + numberOfDice = 1; final Roll right = rolls.getFirst(); - final int sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); - if (sidesOfDie < 2) { - throw new ExpressionException(String.format("The number of sides of a die must be greater then 1 but was %d", sidesOfDie)); - } - final ImmutableList explodingAddDice = explodingAddDice(1, sidesOfDie, numberSupplier); - final ImmutableList rollElements = explodedAddDie2RollElements(explodingAddDice); - randomElements.add(right.getRandomElementsInRoll()); - randomElements.addAsRandomElements(explodedAddDie2RandomElements(explodingAddDice)); - return Optional.of(ImmutableList.of(new Roll(toExpression(), - rollElements, - randomElements.build(), - ImmutableList.of(right), - maxNumberOfElements, keepChildrenRolls))); + randomElements.addRoll(right); + sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); + childrenRolls = ImmutableList.of(right); + } else { + final Roll left = rolls.getFirst(); + final Roll right = rolls.get(1); + randomElements.addRoll(left); + randomElements.addRoll(right); + numberOfDice = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, left, "left")); + sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); + childrenRolls = ImmutableList.of(left, right); } - final Roll left = rolls.getFirst(); - final Roll right = rolls.get(1); - randomElements.add(left.getRandomElementsInRoll()); - randomElements.add(right.getRandomElementsInRoll()); - final int numberOfDice = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, left, "left")); if (numberOfDice > maxNumberOfDice) { - throw new ExpressionException(String.format("The number of dice must be less or equal then %d but was %d", maxNumberOfDice, numberOfDice)); + throw new ExpressionException(String.format("The number of dice must be less or equal then %d but was %d", maxNumberOfDice, numberOfDice), expressionPosition); } if (numberOfDice < 0) { - throw new ExpressionException(String.format("The number of dice can not be negativ but was %d", numberOfDice)); + throw new ExpressionException(String.format("The number of dice can not be negativ but was %d", numberOfDice), expressionPosition); } - final int sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); if (sidesOfDie < 2) { - throw new ExpressionException(String.format("The number of sides of a die must be greater then 1 but was %d", sidesOfDie)); + throw new ExpressionException(String.format("The number of sides of a die must be greater then 1 but was %d", sidesOfDie), expressionPosition); } - final ImmutableList explodingAddDice = explodingAddDice(numberOfDice, sidesOfDie, numberSupplier); - final ImmutableList rollElements = explodedAddDie2RollElements(explodingAddDice); - randomElements.addAsRandomElements(explodedAddDie2RandomElements(explodingAddDice)); + final ImmutableList roll = explodingDice(numberOfDice, sidesOfDie, numberSupplier, rollId, maxNumberOfElements, toExpression()); + final ImmutableList rollElements = sumRerollsTogether(roll); return Optional.of(ImmutableList.of(new Roll(toExpression(), rollElements, - randomElements.build(), - ImmutableList.of(left, right), + randomElements + .addRandomElements(roll) + .build(), + childrenRolls, + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { if (operands.size() == 1) { - return getRightUnaryExpression(inputValue, operands); + return getRightUnaryExpression(expressionPosition, operands); } - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingDice.java b/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingDice.java index b594001..3b0c29c 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingDice.java +++ b/src/main/java/de/janno/evaluator/dice/operator/die/ExplodingDice.java @@ -6,11 +6,9 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.DiceHelper.explodingDice; -import static de.janno.evaluator.dice.DiceHelper.toRollElements; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; import static de.janno.evaluator.dice.ValidatorUtil.throwNotIntegerExpression; @@ -27,69 +25,66 @@ public ExplodingDice(NumberSupplier numberSupplier, int maxNumberOfDice, int max } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { + @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 2); - UniqueRandomElements.Builder randomElements = UniqueRandomElements.builder(); - if (rolls.size() == 1) { - final Roll right = rolls.getFirst(); - final int sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); - if (sidesOfDie < 2) { - throw new ExpressionException(String.format("The number of sides of a die must be greater then 1 but was %d", sidesOfDie)); - } - final ImmutableList rollElements = toRollElements(explodingDice(1, sidesOfDie, numberSupplier)); - randomElements.add(right.getRandomElementsInRoll()); + RandomElementsBuilder randomElements = RandomElementsBuilder.empty(); - randomElements.addAsRandomElements(rollElements.stream() - .map(r -> new RandomElement(r, 1, sidesOfDie)) - .collect(ImmutableList.toImmutableList())); + final RollId rollId = RollId.of(expressionPosition, rollContext.getNextReEvaluationNumber(expressionPosition)); - return Optional.of(ImmutableList.of(new Roll(toExpression(), - rollElements, - randomElements.build(), - ImmutableList.of(right), - maxNumberOfElements, keepChildrenRolls))); + final int numberOfDice; + final int sidesOfDie; + final ImmutableList childrenRolls; + if (rolls.size() == 1) { + numberOfDice = 1; + final Roll right = rolls.getFirst(); + sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); + childrenRolls = ImmutableList.of(right); + randomElements.addRoll(right); + } else { + final Roll left = rolls.getFirst(); + final Roll right = rolls.get(1); + randomElements.addRoll(left); + randomElements.addRoll(right); + numberOfDice = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, left, "left")); + sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); + childrenRolls = ImmutableList.of(left, right); } - final Roll left = rolls.getFirst(); - final Roll right = rolls.get(1); - randomElements.add(left.getRandomElementsInRoll()); - - randomElements.add(right.getRandomElementsInRoll()); - - final int numberOfDice = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, left, "left")); if (numberOfDice > maxNumberOfDice) { - throw new ExpressionException(String.format("The number of dice must be less or equal then %d but was %d", maxNumberOfDice, numberOfDice)); + throw new ExpressionException(String.format("The number of dice must be less or equal then %d but was %d", maxNumberOfDice, numberOfDice), expressionPosition); } if (numberOfDice < 0) { - throw new ExpressionException(String.format("The number of dice can not be negativ but was %d", numberOfDice)); + throw new ExpressionException(String.format("The number of dice can not be negativ but was %d", numberOfDice), expressionPosition); } - final int sidesOfDie = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); if (sidesOfDie < 2) { - throw new ExpressionException(String.format("The number of sides of a die must be greater then 1 but was %d", sidesOfDie)); + throw new ExpressionException(String.format("The number of sides of a die must be greater then 1 but was %d", sidesOfDie), expressionPosition); } - final ImmutableList rollElements = toRollElements(explodingDice(numberOfDice, sidesOfDie, numberSupplier)); - randomElements.addAsRandomElements(rollElements.stream() - .map(r -> new RandomElement(r, 1, sidesOfDie)) - .collect(ImmutableList.toImmutableList())); + final ImmutableList roll = explodingDice(numberOfDice, sidesOfDie, numberSupplier, rollId, maxNumberOfElements, toExpression()); + final ImmutableList rollElements = roll.stream().map(RandomElement::getRollElement).collect(ImmutableList.toImmutableList()); + return Optional.of(ImmutableList.of(new Roll(toExpression(), rollElements, - randomElements.build(), - ImmutableList.of(left, right), + randomElements + .addRandomElements(roll) + .build(), + childrenRolls, + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { if (operands.size() == 1) { - return getRightUnaryExpression(inputValue, operands); + return getRightUnaryExpression(expressionPosition, operands); } - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/die/RegularDice.java b/src/main/java/de/janno/evaluator/dice/operator/die/RegularDice.java index 97d0d94..2f10e2f 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/die/RegularDice.java +++ b/src/main/java/de/janno/evaluator/dice/operator/die/RegularDice.java @@ -6,10 +6,10 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; -import static de.janno.evaluator.dice.DiceHelper.*; +import static de.janno.evaluator.dice.DiceHelper.pickOneOf; +import static de.janno.evaluator.dice.DiceHelper.rollDice; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; import static de.janno.evaluator.dice.ValidatorUtil.throwNotIntegerExpression; @@ -26,20 +26,24 @@ public RegularDice(NumberSupplier numberSupplier, int maxNumberOfDice, int maxNu } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { + @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 2); final int numberOfDice; final Roll right; final ImmutableList childrenRolls; final String expression; - UniqueRandomElements.Builder randomElements = UniqueRandomElements.builder(); + final RollId rollId = RollId.of(expressionPosition, rollContext.getNextReEvaluationNumber(expressionPosition)); + + RandomElementsBuilder randomElements = RandomElementsBuilder.empty(); if (rolls.size() == 1) { right = rolls.getFirst(); + randomElements.addRoll(right); numberOfDice = 1; childrenRolls = ImmutableList.of(right); expression = toExpression(); @@ -47,46 +51,42 @@ public RegularDice(NumberSupplier numberSupplier, int maxNumberOfDice, int maxNu Roll left = rolls.getFirst(); right = rolls.get(1); childrenRolls = ImmutableList.of(left, right); - numberOfDice = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, left, "left")); + numberOfDice = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, left, "left")); expression = toExpression(); - randomElements.add(left.getRandomElementsInRoll()); + randomElements.addRoll(left); + randomElements.addRoll(right); } else { - throw new IllegalStateException("More then two operands for " + inputValue); + throw new IllegalStateException("More then two operands for " + expressionPosition.getValue()); } - randomElements.add(right.getRandomElementsInRoll()); if (numberOfDice > maxNumberOfDice) { - throw new ExpressionException(String.format("The number of dice must be less or equal then %d but was %d", maxNumberOfDice, numberOfDice)); + throw new ExpressionException(String.format("The number of dice must be less or equal then %d but was %d", maxNumberOfDice, numberOfDice), expressionPosition); } if (numberOfDice < 0) { - throw new ExpressionException(String.format("The number of dice can not be negativ but was %d", numberOfDice)); + throw new ExpressionException(String.format("The number of dice can not be negativ but was %d", numberOfDice), expressionPosition); } final ImmutableList rollElements; if (right.asInteger().isPresent()) { int sidesOfDie = right.asInteger().get(); - rollElements = toRollElements(rollDice(numberOfDice, sidesOfDie, numberSupplier)); - - randomElements.addAsRandomElements(rollElements.stream() - .map(r -> new RandomElement(r, 1, sidesOfDie)) - .collect(ImmutableList.toImmutableList())); + List roll = rollDice(numberOfDice, sidesOfDie, numberSupplier, rollId); + rollElements = roll.stream().map(RandomElement::getRollElement).collect(ImmutableList.toImmutableList()); + randomElements.addRandomElements(roll); } else { - ImmutableList.Builder builder = ImmutableList.builder(); + ImmutableList.Builder rollBuilder = ImmutableList.builder(); for (int i = 0; i < numberOfDice; i++) { - builder.add(pickOneOf(right.getElements(), numberSupplier)); + rollBuilder.add(pickOneOf(right.getElements(), numberSupplier, DieId.of(rollId, i, 0))); } - rollElements = builder.build(); - randomElements.addAsRandomElements(rollElements.stream() - .map(r -> new RandomElement(r, right.getElements().stream() - .map(RollElement::getValue) - .collect(ImmutableList.toImmutableList()))) - .collect(ImmutableList.toImmutableList())); + List roll = rollBuilder.build(); + rollElements = roll.stream().map(RandomElement::getRollElement).collect(ImmutableList.toImmutableList()); + randomElements.addRandomElements(roll); } return Optional.of(ImmutableList.of(new Roll(expression, rollElements, randomElements.build(), childrenRolls, + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @@ -94,9 +94,9 @@ public RegularDice(NumberSupplier numberSupplier, int maxNumberOfDice, int maxNu @Override public @NonNull String toExpression() { if (operands.size() == 1) { - return getRightUnaryExpression(inputValue, operands); + return getRightUnaryExpression(expressionPosition, operands); } - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/die/Reroll.java b/src/main/java/de/janno/evaluator/dice/operator/die/Reroll.java index 7197cf6..9854c7f 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/die/Reroll.java +++ b/src/main/java/de/janno/evaluator/dice/operator/die/Reroll.java @@ -6,7 +6,6 @@ import java.util.Collections; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; @@ -18,26 +17,25 @@ public Reroll(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { RollBuilder inputBuilder = operands.getFirst(); - List compareTos = operands.get(1).extendRoll(variables).orElse(Collections.emptyList()); - checkRollSize(inputValue, compareTos, 1, 1); + List compareTos = operands.get(1).extendRoll(rollContext).orElse(Collections.emptyList()); + checkRollSize(expressionPosition, compareTos, 1, 1); Roll compareTo = compareTos.getFirst(); - List rolls = inputBuilder.extendRoll(variables).orElse(Collections.emptyList()); - checkRollSize(inputValue, rolls, 1, 1); + List rolls = inputBuilder.extendRoll(rollContext).orElse(Collections.emptyList()); + checkRollSize(expressionPosition, rolls, 1, 1); Roll roll = rolls.getFirst(); - UniqueRandomElements.Builder builder = UniqueRandomElements.builder(); - builder.add(roll.getRandomElementsInRoll()); + RandomElementsBuilder builder = RandomElementsBuilder.ofRoll(roll).addRoll(compareTo); if (roll.getElements().stream().anyMatch(compareTo::isElementsContainsElementWithValueAndTag)) { - rolls = inputBuilder.extendRoll(variables).orElse(Collections.emptyList()); - checkRollSize(inputValue, rolls, 1, 1); + rolls = inputBuilder.extendRoll(rollContext).orElse(Collections.emptyList()); + checkRollSize(expressionPosition, rolls, 1, 1); roll = rolls.getFirst(); - builder.add(roll.getRandomElementsInRoll()); + builder.addRoll(roll); } return Optional.of(ImmutableList.of(new Roll(toExpression(), @@ -47,13 +45,14 @@ public Reroll(int maxNumberOfElements, boolean keepChildrenRolls) { .addAll(compareTo.getChildrenRolls()) .addAll(roll.getChildrenRolls()) .build(), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/die/Tag.java b/src/main/java/de/janno/evaluator/dice/operator/die/Tag.java index 290608d..d704ad8 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/die/Tag.java +++ b/src/main/java/de/janno/evaluator/dice/operator/die/Tag.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -18,18 +17,18 @@ public Tag(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkAllElementsAreSameTag(inputValue, left, right); - checkContainsSingleElement(inputValue, right, "second argument"); + checkAllElementsAreSameTag(expressionPosition, left, right); + checkContainsSingleElement(expressionPosition, right, "second argument"); String tag = right.getElements().getFirst().getValue(); return Optional.of(ImmutableList.of(new Roll(toExpression(), @@ -37,14 +36,15 @@ public Tag(int maxNumberOfElements, boolean keepChildrenRolls) { .map(r -> new RollElement(r.getValue(), tag, r.getColor())) .collect(ImmutableList.toImmutableList()), //tags are not applied to the random elements - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(getName(), operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/AddToList.java b/src/main/java/de/janno/evaluator/dice/operator/list/AddToList.java index 06025ec..5535542 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/AddToList.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/AddToList.java @@ -6,7 +6,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -18,18 +17,19 @@ public AddToList(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 2); if (rolls.size() == 1) { return Optional.of(ImmutableList.of(new Roll(toExpression(), rolls.getFirst().getElements(), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(rolls.getFirst()), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @@ -41,17 +41,18 @@ public AddToList(int maxNumberOfElements, boolean keepChildrenRolls) { .build(); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { if (operands.size() == 1) { - return getRightUnaryExpression(inputValue, operands); + return getRightUnaryExpression(expressionPosition, operands); } - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/Concat.java b/src/main/java/de/janno/evaluator/dice/operator/list/Concat.java index 51c9f34..f2bb552 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/Concat.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/Concat.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; @@ -18,25 +17,26 @@ public Concat(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); String joined = rolls.stream() .map(Roll::getResultString) .collect(Collectors.joining()); return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement(joined, RollElement.NO_TAG, RollElement.NO_COLOR)), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.copyOf(rolls), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/Count.java b/src/main/java/de/janno/evaluator/dice/operator/list/Count.java index 095f916..4997edf 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/Count.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/Count.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; @@ -20,12 +19,12 @@ public Count(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 1); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 1); Roll left = rolls.getFirst(); @@ -41,14 +40,15 @@ public Count(int maxNumberOfElements, boolean keepChildrenRolls) { } return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getLeftUnaryExpression(inputValue, operands); + return getLeftUnaryExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/EqualFilter.java b/src/main/java/de/janno/evaluator/dice/operator/list/EqualFilter.java index 55c0c36..aefb1e5 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/EqualFilter.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/EqualFilter.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -20,30 +19,31 @@ public EqualFilter(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkContainsSingleElement(inputValue, right, "right"); + checkContainsSingleElement(expressionPosition, right, "right"); ImmutableList diceResult = left.getElements().stream() .filter(re -> right.getElements().getFirst().isEqualValueAndTag(re)) .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/GreaterEqualThanFilter.java b/src/main/java/de/janno/evaluator/dice/operator/list/GreaterEqualThanFilter.java index 349b77c..03d9433 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/GreaterEqualThanFilter.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/GreaterEqualThanFilter.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.Optional; @@ -21,17 +20,17 @@ public GreaterEqualThanFilter(int maxNumberOfElements, boolean keepChildrenRolls } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkContainsOnlyDecimal(inputValue, left, "left"); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + checkContainsOnlyDecimal(expressionPosition, left, "left"); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); ImmutableList diceResult = left.getElements().stream() .filter(i -> i.asDecimal().isPresent() && i.asDecimal().get().compareTo(rightNumber) >= 0 //the filter is only applied to elements with the same tag @@ -39,14 +38,15 @@ public GreaterEqualThanFilter(int maxNumberOfElements, boolean keepChildrenRolls .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/GreaterThanFilter.java b/src/main/java/de/janno/evaluator/dice/operator/list/GreaterThanFilter.java index a852964..c7ad7d2 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/GreaterThanFilter.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/GreaterThanFilter.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.Optional; @@ -21,17 +20,17 @@ public GreaterThanFilter(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkContainsOnlyDecimal(inputValue, left, "left"); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + checkContainsOnlyDecimal(expressionPosition, left, "left"); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); ImmutableList diceResult = left.getElements().stream() .filter(i -> i.asDecimal().isPresent() && i.asDecimal().get().compareTo(rightNumber) > 0 //the filter is only applied to elements with the same tag @@ -39,14 +38,15 @@ public GreaterThanFilter(int maxNumberOfElements, boolean keepChildrenRolls) { .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/KeepHighest.java b/src/main/java/de/janno/evaluator/dice/operator/list/KeepHighest.java index e6cf0b4..ae6748f 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/KeepHighest.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/KeepHighest.java @@ -6,7 +6,6 @@ import java.util.Comparator; import java.util.List; -import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; @@ -22,18 +21,18 @@ public KeepHighest(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); + final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); if (rightNumber < 0) { - throw new ExpressionException(String.format("The number to keep can not be negativ but was %d", rightNumber)); + throw new ExpressionException(String.format("The number to keep can not be negativ but was %d", rightNumber), expressionPosition); } final String rightTag = right.getElements().getFirst().getTag(); ImmutableList otherTagElements = left.getElements().stream() @@ -53,14 +52,15 @@ public KeepHighest(int maxNumberOfElements, boolean keepChildrenRolls) { .addAll(keep) .addAll(otherTagElements) .build(), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/KeepLowest.java b/src/main/java/de/janno/evaluator/dice/operator/list/KeepLowest.java index 66046c2..3376ce4 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/KeepLowest.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/KeepLowest.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; @@ -21,18 +20,18 @@ public KeepLowest(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); + final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); if (rightNumber < 0) { - throw new ExpressionException(String.format("The number to keep can not be negativ but was %d", rightNumber)); + throw new ExpressionException(String.format("The number to keep can not be negativ but was %d", rightNumber), expressionPosition); } final String rightTag = right.getElements().getFirst().getTag(); ImmutableList otherTagElements = left.getElements().stream() @@ -52,13 +51,15 @@ public KeepLowest(int maxNumberOfElements, boolean keepChildrenRolls) { .addAll(keep) .addAll(otherTagElements) .build(), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), - maxNumberOfElements, keepChildrenRolls))); } + expressionPosition, + maxNumberOfElements, keepChildrenRolls))); + } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/LesserEqualThanFilter.java b/src/main/java/de/janno/evaluator/dice/operator/list/LesserEqualThanFilter.java index 496f22d..6d849c5 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/LesserEqualThanFilter.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/LesserEqualThanFilter.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.Optional; @@ -21,17 +20,17 @@ public LesserEqualThanFilter(int maxNumberOfElements, boolean keepChildrenRolls) } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkContainsOnlyDecimal(inputValue, left, "left"); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + checkContainsOnlyDecimal(expressionPosition, left, "left"); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); ImmutableList diceResult = left.getElements().stream() .filter(i -> i.asDecimal().isPresent() && i.asDecimal().get().compareTo(rightNumber) <= 0 //the filter is only applied to elements with the same tag @@ -39,14 +38,15 @@ public LesserEqualThanFilter(int maxNumberOfElements, boolean keepChildrenRolls) .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/LesserThanFilter.java b/src/main/java/de/janno/evaluator/dice/operator/list/LesserThanFilter.java index 8bcac71..94e6ced 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/LesserThanFilter.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/LesserThanFilter.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.Optional; @@ -21,17 +20,17 @@ public LesserThanFilter(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkContainsOnlyDecimal(inputValue, left, "left"); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + checkContainsOnlyDecimal(expressionPosition, left, "left"); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); //todo only filtered by same tag? ImmutableList diceResult = left.getElements().stream() .filter(i -> i.asDecimal().isPresent() && i.asDecimal().get().compareTo(rightNumber) < 0 @@ -40,14 +39,15 @@ public LesserThanFilter(int maxNumberOfElements, boolean keepChildrenRolls) { .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), diceResult, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/Repeat.java b/src/main/java/de/janno/evaluator/dice/operator/list/Repeat.java index 05defc4..4ca4a1e 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/Repeat.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/Repeat.java @@ -1,15 +1,11 @@ package de.janno.evaluator.dice.operator.list; import com.google.common.collect.ImmutableList; -import de.janno.evaluator.dice.ExpressionException; -import de.janno.evaluator.dice.Operator; -import de.janno.evaluator.dice.Roll; -import de.janno.evaluator.dice.RollBuilder; +import de.janno.evaluator.dice.*; import lombok.NonNull; import java.util.Collections; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; @@ -23,30 +19,29 @@ public Repeat(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List leftRolls = operands.getFirst().extendRoll(variables).orElse(Collections.emptyList()); - checkRollSize(inputValue, leftRolls, 1, 1); - int left = leftRolls.getFirst().asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, leftRolls.getFirst(), "left")); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List leftRolls = operands.getFirst().extendRoll(rollContext).orElse(Collections.emptyList()); + checkRollSize(expressionPosition, leftRolls, 1, 1); + int left = leftRolls.getFirst().asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, leftRolls.getFirst(), "left")); if (left > 10 || left < 1) { - throw new ExpressionException(String.format("The number of repeat must between 1-10 but was %d", left)); + throw new ExpressionException(String.format("The number of repeat must between 1-10 but was %d", left), expressionPosition); } RollBuilder right = operands.get(1); ImmutableList.Builder builder = ImmutableList.builder(); for (int i = 0; i < left; i++) { - List rightRoll = right.extendRoll(variables).orElse(Collections.emptyList()); - checkRollSize(inputValue, rightRoll, 1, 1); + List rightRoll = right.extendRoll(rollContext).orElse(Collections.emptyList()); + checkRollSize(expressionPosition, rightRoll, 1, 1); builder.addAll(rightRoll); } - //todo correct? why no new roll return Optional.of(builder.build()); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/RepeatList.java b/src/main/java/de/janno/evaluator/dice/operator/list/RepeatList.java index 116da2d..f4da2d4 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/RepeatList.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/RepeatList.java @@ -6,7 +6,6 @@ import java.util.Collections; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.ValidatorUtil.checkRollSize; @@ -20,15 +19,15 @@ public RepeatList(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List leftRolls = operands.getFirst().extendRoll(variables).orElse(Collections.emptyList()); - checkRollSize(inputValue, leftRolls, 1, 1); - int left = leftRolls.getFirst().asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, leftRolls.getFirst(), "left")); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List leftRolls = operands.getFirst().extendRoll(rollContext).orElse(Collections.emptyList()); + checkRollSize(expressionPosition, leftRolls, 1, 1); + int left = leftRolls.getFirst().asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, leftRolls.getFirst(), "left")); if (left > 20 || left < 0) { - throw new ExpressionException(String.format("The number of list repeat must between 0-20 but was %d", left)); + throw new ExpressionException(String.format("The number of list repeat must between 0-20 but was %d", left), expressionPosition); } if (left == 0) { return Optional.empty(); @@ -39,8 +38,8 @@ public RepeatList(int maxNumberOfElements, boolean keepChildrenRolls) { ImmutableList.Builder builder = ImmutableList.builder(); for (int i = 0; i < left; i++) { - List rightRoll = right.extendRoll(variables).orElse(Collections.emptyList()); - checkRollSize(inputValue, rightRoll, 1, 1); + List rightRoll = right.extendRoll(rollContext).orElse(Collections.emptyList()); + checkRollSize(expressionPosition, rightRoll, 1, 1); builder.addAll(rightRoll); } ImmutableList rolls = builder.build(); @@ -48,14 +47,15 @@ public RepeatList(int maxNumberOfElements, boolean keepChildrenRolls) { return Optional.of(ImmutableList.of(new Roll(toExpression(), rolls.stream().flatMap(r -> r.getElements().stream()).collect(ImmutableList.toImmutableList()), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), rolls, + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/list/Sum.java b/src/main/java/de/janno/evaluator/dice/operator/list/Sum.java index 80b0712..9db8aff 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/list/Sum.java +++ b/src/main/java/de/janno/evaluator/dice/operator/list/Sum.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; @@ -29,15 +28,15 @@ private static BigDecimal sumExact(List elements) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 1); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 1); Roll left = rolls.getFirst(); - checkContainsOnlyDecimal(inputValue, left, "left"); + checkContainsOnlyDecimal(expressionPosition, left, "left"); final ImmutableList res; @@ -52,14 +51,15 @@ private static BigDecimal sumExact(List elements) { return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getLeftUnaryExpression(inputValue, operands); + return getLeftUnaryExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/math/DecimalDivide.java b/src/main/java/de/janno/evaluator/dice/operator/math/DecimalDivide.java index 329a7a0..a78753e 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/math/DecimalDivide.java +++ b/src/main/java/de/janno/evaluator/dice/operator/math/DecimalDivide.java @@ -7,7 +7,6 @@ import java.math.BigDecimal; import java.math.RoundingMode; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -21,30 +20,36 @@ public DecimalDivide(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkAllElementsAreSameTag(inputValue, left, right); - final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, left, "left")); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); - - final ImmutableList res = ImmutableList.of(new RollElement(leftNumber.divide(rightNumber, 5, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString(), left.getElements().getFirst().getTag(), RollElement.NO_COLOR)); + checkAllElementsAreSameTag(expressionPosition, left, right); + final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, left, "left")); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); + final String quotient; + try { + quotient = leftNumber.divide(rightNumber, 5, RoundingMode.HALF_UP).stripTrailingZeros().toPlainString(); + } catch (ArithmeticException e) { + throw new ExpressionException(e.getMessage(), expressionPosition); + } + final ImmutableList res = ImmutableList.of(new RollElement(quotient, left.getElements().getFirst().getTag(), RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/math/IntegerDivide.java b/src/main/java/de/janno/evaluator/dice/operator/math/IntegerDivide.java index 5e688cc..69c57ae 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/math/IntegerDivide.java +++ b/src/main/java/de/janno/evaluator/dice/operator/math/IntegerDivide.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -19,29 +18,36 @@ public IntegerDivide(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2,2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkAllElementsAreSameTag(inputValue, left, right); - final int leftNumber = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, left, "left")); - final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); - - final ImmutableList res = ImmutableList.of(new RollElement(String.valueOf(Math.divideExact(leftNumber, rightNumber)), left.getElements().getFirst().getTag(), RollElement.NO_COLOR)); + checkAllElementsAreSameTag(expressionPosition, left, right); + final int leftNumber = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, left, "left")); + final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); + final int quotient; + try { + quotient = Math.divideExact(leftNumber, rightNumber); + } catch (ArithmeticException e) { + throw new ExpressionException(e.getMessage(), expressionPosition); + } + final ImmutableList res = ImmutableList.of(new RollElement(String.valueOf(quotient), left.getElements().getFirst().getTag(), RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), - maxNumberOfElements, keepChildrenRolls))); } + expressionPosition, + maxNumberOfElements, keepChildrenRolls))); + } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/math/Modulo.java b/src/main/java/de/janno/evaluator/dice/operator/math/Modulo.java index 42fd223..8886b2a 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/math/Modulo.java +++ b/src/main/java/de/janno/evaluator/dice/operator/math/Modulo.java @@ -5,7 +5,6 @@ import lombok.NonNull; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -19,29 +18,36 @@ public Modulo(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkAllElementsAreSameTag(inputValue, left, right); - final int leftNumber = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, left, "left")); - final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(inputValue, right, "right")); - - final ImmutableList res = ImmutableList.of(new RollElement(String.valueOf(leftNumber % rightNumber), left.getElements().getFirst().getTag(), RollElement.NO_COLOR)); + checkAllElementsAreSameTag(expressionPosition, left, right); + final int leftNumber = left.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, left, "left")); + final int rightNumber = right.asInteger().orElseThrow(() -> throwNotIntegerExpression(expressionPosition, right, "right")); + final int calculationResult; + try { + calculationResult = leftNumber % rightNumber; + } catch (ArithmeticException e) { + throw new ExpressionException(e.getMessage(), expressionPosition); + } + final ImmutableList res = ImmutableList.of(new RollElement(String.valueOf(calculationResult), left.getElements().getFirst().getTag(), RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), - maxNumberOfElements, keepChildrenRolls))); } + expressionPosition, + maxNumberOfElements, keepChildrenRolls))); + } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/math/Multiply.java b/src/main/java/de/janno/evaluator/dice/operator/math/Multiply.java index 3fe8785..b37883f 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/math/Multiply.java +++ b/src/main/java/de/janno/evaluator/dice/operator/math/Multiply.java @@ -6,7 +6,6 @@ import java.math.BigDecimal; import java.util.List; -import java.util.Map; import java.util.Optional; import static de.janno.evaluator.dice.RollBuilder.extendAllBuilder; @@ -19,30 +18,31 @@ public Multiply(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 2, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 2, 2); Roll left = rolls.getFirst(); Roll right = rolls.get(1); - checkAllElementsAreSameTag(inputValue, left, right); - final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, left, "left")); - final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(inputValue, right, "right")); + checkAllElementsAreSameTag(expressionPosition, left, right); + final BigDecimal leftNumber = left.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, left, "left")); + final BigDecimal rightNumber = right.asDecimal().orElseThrow(() -> throwNotDecimalExpression(expressionPosition, right, "right")); final ImmutableList res = ImmutableList.of(new RollElement(leftNumber.multiply(rightNumber).stripTrailingZeros().toPlainString(), left.getElements().getFirst().getTag(), RollElement.NO_COLOR)); return Optional.of(ImmutableList.of(new Roll(toExpression(), res, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/operator/math/NegateAddRemove.java b/src/main/java/de/janno/evaluator/dice/operator/math/NegateAddRemove.java index f0abca9..431a854 100644 --- a/src/main/java/de/janno/evaluator/dice/operator/math/NegateAddRemove.java +++ b/src/main/java/de/janno/evaluator/dice/operator/math/NegateAddRemove.java @@ -20,23 +20,24 @@ public NegateAddRemove(int maxNumberOfElements, boolean keepChildrenRolls) { } @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) throws ExpressionException { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) throws ExpressionException { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - List rolls = extendAllBuilder(operands, variables); - checkRollSize(inputValue, rolls, 1, 2); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + List rolls = extendAllBuilder(operands, rollContext); + checkRollSize(expressionPosition, rolls, 1, 2); if (rolls.size() == 1) { Roll right = rolls.getFirst(); - checkContainsOnlyDecimal(inputValue, right, "right"); + checkContainsOnlyDecimal(expressionPosition, right, "right"); ImmutableList negated = right.getElements().stream() .map(e -> new RollElement(e.asDecimal().orElseThrow().multiply(MINUS_ONE).stripTrailingZeros().toPlainString(), e.getTag(), e.getColor())) .collect(ImmutableList.toImmutableList()); return Optional.of(ImmutableList.of(new Roll(toExpression(), negated, - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @@ -60,9 +61,9 @@ public NegateAddRemove(int maxNumberOfElements, boolean keepChildrenRolls) { if (toRemove.stream().anyMatch(r -> r.asDecimal().isEmpty())) { throw new ExpressionException(String.format("'%s' requires as right input only decimals or elements that are on the left side '%s' but was '%s'", - inputValue, + expressionPosition.getValue(), left.getElements().stream().map(RollElement::getValue).toList(), - right.getElements().stream().map(RollElement::getValue).toList())); + right.getElements().stream().map(RollElement::getValue).toList()), expressionPosition); } resultBuilder.addAll(toRemove.stream() @@ -71,18 +72,19 @@ public NegateAddRemove(int maxNumberOfElements, boolean keepChildrenRolls) { return Optional.of(ImmutableList.of(new Roll(toExpression(), resultBuilder.build(), - UniqueRandomElements.from(rolls), + RandomElementsBuilder.fromRolls(rolls), ImmutableList.of(left, right), + expressionPosition, maxNumberOfElements, keepChildrenRolls))); } @Override public @NonNull String toExpression() { if (operands.size() == 1) { - return getRightUnaryExpression(inputValue, operands); + return getRightUnaryExpression(expressionPosition, operands); } - return getBinaryOperatorExpression(inputValue, operands); + return getBinaryOperatorExpression(expressionPosition, operands); } }; } diff --git a/src/main/java/de/janno/evaluator/dice/random/GivenDiceNumberSupplier.java b/src/main/java/de/janno/evaluator/dice/random/GivenDiceNumberSupplier.java new file mode 100644 index 0000000..1ed5a1c --- /dev/null +++ b/src/main/java/de/janno/evaluator/dice/random/GivenDiceNumberSupplier.java @@ -0,0 +1,38 @@ +package de.janno.evaluator.dice.random; + +import com.google.common.annotations.VisibleForTesting; +import de.janno.evaluator.dice.DieId; +import de.janno.evaluator.dice.ExpressionException; +import lombok.NonNull; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +public class GivenDiceNumberSupplier implements NumberSupplier { + private final NumberSupplier numberSupplier; + private final Map givenDiceNumbers; + + public GivenDiceNumberSupplier(@NonNull Map givenDiceNumbers) { + numberSupplier = new RandomNumberSupplier(); + this.givenDiceNumbers = new ConcurrentHashMap<>(givenDiceNumbers); + } + + @VisibleForTesting + public GivenDiceNumberSupplier(@NonNull NumberSupplier numberSupplier, @NonNull Map givenDiceNumbers) { + this.numberSupplier = numberSupplier; + this.givenDiceNumbers = new ConcurrentHashMap<>(givenDiceNumbers); + } + + @Override + public int get(int minExcl, int maxIncl, @NonNull DieId dieId) throws ExpressionException { + if (givenDiceNumbers.containsKey(dieId)) { + return givenDiceNumbers.remove(dieId); + } + + return numberSupplier.get(minExcl, maxIncl, dieId); + } + + public boolean allStoredDiceUsed() { + return givenDiceNumbers.isEmpty(); + } +} diff --git a/src/main/java/de/janno/evaluator/dice/random/GivenNumberSupplier.java b/src/main/java/de/janno/evaluator/dice/random/GivenNumberSupplier.java index b2e80f7..6bab678 100644 --- a/src/main/java/de/janno/evaluator/dice/random/GivenNumberSupplier.java +++ b/src/main/java/de/janno/evaluator/dice/random/GivenNumberSupplier.java @@ -1,6 +1,8 @@ package de.janno.evaluator.dice.random; import com.google.common.annotations.VisibleForTesting; +import de.janno.evaluator.dice.DieId; +import lombok.NonNull; import java.util.*; @@ -26,7 +28,7 @@ public GivenNumberSupplier(Collection results) { } @Override - public int get(int minExcl, int maxIncl) { + public int get(int minExcl, int maxIncl, @NonNull DieId dieId) { if (results.isEmpty()) { return maxIncl; } diff --git a/src/main/java/de/janno/evaluator/dice/random/NumberSupplier.java b/src/main/java/de/janno/evaluator/dice/random/NumberSupplier.java index 1da2ef8..e8e17b1 100644 --- a/src/main/java/de/janno/evaluator/dice/random/NumberSupplier.java +++ b/src/main/java/de/janno/evaluator/dice/random/NumberSupplier.java @@ -1,6 +1,8 @@ package de.janno.evaluator.dice.random; +import de.janno.evaluator.dice.DieId; import de.janno.evaluator.dice.ExpressionException; +import lombok.NonNull; /** * Provides a number between minExcl and maxIncl. @@ -13,7 +15,8 @@ public interface NumberSupplier { * * @param minExcl the minimum value (exclusive) * @param maxIncl the maximum value (inclusive) + * @param dieId the id of the die in the expression that is rolled * @return a number between minExcl and maxIncl */ - int get(int minExcl, int maxIncl) throws ExpressionException; + int get(int minExcl, int maxIncl, @NonNull DieId dieId) throws ExpressionException; } diff --git a/src/main/java/de/janno/evaluator/dice/random/RandomNumberSupplier.java b/src/main/java/de/janno/evaluator/dice/random/RandomNumberSupplier.java index f7f91f8..2ccfb07 100644 --- a/src/main/java/de/janno/evaluator/dice/random/RandomNumberSupplier.java +++ b/src/main/java/de/janno/evaluator/dice/random/RandomNumberSupplier.java @@ -1,7 +1,9 @@ package de.janno.evaluator.dice.random; import com.google.common.annotations.VisibleForTesting; +import de.janno.evaluator.dice.DieId; import de.janno.evaluator.dice.ExpressionException; +import lombok.NonNull; import java.util.random.RandomGenerator; @@ -20,15 +22,15 @@ public RandomNumberSupplier(long seed) { randomSource = new Sfc64Random(seed); } - public int get(int minExcl, int maxIncl) throws ExpressionException { + public int get(int minExcl, int maxIncl, @NonNull DieId dieId) throws ExpressionException { if (minExcl == Integer.MAX_VALUE) { - throw new ExpressionException("Cannot give a random number for minExcl =%d".formatted(Integer.MAX_VALUE)); + throw new ExpressionException("Cannot give a random number for minExcl =%d".formatted(Integer.MAX_VALUE), dieId.getRollId().getExpressionPosition()); } if (maxIncl == Integer.MAX_VALUE) { - throw new ExpressionException("Cannot give a random number for maxIncl =%d".formatted(Integer.MAX_VALUE)); + throw new ExpressionException("Cannot give a random number for maxIncl =%d".formatted(Integer.MAX_VALUE), dieId.getRollId().getExpressionPosition()); } if (minExcl >= maxIncl) { - throw new ExpressionException("Random number between %d (excl) and %d (incl) is not possible".formatted(minExcl, maxIncl)); + throw new ExpressionException("Random number between %d (excl) and %d (incl) is not possible".formatted(minExcl, maxIncl), dieId.getRollId().getExpressionPosition()); } if (minExcl + 1 == maxIncl) { return maxIncl; diff --git a/src/test/java/de/janno/evaluator/dice/DiceEvaluatorTest.java b/src/test/java/de/janno/evaluator/dice/DiceEvaluatorTest.java index b9b675f..09d367e 100644 --- a/src/test/java/de/janno/evaluator/dice/DiceEvaluatorTest.java +++ b/src/test/java/de/janno/evaluator/dice/DiceEvaluatorTest.java @@ -1,14 +1,18 @@ package de.janno.evaluator.dice; +import com.google.common.collect.ImmutableMap; +import de.janno.evaluator.dice.random.GivenDiceNumberSupplier; import de.janno.evaluator.dice.random.GivenNumberSupplier; import de.janno.evaluator.dice.random.RandomNumberSupplier; +import org.assertj.core.api.SoftAssertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import java.util.AbstractCollection; +import java.util.Collection; import java.util.List; +import java.util.Objects; import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; @@ -526,6 +530,7 @@ private static Stream generateErrorData() { Arguments.of("min3(45)", "A function, in this case 'min', must be followed a open function bracket: ("), Arguments.of(")", "expression can't start with a close bracket"), Arguments.of("(", "Parentheses mismatched"), + Arguments.of("1)", "Parentheses mismatched"), Arguments.of(",3", "expression can't start with a separator"), Arguments.of("10*", "Operator * does not support unary operations"), Arguments.of("10*a", "No matching operator for 'a', non-functional text and value names must to be surrounded by '' or []"), @@ -553,6 +558,8 @@ private static Stream generateErrorData() { Arguments.of("(-6)d!2", "The number of dice can not be negativ but was -6"), Arguments.of("(-6)d!!2", "The number of dice can not be negativ but was -6"), Arguments.of("d'-1'", "Sides of dice to roll must be positive"), + Arguments.of("d!'-1'", "The number of sides of a die must be greater then 1 but was -1"), + Arguments.of("d!!'-1'", "The number of sides of a die must be greater then 1 but was -1"), Arguments.of("5 mod 0", "/ by zero"), Arguments.of("11x(1d6)", "The number of repeat must between 1-10 but was 11"), Arguments.of("0x(1d6)", "The number of repeat must between 1-10 but was 0"), @@ -566,8 +573,8 @@ private static Stream generateErrorData() { Arguments.of("1000d9999999999", "The number '9999999999' is too big"), Arguments.of("9.9999999999", "The number '9.9999999999' is too big"), Arguments.of("(3x2d6)=", "'=' requires as 1 inputs but was '[[2, 3], [1, 4], [1, 1]]'"), - Arguments.of("1&&'ab'", "'&&' requires as left input a single boolean but was '[1]'"), - Arguments.of("1||'ab'", "'||' requires as left input a single boolean but was '[1]'"), + Arguments.of("3&&'ab'", "'&&' requires as left input a single boolean but was '[3]'"), + Arguments.of("3||'ab'", "'||' requires as left input a single boolean but was '[3]'"), Arguments.of("1 generateErrorData() { Arguments.of("1d+6", "Not enough values, d needs 2"), Arguments.of("concat('test' 'test')", "All brackets need to be closed be for starting a new expression or missing ','"), Arguments.of("exp(1d6)", "'exp' requires 2 or 3 arguments but was 1"), - Arguments.of("exp(1d6, if('false', 1d6), 3)", "'exp' requires a non-empty input as second argument"), + Arguments.of("exp(1d6, val('a', 1), 3)", "'exp' requires a non-empty input as second argument"), Arguments.of("exp(1d6, 3, -1)", "'exp' requires as third argument a number between 0 and 100"), - Arguments.of("exp(1d6, 3, if('false', 1d6))", "'exp' requires a non-empty input as third argument"), + Arguments.of("exp(1d6, 3, val('a', 1))", "'exp' requires a non-empty input as third argument"), Arguments.of("exp(1d6, 3, 101)", "'exp' requires as third argument a number between 0 and 100"), Arguments.of("1 - [a]", "'-' requires as right input only decimals or elements that are on the left side '[1]' but was '[a]'"), Arguments.of("1 - [3/a]", "'-' requires as right input only decimals or elements that are on the left side '[1]' but was '[3, a]'"), + Arguments.of("val('a')", "'val' requires as 2 inputs but was '[[a]]'"), + Arguments.of("val('',d6)", "'val' requires a non-empty input as first argument"), Arguments.of("d", "Operator d has right associativity but the right value was: empty") @@ -634,30 +643,278 @@ private static Stream generateHasOperatorOrFunction() { ); } + private static Stream generateStringDiceDataWithRandomElements() { + return Stream.of( + //if + Arguments.of("if(d6>?3,d8)", List.of(4), "8", "[3de0i0r0=4∈[1...6], 9de0i0r0=8∈[1...8]]"), + Arguments.of("if(d6>?3,d8)", List.of(2), "", "[3de0i0r0=2∈[1...6]]"), + Arguments.of("if(d6>?3,d4,d8)", List.of(4), "4", "[3de0i0r0=4∈[1...6], 9de0i0r0=4∈[1...4]]"), + Arguments.of("if(d6>?3,d4,d8)", List.of(2), "8", "[3de0i0r0=2∈[1...6], 12de0i0r0=8∈[1...8]]"), + Arguments.of("if(d6>?3,d4,d12>?3,d8)", List.of(4), "4", "[3de0i0r0=4∈[1...6], 9de0i0r0=4∈[1...4]]"), + Arguments.of("if(d6>?3,d4,d12?3,d4,d12>?3,d8)", List.of(2), "8", "[3de0i0r0=2∈[1...6], 12de0i0r0=12∈[1...12], 19de0i0r0=8∈[1...8]]"), + Arguments.of("if(d6>?3,d4,d12?3,'$a' + 3, '$a' -1)", List.of(3), "3, -1", "[10de0i0r0=3∈[1...6]]"), + Arguments.of("val('$a',1d6),if('$a'>?3,'$a' + 3, '$a' -1)", List.of(4), "4, 3", "[10de0i0r0=4∈[1...6]]"), + + //exp + Arguments.of("exp(d6,d6,d6)", List.of(2, 2, 2), "2, 6", "[4de0i0r0=2∈[1...6], 4de1i0r0=6∈[1...6], 7de0i0r0=2∈[1...6], 10de0i0r0=2∈[1...6]]"), + Arguments.of("exp(2d4,d4,d4)", List.of(), "4, 4, 4, 4, 4, 4, 4, 4, 4, 4", "[5de0i0r0=4∈[1...4], 5de0i1r0=4∈[1...4], 5de1i0r0=4∈[1...4], 5de1i1r0=4∈[1...4], 5de2i0r0=4∈[1...4], 5de2i1r0=4∈[1...4], 5de3i0r0=4∈[1...4], 5de3i1r0=4∈[1...4], 5de4i0r0=4∈[1...4], 5de4i1r0=4∈[1...4], 8de0i0r0=4∈[1...4], 11de0i0r0=4∈[1...4]]"), + Arguments.of("exp(d6,d6)", List.of(2, 2), "2, 6", "[4de0i0r0=2∈[1...6], 4de1i0r0=6∈[1...6], 7de0i0r0=2∈[1...6]]"), + + //bool + Arguments.of("d[0,1]&&d[0,1]", List.of(), "true", "[0de0i0r0=1∈[0, 1], 8de0i0r0=1∈[0, 1]]"), + Arguments.of("d6=?6", List.of(), "true", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6=?1", List.of(), "false", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6>?6", List.of(), "false", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6>?1", List.of(), "true", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6>=?7", List.of(), "false", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6>=?6", List.of(), "true", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6>=?1", List.of(), "true", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6 in d6", List.of(6, 1), "false", "[0de0i0r0=6∈[1...6], 6de0i0r0=1∈[1...6]]"), + Arguments.of("d6 in 6", List.of(), "true", "[0de0i0r0=6∈[1...6]]"), + Arguments.of("d6= d6", List.of(3, 6), "", "[0de0i0r0=3∈[1...6], 6de0i0r0=6∈[1...6]]"), + Arguments.of("d6 >= d6", List.of(6, 6), "6", "[0de0i0r0=6∈[1...6], 6de0i0r0=6∈[1...6]]"), + Arguments.of("d6 >= d6", List.of(6, 5), "6", "[0de0i0r0=6∈[1...6], 6de0i0r0=5∈[1...6]]"), + Arguments.of("d6 > d6", List.of(3, 6), "", "[0de0i0r0=3∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 > d6", List.of(6, 6), "", "[0de0i0r0=6∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 > d6", List.of(6, 5), "6", "[0de0i0r0=6∈[1...6], 5de0i0r0=5∈[1...6]]"), + Arguments.of("d6 <= d6", List.of(3, 6), "3", "[0de0i0r0=3∈[1...6], 6de0i0r0=6∈[1...6]]"), + Arguments.of("d6 <= d6", List.of(6, 6), "6", "[0de0i0r0=6∈[1...6], 6de0i0r0=6∈[1...6]]"), + Arguments.of("d6 <= d6", List.of(6, 5), "", "[0de0i0r0=6∈[1...6], 6de0i0r0=5∈[1...6]]"), + Arguments.of("d6 < d6", List.of(3, 6), "3", "[0de0i0r0=3∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 < d6", List.of(6, 6), "", "[0de0i0r0=6∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 < d6", List.of(6, 5), "", "[0de0i0r0=6∈[1...6], 5de0i0r0=5∈[1...6]]"), + Arguments.of("d6 k d6", List.of(), "6", "[0de0i0r0=6∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 l d6", List.of(), "6", "[0de0i0r0=6∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 x d6", List.of(3), "6, 6, 6", "[5de0i0r0=6∈[1...6]], [5de1i0r0=6∈[1...6]], [5de2i0r0=6∈[1...6]]"), + Arguments.of("d6 r d6", List.of(3), "6, 6, 6", "[5de0i0r0=6∈[1...6], 5de1i0r0=6∈[1...6], 5de2i0r0=6∈[1...6]]"), + + //math + Arguments.of("3d6=", List.of(), "18", "[1de0i0r0=6∈[1...6], 1de0i1r0=6∈[1...6], 1de0i2r0=6∈[1...6]]"), + Arguments.of("d6 / d6", List.of(), "1", "[0de0i0r0=6∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 // d6", List.of(), "1", "[0de0i0r0=6∈[1...6], 6de0i0r0=6∈[1...6]]"), + Arguments.of("d6 mod d6", List.of(), "0", "[0de0i0r0=6∈[1...6], 7de0i0r0=6∈[1...6]]"), + Arguments.of("d6 * d6", List.of(), "36", "[0de0i0r0=6∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 - d6", List.of(), "", "[0de0i0r0=6∈[1...6], 5de0i0r0=6∈[1...6]]"), + Arguments.of("d6 - d6", List.of(5), "5, -6", "[0de0i0r0=5∈[1...6], 5de0i0r0=6∈[1...6]]"), + + //function + Arguments.of("cancel(3d6, d6, d4)", List.of(4, 5, 6), "5", "[8de0i0r0=4∈[1...6], 8de0i1r0=5∈[1...6], 8de0i2r0=6∈[1...6], 12de0i0r0=6∈[1...6], 16de0i0r0=4∈[1...4]]"), + Arguments.of("concat(d6, d4)", List.of(), "64", "[7de0i0r0=6∈[1...6], 11de0i0r0=4∈[1...4]]"), + Arguments.of("exp(d6, d6)", List.of(6, 6, 6, 5), "6, 6, 5", "[4de0i0r0=6∈[1...6], 4de1i0r0=6∈[1...6], 4de2i0r0=5∈[1...6], 8de0i0r0=6∈[1...6]]"), + Arguments.of("exp(d6, d6, d6)", List.of(6, 6, 6, 6, 5), "6, 6, 5", "[4de0i0r0=6∈[1...6], 4de1i0r0=6∈[1...6], 4de2i0r0=5∈[1...6], 8de0i0r0=6∈[1...6], 12de0i0r0=6∈[1...6]]"), + Arguments.of("groupC(3d6)", List.of(), "3x6", "[8de0i0r0=6∈[1...6], 8de0i1r0=6∈[1...6], 8de0i2r0=6∈[1...6]]"), + Arguments.of("if(d6=?6,d4)", List.of(), "4", "[3de0i0r0=6∈[1...6], 9de0i0r0=4∈[1...4]]"), + Arguments.of("if(d6=?6,d4,d10)", List.of(), "4", "[3de0i0r0=6∈[1...6], 9de0i0r0=4∈[1...4]]"), + Arguments.of("if(d6=?5,d4,d10)", List.of(), "10", "[3de0i0r0=6∈[1...6], 12de0i0r0=10∈[1...10]]"), + Arguments.of("if(d6=?6,d4,d6=?6,d10,d12)", List.of(), "4", "[3de0i0r0=6∈[1...6], 9de0i0r0=4∈[1...4]]"), + Arguments.of("if(d6=?5,d4,d6=?6,d10,d12)", List.of(), "10", "[3de0i0r0=6∈[1...6], 12de0i0r0=6∈[1...6], 18de0i0r0=10∈[1...10]]"), + Arguments.of("if(d6=?5,d4,d6=?5,d10,d12)", List.of(), "12", "[3de0i0r0=6∈[1...6], 12de0i0r0=6∈[1...6], 22de0i0r0=12∈[1...12]]"), + Arguments.of("if(d6=?5,d4,d6=?6,d10)", List.of(), "10", "[3de0i0r0=6∈[1...6], 12de0i0r0=6∈[1...6], 18de0i0r0=10∈[1...10]]"), + Arguments.of("if(d6=?5,d4,d6=?5,d10)", List.of(), "", "[3de0i0r0=6∈[1...6], 12de0i0r0=6∈[1...6]]"), + Arguments.of("max(d6,d4)", List.of(), "6", "[4de0i0r0=6∈[1...6], 7de0i0r0=4∈[1...4]]"), + Arguments.of("min(d6,d4)", List.of(), "4", "[4de0i0r0=6∈[1...6], 7de0i0r0=4∈[1...4]]"), + Arguments.of("replace(d6,d6,d4)", List.of(), "4", "[8de0i0r0=6∈[1...6], 11de0i0r0=6∈[1...6], 14de0i0r0=4∈[1...4]]"), + Arguments.of("asc(d6,d4,d6)", List.of(), "4, 6, 6", "[4de0i0r0=6∈[1...6], 7de0i0r0=4∈[1...4], 10de0i0r0=6∈[1...6]]"), + Arguments.of("desc(d6,d4,d6)", List.of(), "6, 6, 4", "[5de0i0r0=6∈[1...6], 8de0i0r0=4∈[1...4], 11de0i0r0=6∈[1...6]]"), + Arguments.of("val('$1',d6), '$1' + '$1'", List.of(), "6, 6", "[9de0i0r0=6∈[1...6]]"), + Arguments.of("val('$1',d6), val('$1',d4), '$1'", List.of(), "4", "[23de0i0r0=4∈[1...4]]"), + Arguments.of("val('$1',d6), val('$2',d4 + '$1'), '$2'", List.of(), "4, 6", "[9de0i0r0=6∈[1...6], 23de0i0r0=4∈[1...4]]") + ); + } + + private static String getRandomElementsString(Roll roll) { + return roll.getRandomElementsInRoll().stream() + .map(l -> l.stream() + .map(RandomElement::getRollElement) + .map(RollElement::getValue) + .toList()) + .map(List::toString) + .collect(Collectors.joining(" ")); + } + + @ParameterizedTest(name = "{index} input:{0}, diceRolls:{1} -> {2},{3}") + @MethodSource("generateStringDiceDataWithRandomElements") + void rollDiceExpressionWithRandomElements(String diceExpression, List diceNumbers, String expectedResult, String expectedRandomElements) throws ExpressionException { + DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(diceNumbers), 1000, 10_000, true); + List res = underTest.evaluate(diceExpression).getRolls(); + + String result = res.stream().map(Roll::getResultStringWithTagAndColor).collect(Collectors.joining(", ")); + String randomElements = res.stream().map(r -> r.getRandomElementsInRoll().stream() + .flatMap(Collection::stream) + .toList().toString()).collect(Collectors.joining(", ")); + String diceNumbersOut = diceNumbers.stream().map(String::valueOf).collect(Collectors.joining(", ")); + //System.out.printf("Arguments.of(\"%s\", List.of(%s), \"%s\", \"%s\"),%n", diceExpression, diceNumbersOut, result, randomElements); + + + SoftAssertions.assertSoftly(s -> { + s.assertThat(result).isEqualTo(expectedResult); + s.assertThat(randomElements).isEqualTo(expectedRandomElements); + + //x will not be part of the result expression + if (!diceExpression.contains("x")) { + s.assertThat(res.getFirst().getExpression().replace(" ", "")).isEqualTo(diceExpression.replace(" ", "")); + } + }); + } + @Test void debug() throws ExpressionException { - DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 3, 4, 5, 6, 6, 1), 1000, 10_000, true); + GivenNumberSupplier numberSupplier = new GivenNumberSupplier(1); + DiceEvaluator underTest = new DiceEvaluator(numberSupplier, 1000, 10_000, true); - List res = underTest.evaluate("[]="); + // List res = underTest.evaluate("3d!6+(2r(2d8))"); + List res = underTest.evaluate("if(d6>?3,d8)").getRolls(); System.out.println(res.size()); res.forEach(r -> System.out.println(r.getResultString())); System.out.println(res); System.out.println(res.getFirst().getExpression()); + System.out.println(res.stream().map(Roll::getRandomElementsInRoll).flatMap(r -> r.stream().flatMap(Collection::stream) + .map(re -> re.getDieId() + "=" + re.getRollElement().getValue())) + .collect(Collectors.joining(", "))); res.forEach(r -> System.out.println(r.getRandomElementsInRoll())); - res.forEach(r -> System.out.println(r.getRandomElementsString())); + res.forEach(r -> System.out.println(getRandomElementsString(r))); System.out.println(res.stream().flatMap(r -> r.getElements().stream()).map(RollElement::getValue).toList()); + // assertThat(numberSupplier.allStoredDiceUsed()).isTrue(); + } + + @Test + void giveDiceNumber() throws ExpressionException { + GivenDiceNumberSupplier givenDiceNumberSupplier = new GivenDiceNumberSupplier(new GivenNumberSupplier(), ImmutableMap.of( + DieId.of(1, "d", 0, 2, 0), 4, + DieId.of(9, "d", 1, 1, 0), 1) + ); + DiceEvaluator underTest = new DiceEvaluator(givenDiceNumberSupplier, 1000, 10_000, true); + + List res = underTest.evaluate("3d6+(2r(2d8))").getRolls(); + + assertThat(res.size()).isEqualTo(1); + assertThat(values(res)).containsExactly("6", "6", "4", "8", "8", "8", "1"); + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream) + .toList().toString()) + .isEqualTo("[1de0i0r0=6∈[1...6], 1de0i1r0=6∈[1...6], 1de0i2r0=4∈[1...6], 9de0i0r0=8∈[1...8], 9de0i1r0=8∈[1...8], 9de1i0r0=8∈[1...8], 9de1i1r0=1∈[1...8]]"); + assertThat((res.stream().map(Roll::getRandomElementsInRoll).flatMap(r -> r.stream().flatMap(Collection::stream) + .map(re -> re.getDieId() + "=" + re.getRollElement().getValue())))).containsExactly( + "1de0i0r0=6", + "1de0i1r0=6", + "1de0i2r0=4", + "9de0i0r0=8", + "9de0i1r0=8", + "9de1i0r0=8", + "9de1i1r0=1"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[6, 6, 4] [8, 8] [8, 1]"); + assertThat(givenDiceNumberSupplier.allStoredDiceUsed()).isTrue(); + } + + @Test + void giveDiceNumberRandom() throws ExpressionException { + GivenDiceNumberSupplier givenDiceNumberSupplier = new GivenDiceNumberSupplier(ImmutableMap.of( + DieId.of(1, "d", 0, 2, 0), 10, + DieId.of(9, "d", 1, 1, 0), 11) + ); + DiceEvaluator underTest = new DiceEvaluator(givenDiceNumberSupplier, 1000, 10_000, true); + + List res = underTest.evaluate("3d6+(2r(2d8))").getRolls(); + + assertThat(res.size()).isEqualTo(1); + assertThat(values(res)).contains("10", "11"); + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream) + .map(Objects::toString)) + .contains("1de0i2r0=10∈[1...6]", "9de1i1r0=11∈[1...8]"); + assertThat(givenDiceNumberSupplier.allStoredDiceUsed()).isTrue(); + } + + @Test + void giveDiceNumber_additionalyStoredValue() throws ExpressionException { + GivenDiceNumberSupplier givenDiceNumberSupplier = new GivenDiceNumberSupplier(new GivenNumberSupplier(), ImmutableMap.of( + DieId.of(1, "d", 0, 2, 0), 4, + DieId.of(9, "d", 1, 1, 0), 1, + DieId.of(10, "d", 1, 1, 0), 1) + ); + DiceEvaluator underTest = new DiceEvaluator(givenDiceNumberSupplier, 1000, 10_000, true); + + List res = underTest.evaluate("3d6+(2r(2d8))").getRolls(); + + assertThat(res.size()).isEqualTo(1); + assertThat(values(res)).containsExactly("6", "6", "4", "8", "8", "8", "1"); + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream) + .toList().toString()) + .isEqualTo("[1de0i0r0=6∈[1...6], 1de0i1r0=6∈[1...6], 1de0i2r0=4∈[1...6], 9de0i0r0=8∈[1...8], 9de0i1r0=8∈[1...8], 9de1i0r0=8∈[1...8], 9de1i1r0=1∈[1...8]]"); + assertThat((res.stream().map(Roll::getRandomElementsInRoll).flatMap(r -> r.stream().flatMap(Collection::stream) + .map(re -> re.getDieId() + "=" + re.getRollElement().getValue())))).containsExactly( + "1de0i0r0=6", + "1de0i1r0=6", + "1de0i2r0=4", + "9de0i0r0=8", + "9de0i1r0=8", + "9de1i0r0=8", + "9de1i1r0=1"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[6, 6, 4] [8, 8] [8, 1]"); + assertThat(givenDiceNumberSupplier.allStoredDiceUsed()).isFalse(); + } + + @Test + void rollerRollIdentical() throws ExpressionException { + DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(5, 5), 1000, 10_000, true); + + Roller roller = underTest.buildRollSupplier("1d6"); + + assertThat(roller.roll()).isEqualTo(roller.roll()); } @Test void valRandomElementsInCorrectOrder() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 3, 4, 5, 6), 1000, 10_000, true); - List res = underTest.evaluate("val('$r',color(1d9,'blue')) val('$h',color(1d10,'purple_dark')) val('$s',('$r'+'$h')>=6c) val('$rt','$r'==10c) val('$ht','$h'==10c) val('$ho','$h'==1c) val('$2s',((('$rt'+'$ht'=))/2)*2) val('$ts',('$s'+'$2s'=)) concat('successes: ', '$ts', ifE('$ts',0,ifG('$ho',1,' bestial failure' , ''),''), ifE('$rt' mod 2, 1, ifE('$ht' mod 2, 1, ' messy critical', ''), ''))"); + List res = underTest.evaluate("val('$r',color(1d9,'blue')) val('$h',color(1d10,'purple_dark')) val('$s',('$r'+'$h')>=6c) val('$rt','$r'==10c) val('$ht','$h'==10c) val('$ho','$h'==1c) val('$2s',((('$rt'+'$ht'=))/2)*2) val('$ts',('$s'+'$2s'=)) concat('successes: ', '$ts', ifE('$ts',0,ifG('$ho',1,' bestial failure' , ''),''), ifE('$rt' mod 2, 1, ifE('$ht' mod 2, 1, ' messy critical', ''), ''))").getRolls(); assertThat(values(res)).containsExactly("successes: 0, blue:1, purple_dark:1"); assertThat(res.size()).isEqualTo(1); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().toString()).isEqualTo("[[1∈[1...9]], [2∈[1...10]]]"); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[1] [2]"); + assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[[16de0i0r0=1∈[1...9]], [44de0i0r0=2∈[1...10]]]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[1] [2]"); } @ParameterizedTest(name = "{index} input:{0}, diceRolls:{1} -> {2}") @@ -665,26 +922,26 @@ void valRandomElementsInCorrectOrder() throws ExpressionException { void resultSize(String expression, int size) throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate(expression); + List res = underTest.evaluate(expression).getRolls(); assertThat(res).hasSize(size); } @Test - void testColDontCopyUniqueRandomElements() throws ExpressionException { + void testColDontCopyRandomElements() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 3, 4, 5, 6), 1000, 10_000, true); - List res = underTest.evaluate("val('1',1d6) if('1' =? 1, '1' col 'red', '1')"); + List res = underTest.evaluate("val('1',1d6) if('1' =? 1, '1' col 'red', '1')").getRolls(); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements()).hasSize(1); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().getFirst().getRandomElements().getFirst().getRollElement().getColor()).isEqualTo("red"); + assertThat(res.getFirst().getRandomElementsInRoll()).hasSize(1); + assertThat(res.getFirst().getRandomElementsInRoll().getFirst().getFirst().getRollElement().getColor()).isEqualTo("red"); } @Test void testRegularDieHeap() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate("1000d999999999"); + List res = underTest.evaluate("1000d999999999").getRolls(); assertThat(res.getFirst().getElements()).hasSize(1000); } @@ -693,9 +950,10 @@ void testRegularDieHeap() throws ExpressionException { void disableRollChildren() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(0), 1000, 10_000, false); - List res = underTest.evaluate("(2d6=)d(2d6=)"); + List res = underTest.evaluate("(2d6=)d(2d6=)").getRolls(); assertThat(res.getFirst().getElements()).hasSize(5); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().stream().map(RandomElements::getRandomElements).mapToLong(AbstractCollection::size).sum()).isEqualTo(9); + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream)).hasSize(9); assertThat(res.getFirst().getChildrenRolls().stream().mapToLong(this::getNumberOfChildrenRolls).sum()).isEqualTo(0); } @@ -703,9 +961,10 @@ void disableRollChildren() throws ExpressionException { void enableRollChildren() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(0), 1000, 10_000, true); - List res = underTest.evaluate("(2d6=)d(2d6=)"); + List res = underTest.evaluate("(2d6=)d(2d6=)").getRolls(); assertThat(res.getFirst().getElements()).hasSize(5); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().stream().map(RandomElements::getRandomElements).mapToLong(AbstractCollection::size).sum()).isEqualTo(9); + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream)).hasSize(9); assertThat(res.getFirst().getChildrenRolls().stream().mapToLong(this::getNumberOfChildrenRolls).sum()).isEqualTo(6); } @@ -715,8 +974,9 @@ void testMaxResultElements() { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10, false); assertThatThrownBy(() -> underTest.evaluate("10d10 + 5")) - .isInstanceOfAny(ExpressionException.class, ArithmeticException.class) - .hasMessage("To many elements in roll '10d10+5', max is 10 but there where 11"); + .isInstanceOfAny(ExpressionException.class) + .hasMessage("To many elements in roll '10d10+5', max is 10 but there where 11") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(6, "+")); } @Test @@ -724,8 +984,9 @@ void testMaxRandomElements() { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10, false); assertThatThrownBy(() -> underTest.evaluate("(6d6k1)+(6d6k1)")) - .isInstanceOfAny(ExpressionException.class, ArithmeticException.class) - .hasMessage("To many random elements in roll '(6d6k1)+(6d6k1)', max is 10 but there where 12"); + .isInstanceOfAny(ExpressionException.class) + .hasMessage("To many random elements in roll '(6d6k1)+(6d6k1)', max is 10 but there where 12") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(7, "+")); } private long getNumberOfChildrenRolls(Roll roll) { @@ -736,7 +997,7 @@ private long getNumberOfChildrenRolls(Roll roll) { void testCustomDieHeap() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate("1000d[" + IntStream.range(0, 1000).mapToObj(i -> "1").collect(Collectors.joining("/")) + "]"); + List res = underTest.evaluate("1000d[" + IntStream.range(0, 1000).mapToObj(i -> "1").collect(Collectors.joining("/")) + "]").getRolls(); assertThat(res.getFirst().getElements()).hasSize(1000); } @@ -745,7 +1006,7 @@ void testCustomDieHeap() throws ExpressionException { void testExplodingDieMaxHeap() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate("1000d!999999999"); + List res = underTest.evaluate("1000d!999999999").getRolls(); assertThat(res.getFirst().getElements()).hasSize(1000); } @@ -754,16 +1015,61 @@ void testExplodingDieMaxHeap() throws ExpressionException { void testExplodingDieTwoHeap() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate("1000d!2"); + List res = underTest.evaluate("1000d!2").getRolls(); assertThat(res.getFirst().getElements()).hasSizeGreaterThan(1000); } + @Test + void testExplodingDieHeap() { + DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); + + assertThatThrownBy(() -> underTest.evaluate("d!6")) + .isInstanceOfAny(ExpressionException.class) + .hasMessage("To many elements in roll 'd!6', max is 10000 but there where 10001") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(0, "d!")); + + } + + @Test + void testExplodingDiceHeap() { + DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); + + assertThatThrownBy(() -> underTest.evaluate("1000d!6")) + .isInstanceOfAny(ExpressionException.class) + .hasMessage("To many elements in roll '1000d!6', max is 10000 but there where 10001") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(4, "d!")); + + } + + @Test + void testExplodingAddDieHeap() { + DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); + + assertThatThrownBy(() -> underTest.evaluate("d!!6")) + .isInstanceOfAny(ExpressionException.class) + .hasMessage("To many elements in roll 'd!!6', max is 10000 but there where 10001") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(0, "d!!")); + + } + + @Test + void testExplodingAddDiceHeap() { + DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); + + assertThatThrownBy(() -> underTest.evaluate("1000d!!6")) + .isInstanceOfAny(ExpressionException.class) + .hasMessage("To many elements in roll '1000d!!6', max is 10000 but there where 10001") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(4, "d!!")); + + } + + @Test void testExplodingAddDieMaxHeap() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate("1000d!!999999999"); + List res = underTest.evaluate("1000d!!999999999").getRolls(); assertThat(res.getFirst().getElements()).hasSize(1000); } @@ -772,7 +1078,7 @@ void testExplodingAddDieMaxHeap() throws ExpressionException { void testExplodingAddDieTwoHeap() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate("1000d!!2"); + List res = underTest.evaluate("1000d!!2").getRolls(); assertThat(res.getFirst().getElements()).hasSize(1000); } @@ -781,20 +1087,16 @@ void testExplodingAddDieTwoHeap() throws ExpressionException { @MethodSource("generateData") void rollExpression(String diceExpression, List diceNumbers, List expected) throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(diceNumbers), 1000, 10_000, true); - List res = underTest.evaluate(diceExpression); + List res = underTest.evaluate(diceExpression).getRolls(); assertThat(res.stream().flatMap(r -> r.getElements().stream()).flatMap(e -> e.asInteger().stream())).containsExactlyElementsOf(expected); - //val is not given in the dice expression because it is on a roll without result - if (res.size() == 1 && !diceExpression.contains("val(")) { - assertThat(res.getFirst().getExpression().replace(" ", "")).isEqualTo(diceExpression.replace(" ", "")); - } } @Test void sortAsc() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 20, 1, 12), 1000, 10_000, true); - List res = underTest.evaluate("asc(4d20)"); + List res = underTest.evaluate("asc(4d20)").getRolls(); assertThat(values(res)).containsExactly("1", "3", "12", "20"); } @@ -803,7 +1105,7 @@ void sortAsc() throws ExpressionException { void sortDesc() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 20, 1, 12), 1000, 10_000, true); - List res = underTest.evaluate("desc(4d20)"); + List res = underTest.evaluate("desc(4d20)").getRolls(); assertThat(values(res)).containsExactly("20", "12", "3", "1"); } @@ -812,7 +1114,7 @@ void sortDesc() throws ExpressionException { void sortAlphaAsc() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 20, 1, 12), 1000, 10_000, true); - List res = underTest.evaluate("asc(4d20 + '5a' +'b')"); + List res = underTest.evaluate("asc(4d20 + '5a' +'b')").getRolls(); assertThat(values(res)).containsExactly("1", "3", "12", "20", "5a", "b"); } @@ -821,7 +1123,7 @@ void sortAlphaAsc() throws ExpressionException { void sortAlphaDesc() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 20, 1, 12), 1000, 10_000, true); - List res = underTest.evaluate("desc(4d20 + '5a' + 'b')"); + List res = underTest.evaluate("desc(4d20 + '5a' + 'b')").getRolls(); assertThat(values(res)).containsExactly("b", "5a", "20", "12", "3", "1"); } @@ -830,7 +1132,7 @@ void sortAlphaDesc() throws ExpressionException { void groupCount() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); - List res = underTest.evaluate("groupC(4d20 + 10d10 + 3d6 + 10 + color(3d6,'red')+color(3d4,'black'))"); + List res = underTest.evaluate("groupC(4d20 + 10d10 + 3d6 + 10 + color(3d6,'red')+color(3d4,'black'))").getRolls(); assertThat(res.stream().flatMap(r -> r.getElements().stream()).map(Object::toString)).containsExactly("11x10", "4x20", "black:3x4", "3x6", "red:3x6"); } @@ -839,7 +1141,7 @@ void groupCount() throws ExpressionException { @MethodSource("generateStringDiceData") void rollStringDiceExpression(String diceExpression, List diceNumbers, List expected) throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(diceNumbers), 1000, 10_000, true); - List res = underTest.evaluate(diceExpression); + List res = underTest.evaluate(diceExpression).getRolls(); assertThat(values(res)).containsExactlyElementsOf(expected); //val is not given in the dice expression because it is on a roll without result @@ -852,12 +1154,12 @@ void rollStringDiceExpression(String diceExpression, List diceNumbers, @MethodSource("generateStringDiceDataColor") void rollStringDiceExpressionColor(String diceExpression, List diceNumbers, List expected, String expectedColor) throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(diceNumbers), 1000, 10_000, true); - List res = underTest.evaluate(diceExpression); + List res = underTest.evaluate(diceExpression).getRolls(); assertThat(values(res)).containsExactlyElementsOf(expected); assertThat(res.stream() - .flatMap(e -> e.getRandomElementsInRoll().getRandomElements().stream()) - .flatMap(r -> r.getRandomElements().stream()) + .flatMap(e -> e.getRandomElementsInRoll().stream()) + .flatMap(Collection::stream) .map(RandomElement::getRollElement) .map(RollElement::getColor) ).allMatch(expectedColor::equals); @@ -869,7 +1171,9 @@ void integerDevide_NotSingleIntegerException() { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(4, 1), 1000, 10_000, true); assertThatThrownBy(() -> underTest.evaluate("2d6 / 3")) .isInstanceOf(ExpressionException.class) - .hasMessage("'/' requires as left input a single integer but was '[4, 1]'. Try to sum the numbers together like (2d6=)"); + .hasMessage("'/' requires as left input a single integer but was '[4, 1]'. Try to sum the numbers together like (2d6=)") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(4, "/")); + } @Test @@ -877,75 +1181,82 @@ void decimalDevide_NotSingleDecimalException() { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(4, 1), 1000, 10_000, true); assertThatThrownBy(() -> underTest.evaluate("2d6 // 3")) .isInstanceOf(ExpressionException.class) - .hasMessage("'//' requires as left input a single decimal but was '[4, 1]'. Try to sum the numbers together like (2d6=)"); + .hasMessage("'//' requires as left input a single decimal but was '[4, 1]'. Try to sum the numbers together like (2d6=)") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(4, "//")); + } @Test void divisorZero() { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); assertThatThrownBy(() -> underTest.evaluate("10 / 0")) - .isInstanceOf(ArithmeticException.class) - .hasMessage("/ by zero"); + .isInstanceOf(ExpressionException.class) + .hasMessage("/ by zero") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(3, "/")); } @ParameterizedTest(name = "{index} input:{0}, diceRolls:{1} -> {2}") @MethodSource("generateRandomDiceData") void getRandomElements(String expression, List diceThrows, List> expectedRandomElements) throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(diceThrows), 1000, 10_000, true); - List res = underTest.evaluate(expression); + List res = underTest.evaluate(expression).getRolls(); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) - .map(RollElement::getValue).toList())) + .map(RollElement::getValue) + .toList() + )) .containsExactlyElementsOf(expectedRandomElements); } @Test void getRandomElements_regularDice() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 4, 4, 5), 1000, 10_000, true); - List res = underTest.evaluate("(2d4=)d6"); + List res = underTest.evaluate("(2d4=)d6").getRolls(); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) .map(RollElement::getValue) - .toList())) + .toList() + )) .containsExactly(List.of("1", "2"), List.of("4", "4", "5")); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(r -> r.stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) .containsExactly(List.of(4, 4), List.of(6, 6, 6)); } @Test void getRandomElements_customDice() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 4, 4, 5), 1000, 10_000, true); - List res = underTest.evaluate("(2d4=)d[a/b/c/d/e/f]"); + List res = underTest.evaluate("(2d4=)d[a/b/c/d/e/f]").getRolls(); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) .map(RollElement::getValue) - .toList())) + .toList() + )) .containsExactly(List.of("1", "2"), List.of("d", "d", "e")); assertThat(res.stream().map(r -> r.getRandomElementsInRoll().toString())) - .containsExactly("[1∈[1...4], 2∈[1...4]], [d∈[a, b, c, d, e, f], d∈[a, b, c, d, e, f], e∈[a, b, c, d, e, f]]"); + .containsExactly("[[2de0i0r0=1∈[1...4], 2de0i1r0=2∈[1...4]], [6de0i0r0=d∈[a, b, c, d, e, f], 6de0i1r0=d∈[a, b, c, d, e, f], 6de0i2r0=e∈[a, b, c, d, e, f]]]"); } @Test void getRandomElements_value() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(5, 10, 10), 1000, 10_000, true); - List res = underTest.evaluate("val('$1',d100) ifG('$1', 95, (d100 + '$1'=), ifL('$1', 6, ('$1' - d100=)))"); + List res = underTest.evaluate("val('$1',d100) ifG('$1', 95, (d100 + '$1'=), ifL('$1', 6, ('$1' - d100=)))").getRolls(); assertThat(res).hasSize(1); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("-5"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .flatMap(r -> r.getRandomElements().stream() - .map(RandomElement::getRollElement) - .map(RollElement::getValue))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream() + .flatMap(Collection::stream)) + .map(RandomElement::getRollElement) + .map(RollElement::getValue)) .containsExactly("5", "10"); } @@ -954,94 +1265,98 @@ void getRandomElements_value() throws ExpressionException { @Test void getRandomElements_explode() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 2, 8, 3, 4), 1000, 10_000, true); - List res = underTest.evaluate("exp(2d6,1d8,1d10)"); + List res = underTest.evaluate("exp(2d6,1d8,1d10)").getRolls(); assertThat(res.stream().flatMap(r -> r.getElements().stream()).map(RollElement::getValue)).containsExactly("1", "2", "3", "4"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) .map(RollElement::getValue) - .toList())) - .containsExactly(List.of("1", "2"), List.of("2"), List.of("8"), List.of("3", "4")); + .toList() + )) + .containsExactly(List.of("1", "2"), List.of("3", "4"), List.of("2"), List.of("8")); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) - .containsExactly(List.of(6, 6), List.of(8), List.of(10), List.of(6, 6)); + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(r -> r.stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) + .containsExactly(List.of(6, 6), List.of(6, 6), List.of(8), List.of(10)); } @Test void getRandomElements_replace_no_match() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 5), 1000, 10_000, true); - List res = underTest.evaluate("replace(3d6,[6],2d20)"); + List res = underTest.evaluate("replace(3d6,[6],2d20)").getRolls(); assertThat(res.stream().flatMap(r -> r.getElements().stream()).map(RollElement::getValue)).containsExactly("1", "2", "5"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) .map(RollElement::getValue) - .toList())) + .toList() + )) .containsExactly(List.of("1", "2", "5")); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(r -> r.stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) .containsExactly(List.of(6, 6, 6)); } @Test void getRandomElements_replace() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 5, 19, 18, 17, 16), 1000, 10_000, true); - List res = underTest.evaluate("replace(3d6,[1,5],2d20)"); + List res = underTest.evaluate("replace(3d6,[1,5],2d20)").getRolls(); assertThat(res.stream().flatMap(r -> r.getElements().stream()).map(RollElement::getValue)).containsExactly("19", "18", "2", "17", "16"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) .map(RollElement::getValue) - .toList())) + .toList() + )) .containsExactly(List.of("1", "2", "5"), List.of("19", "18"), List.of("17", "16")); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(r -> r.stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) .containsExactly(List.of(6, 6, 6), List.of(20, 20), List.of(20, 20)); } @Test void getRandomElements_replaceRollFind() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 1, 2, 3), 1000, 10_000, true); - List res = underTest.evaluate("replace(1d6, 1d6, 1d6, 1d8, 1d10)"); + List res = underTest.evaluate("replace(1d6, 1d6, 1d6, 1d8, 1d10)").getRolls(); assertThat(res.stream().flatMap(r -> r.getElements().stream()).map(RollElement::getValue)).containsExactly("2"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) .map(RollElement::getValue) - .toList())) + .toList() + )) .containsExactly(List.of("1"), List.of("1"), List.of("2"), List.of("3")); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(r -> r.stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) .containsExactly(List.of(6), List.of(6), List.of(6), List.of(8)); } @Test void separatorTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2), 1000, 10_000, true); - List res = underTest.evaluate("1d6,1d8"); + List res = underTest.evaluate("1d6,1d8").getRolls(); assertThat(res).hasSize(2); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("1"); assertThat(res.get(1).getElements().stream().map(RollElement::getValue)).containsExactly("2"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .flatMap(r -> r.getRandomElements().stream() - .map(RandomElement::getRollElement) - .map(RollElement::getValue))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .flatMap(Collection::stream) + .map(RandomElement::getRollElement) + .map(RollElement::getValue)) .containsExactly("1", "2"); assertThat(res.stream().map(Roll::getExpression)) .containsExactly("1d6", "1d8"); @@ -1050,16 +1365,16 @@ void separatorTest() throws ExpressionException { @Test void spaceSeparatorTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2), 1000, 10_000, true); - List res = underTest.evaluate("1d6 1d8"); + List res = underTest.evaluate("1d6 1d8").getRolls(); assertThat(res).hasSize(2); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("1"); assertThat(res.get(1).getElements().stream().map(RollElement::getValue)).containsExactly("2"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .flatMap(r -> r.getRandomElements().stream() - .map(RandomElement::getRollElement) - .map(RollElement::getValue))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .flatMap(Collection::stream) + .map(RandomElement::getRollElement) + .map(RollElement::getValue)) .containsExactly("1", "2"); assertThat(res.stream().map(Roll::getExpression)) .containsExactly("1d6", "1d8"); @@ -1068,7 +1383,7 @@ void spaceSeparatorTest() throws ExpressionException { @Test void getRandomElements_Repeat() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 3, 4, 5), 1000, 10_000, true); - List res = underTest.evaluate("5x1d6"); + List res = underTest.evaluate("5x1d6").getRolls(); assertThat(res).hasSize(5); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("1"); @@ -1077,10 +1392,10 @@ void getRandomElements_Repeat() throws ExpressionException { assertThat(res.get(3).getElements().stream().map(RollElement::getValue)).containsExactly("4"); assertThat(res.get(4).getElements().stream().map(RollElement::getValue)).containsExactly("5"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .flatMap(r -> r.getRandomElements().stream() - .map(RandomElement::getRollElement) - .map(RollElement::getValue))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .flatMap(Collection::stream) + .map(RandomElement::getRollElement) + .map(RollElement::getValue)) .containsExactly("1", "2", "3", "4", "5"); assertThat(res.stream().map(Roll::getExpression)) .containsExactly("1d6", "1d6", "1d6", "1d6", "1d6"); @@ -1089,15 +1404,15 @@ void getRandomElements_Repeat() throws ExpressionException { @Test void getRandomElements_ListRepeat() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(1, 2, 3, 4, 5), 1000, 10_000, true); - List res = underTest.evaluate("5r1d6"); + List res = underTest.evaluate("5r1d6").getRolls(); assertThat(res).hasSize(1); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("1", "2", "3", "4", "5"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .flatMap(r -> r.getRandomElements().stream() - .map(RandomElement::getRollElement) - .map(RollElement::getValue))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .flatMap(Collection::stream) + .map(RandomElement::getRollElement) + .map(RollElement::getValue)) .containsExactly("1", "2", "3", "4", "5"); assertThat(res.getFirst().getExpression()).isEqualTo("5r1d6"); } @@ -1107,16 +1422,16 @@ void getRandomElements_reroll() throws ExpressionException { //roll 4d6, reroll 1s once, drop lowest, rolled three times DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(0L), 1000, 10_000, true); - List res = underTest.evaluate("3x4d6rr1k3"); + List res = underTest.evaluate("3x4d6rr1k3").getRolls(); assertThat(res).hasSize(3); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("6", "3", "1"); assertThat(res.get(1).getElements().stream().map(RollElement::getValue)).containsExactly("6", "3", "3"); assertThat(res.get(2).getElements().stream().map(RollElement::getValue)).containsExactly("4", "4", "3"); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[2, 3, 1, 4] [1, 1, 6, 3]"); - assertThat(res.get(1).getRandomElementsString()).isEqualTo("[2, 3, 6, 3]"); - assertThat(res.get(2).getRandomElementsString()).isEqualTo("[3, 2, 4, 4]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[2, 3, 1, 4] [1, 1, 6, 3]"); + assertThat(getRandomElementsString(res.get(1))).isEqualTo("[2, 3, 6, 3]"); + assertThat(getRandomElementsString(res.get(2))).isEqualTo("[3, 2, 4, 4]"); assertThat(res.stream().map(Roll::getExpression)) .containsExactly("4d6rr1k3", "4d6rr1k3", "4d6rr1k3"); @@ -1125,17 +1440,19 @@ void getRandomElements_reroll() throws ExpressionException { @Test void getRandomElements_explodingDice() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(2, 1, 4, 6, 6, 1, 5), 1000, 10_000, true); - List res = underTest.evaluate("(1d!2=)d!6"); + List res = underTest.evaluate("(1d!2=)d!6").getRolls(); assertThat(res).hasSize(1); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("4", "6", "6", "1", "5"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) - .map(RollElement::getValue).toList())) + .map(RollElement::getValue) + .toList() + )) .containsExactly(List.of("2", "1"), List.of("4", "6", "6", "1", "5")); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(r -> r.stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) .containsExactly(List.of(2, 2), List.of(6, 6, 6, 6, 6)); assertThat(res.getFirst().getExpression()).isEqualTo("(1d!2=)d!6"); } @@ -1143,18 +1460,19 @@ void getRandomElements_explodingDice() throws ExpressionException { @Test void getRandomElements_explodingAddDice() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(2, 1, 4, 6, 6, 1, 5), 1000, 10_000, true); - List res = underTest.evaluate("(1d!!2=)d!!6"); + List res = underTest.evaluate("(1d!!2=)d!!6").getRolls(); assertThat(res).hasSize(1); assertThat(res.getFirst().getElements().stream().map(RollElement::getValue)).containsExactly("4", "13", "5"); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream() + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(rl -> rl.stream() .map(RandomElement::getRollElement) .map(RollElement::getValue) - .toList())) + .toList() + )) .containsExactly(List.of("2", "1"), List.of("4", "6", "6", "1", "5")); - assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().getRandomElements().stream()) - .map(r -> r.getRandomElements().stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) + assertThat(res.stream().flatMap(r -> r.getRandomElementsInRoll().stream()) + .map(r -> r.stream().map(RandomElement::getMaxInc).collect(Collectors.toList()))) .containsExactly(List.of(2, 2), List.of(6, 6, 6, 6, 6)); assertThat(res.getFirst().getExpression()).isEqualTo("(1d!!2=)d!!6"); } @@ -1162,10 +1480,10 @@ void getRandomElements_explodingAddDice() throws ExpressionException { @Test void toStringTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("1d6 + 3d20 + 10 +min(2d6,3d4)"); + List res = underTest.evaluate("1d6 + 3d20 + 10 +min(2d6,3d4)").getRolls(); assertThat(res).hasSize(1); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3] [2, 1, 4] [6, 6] [4, 4, 4]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3] [2, 1, 4] [6, 6] [4, 4, 4]"); assertThat(res.getFirst().getResultString()).isEqualTo("3, 2, 1, 4, 10, 4, 4, 4"); assertThat(res.getFirst().getExpression()).isEqualTo("1d6+3d20+10+min(2d6,3d4)"); } @@ -1173,10 +1491,10 @@ void toStringTest() throws ExpressionException { @Test void toStringBracketTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("3d(20 + 10=)"); + List res = underTest.evaluate("3d(20 + 10=)").getRolls(); assertThat(res).hasSize(1); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3, 2, 1]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3, 2, 1]"); assertThat(res.getFirst().getResultString()).isEqualTo("3, 2, 1"); assertThat(res.getFirst().getExpression()).isEqualTo("3d(20+10=)"); } @@ -1184,31 +1502,47 @@ void toStringBracketTest() throws ExpressionException { @Test void toStringColorTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("color(1d6,'red') + color(3d20,'blue')"); + List res = underTest.evaluate("color(1d6,'red') + color(3d20,'blue')").getRolls(); assertThat(res).hasSize(1); - assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[3∈[1...6]], [2∈[1...20], 1∈[1...20], 4∈[1...20]]"); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3] [2, 1, 4]"); + assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[[7de0i0r0=3∈[1...6]], [26de0i0r0=2∈[1...20], 26de0i1r0=1∈[1...20], 26de0i2r0=4∈[1...20]]]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3] [2, 1, 4]"); assertThat(res.getFirst().getResultString()).isEqualTo("red:3, blue:2, blue:1, blue:4"); assertThat(res.getFirst().getExpression()).isEqualTo("color(1d6,'red')+color(3d20,'blue')"); } + @Test + void diceIdTest() throws ExpressionException { + DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(5, 5), 1000, 10_000, true); + RollResult res = underTest.evaluate(" d6 + ' test t t' + d!6 "); + + assertThat(res.getRolls()).hasSize(1); + DieId diceId1 = res.getRolls().getFirst().getRandomElementsInRoll().getFirst().getFirst().getDieId(); + DieId diceId2 = res.getRolls().getFirst().getRandomElementsInRoll().getLast().getFirst().getDieId(); + assertThat(diceId1.toString()).isEqualTo("0de0i0r0"); + assertThat(diceId2.toString()).isEqualTo("20d!e0i0r0"); + assertThat(res.getExpression()).isEqualTo("d6 + ' test t t' + d!6"); + assertThat(res.getExpression().substring(diceId1.getRollId().getExpressionPosition().getStartInc(), diceId1.getRollId().getExpressionPosition().getStartInc() + diceId1.getRollId().getExpressionPosition().getValue().length())).isEqualTo(diceId1.getRollId().getExpressionPosition().getValue()); + assertThat(res.getExpression().substring(diceId2.getRollId().getExpressionPosition().getStartInc(), diceId2.getRollId().getExpressionPosition().getStartInc() + diceId2.getRollId().getExpressionPosition().getValue().length())).isEqualTo(diceId2.getRollId().getExpressionPosition().getValue()); + } + + @Test void colTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("1d6 col 'red' + 3d20 col 'blue'"); + List res = underTest.evaluate("1d6 col 'red' + 3d20 col 'blue'").getRolls(); assertThat(res).hasSize(1); - assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[3∈[1...6]], [2∈[1...20], 1∈[1...20], 4∈[1...20]]"); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().stream() - .flatMap(r -> r.getRandomElements().stream()) + assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[[1de0i0r0=3∈[1...6]], [18de0i0r0=2∈[1...20], 18de0i1r0=1∈[1...20], 18de0i2r0=4∈[1...20]]]"); + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream) .map(RandomElement::getRollElement) .map(RollElement::getColor)).containsExactly("red", "blue", "blue", "blue"); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().stream() - .flatMap(r -> r.getRandomElements().stream()) + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream) .map(RandomElement::getRollElement) .map(RollElement::getTag)).containsExactly("", "", "", ""); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3] [2, 1, 4]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3] [2, 1, 4]"); assertThat(res.getFirst().getResultString()).isEqualTo("3, 2, 1, 4"); assertThat(res.getFirst().getExpression()).isEqualTo("1d6col'red'+3d20col'blue'"); } @@ -1216,17 +1550,17 @@ void colTest() throws ExpressionException { @Test void tagTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("1d6 tag 'red' + 3d20 tag 'blue'"); + List res = underTest.evaluate("1d6 tag 'red' + 3d20 tag 'blue'").getRolls(); assertThat(res).hasSize(1); - assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[3∈[1...6]], [2∈[1...20], 1∈[1...20], 4∈[1...20]]"); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3] [2, 1, 4]"); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().stream() - .flatMap(r -> r.getRandomElements().stream()) + assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[[1de0i0r0=3∈[1...6]], [18de0i0r0=2∈[1...20], 18de0i1r0=1∈[1...20], 18de0i2r0=4∈[1...20]]]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3] [2, 1, 4]"); + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream) .map(RandomElement::getRollElement) .map(RollElement::getColor)).containsExactly("", "", "", ""); - assertThat(res.getFirst().getRandomElementsInRoll().getRandomElements().stream() - .flatMap(r -> r.getRandomElements().stream()) + assertThat(res.getFirst().getRandomElementsInRoll().stream() + .flatMap(Collection::stream) .map(RandomElement::getRollElement) .map(RollElement::getTag)).containsExactly("", "", "", ""); assertThat(res.getFirst().getResultString()).isEqualTo("red:3, blue:2, blue:1, blue:4"); @@ -1236,49 +1570,49 @@ void tagTest() throws ExpressionException { @Test void toStringValColorTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("val('$r', 1d6) color('$r','red') + color('$r','blue')"); + List res = underTest.evaluate("val('$r', 1d6) color('$r','red') + color('$r','blue')").getRolls(); assertThat(res).hasSize(1); assertThat(res.getFirst().getResultString()).isEqualTo("red:3, blue:3"); - assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[3∈[1...6]]"); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3]"); + assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[[11de0i0r0=3∈[1...6]]]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3]"); assertThat(res.getFirst().getExpression()).isEqualTo("val('$r',1d6), color('$r','red')+color('$r','blue')"); } @Test void toStringValTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("val('$r', 1d6) '$r' + '$r'"); + List res = underTest.evaluate("val('$r', 1d6) '$r' + '$r'").getRolls(); assertThat(res).hasSize(1); assertThat(res.getFirst().getResultString()).isEqualTo("3, 3"); - assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[3∈[1...6]]"); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3]"); + assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[[11de0i0r0=3∈[1...6]]]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3]"); assertThat(res.getFirst().getExpression()).isEqualTo("val('$r',1d6), '$r'+'$r'"); } @Test void ifBoolTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3), 1000, 10_000, true); - List res = underTest.evaluate("val('$r',1d6) if('$r'=?1,'a','$r'=?2,'b','c')"); + List res = underTest.evaluate("val('$r',1d6) if('$r'=?1,'a','$r'=?2,'b','c')").getRolls(); assertThat(res).hasSize(1); assertThat(res.getFirst().getResultString()).isEqualTo("c"); - assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[3∈[1...6]]"); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3]"); + assertThat(res.getFirst().getRandomElementsInRoll().toString()).isEqualTo("[[10de0i0r0=3∈[1...6]]]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3]"); assertThat(res.getFirst().getExpression()).isEqualTo("val('$r',1d6), if('$r'=?1,'a','$r'=?2,'b','c')"); } @Test void toStringMultiExpressionTest() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(3, 2, 1, 4), 1000, 10_000, true); - List res = underTest.evaluate("1d6 + 3d20, 10 +min(2d6,3d4)"); + List res = underTest.evaluate("1d6 + 3d20, 10 +min(2d6,3d4)").getRolls(); assertThat(res).hasSize(2); - assertThat(res.getFirst().getRandomElementsString()).isEqualTo("[3] [2, 1, 4]"); + assertThat(getRandomElementsString(res.getFirst())).isEqualTo("[3] [2, 1, 4]"); assertThat(res.getFirst().getResultString()).isEqualTo("3, 2, 1, 4"); assertThat(res.getFirst().getExpression()).isEqualTo("1d6+3d20"); - assertThat(res.get(1).getRandomElementsString()).isEqualTo("[6, 6] [4, 4, 4]"); + assertThat(getRandomElementsString(res.get(1))).isEqualTo("[6, 6] [4, 4, 4]"); assertThat(res.get(1).getResultString()).isEqualTo("10, 4, 4, 4"); assertThat(res.get(1).getExpression()).isEqualTo("10+min(2d6,3d4)"); } @@ -1289,7 +1623,8 @@ void maxDice() { assertThatThrownBy(() -> underTest.evaluate("1001d6")) .isInstanceOf(ExpressionException.class) - .hasMessage("The number of dice must be less or equal then 1000 but was 1001"); + .hasMessage("The number of dice must be less or equal then 1000 but was 1001") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(4, "d")); } @Test @@ -1297,7 +1632,9 @@ void maxNegativeDice() { DiceEvaluator underTest = new DiceEvaluator(new GivenNumberSupplier(), 1000, 10_000, true); assertThatThrownBy(() -> underTest.evaluate("-1001d6")) .isInstanceOf(ExpressionException.class) - .hasMessage("The number of dice must be less or equal then 1000 but was 1001"); + .hasMessage("The number of dice must be less or equal then 1000 but was 1001") + .extracting(e -> ((ExpressionException) e).getExpressionPosition()).isEqualTo(ExpressionPosition.of(5, "d")); + } @ParameterizedTest(name = "{index} {0} -> {1}") @@ -1305,7 +1642,7 @@ void maxNegativeDice() { void testError(String input, String expectedMessage) { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(0L), 1000, 10_000, true); assertThatThrownBy(() -> underTest.evaluate(input)) - .isInstanceOfAny(ExpressionException.class, ArithmeticException.class) + .isInstanceOfAny(ExpressionException.class) .hasMessage(expectedMessage); } @@ -1315,8 +1652,8 @@ void rollTwice_1d6() throws ExpressionException { Roller res = underTest.buildRollSupplier("1d6"); - assertThat(res.roll().getFirst().getElements().toString()).isEqualTo("[1]"); - assertThat(res.roll().getFirst().getElements().toString()).isEqualTo("[2]"); + assertThat(res.roll().getRolls().getFirst().getElements().toString()).isEqualTo("[1]"); + assertThat(res.roll().getRolls().getFirst().getElements().toString()).isEqualTo("[2]"); } @Test @@ -1326,8 +1663,8 @@ void rollTwice_value() throws ExpressionException { Roller res = underTest.buildRollSupplier("val('$1', 3d6), (('$1')=) + (('$1'>2)c)"); - assertThat(res.roll().getFirst().getElements().toString()).isEqualTo("[6, 1]"); - assertThat(res.roll().getFirst().getElements().toString()).isEqualTo("[9, 2]"); + assertThat(res.roll().getRolls().getFirst().getElements().toString()).isEqualTo("[6, 1]"); + assertThat(res.roll().getRolls().getFirst().getElements().toString()).isEqualTo("[9, 2]"); } @Test diff --git a/src/test/java/de/janno/evaluator/dice/ProdExampleTest.java b/src/test/java/de/janno/evaluator/dice/ProdExampleTest.java index c33dffb..4928233 100644 --- a/src/test/java/de/janno/evaluator/dice/ProdExampleTest.java +++ b/src/test/java/de/janno/evaluator/dice/ProdExampleTest.java @@ -25,8 +25,8 @@ private static void write(String input, String result) throws IOException { @CsvFileSource(resources = "/expressionsAndResults.csv", delimiter = '|', maxCharsPerColumn = 100_000) void csvFileSourceTest(String expression, String expected) throws ExpressionException, IOException { DiceEvaluator underTest = new DiceEvaluator(new RandomNumberSupplier(0L), 1000, 10_000, true); - List res = underTest.evaluate(expression); - // write(expression, res.toString()); + List res = underTest.evaluate(expression).getRolls(); + //write(expression, res.toString()); assertThat(res.toString()).isEqualTo(expected); diff --git a/src/test/java/de/janno/evaluator/dice/RandomDiceEvaluatorTest.java b/src/test/java/de/janno/evaluator/dice/RandomDiceEvaluatorTest.java index fd42821..3d12c97 100644 --- a/src/test/java/de/janno/evaluator/dice/RandomDiceEvaluatorTest.java +++ b/src/test/java/de/janno/evaluator/dice/RandomDiceEvaluatorTest.java @@ -11,7 +11,7 @@ public class RandomDiceEvaluatorTest { void testWithRandom() throws ExpressionException { DiceEvaluator underTest = new DiceEvaluator(); - List res = underTest.evaluate("1d6"); + List res = underTest.evaluate("1d6").getRolls(); assertThat(res.size()).isEqualTo(1); assertThat(res.getFirst().getElements().size()).isEqualTo(1); diff --git a/src/test/java/de/janno/evaluator/dice/RollTest.java b/src/test/java/de/janno/evaluator/dice/RollTest.java new file mode 100644 index 0000000..416cc60 --- /dev/null +++ b/src/test/java/de/janno/evaluator/dice/RollTest.java @@ -0,0 +1,21 @@ +package de.janno.evaluator.dice; + +import com.google.common.collect.ImmutableList; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +public class RollTest { + + @Test + void testVerification() { + DieId dieId = DieId.of(2, "d", 0, 0, 0); + assertThatThrownBy(() -> new Roll("2d6", ImmutableList.of(), ImmutableList.of( + ImmutableList.of(new RandomElement(new RollElement("1", RollElement.NO_COLOR, RollElement.NO_TAG), 0, 6, dieId)), + ImmutableList.of(new RandomElement(new RollElement("1", RollElement.NO_COLOR, RollElement.NO_TAG), 0, 6, dieId))), + ImmutableList.of(), + ExpressionPosition.of(2, "d"), 100, false)) + .isInstanceOfAny(IllegalStateException.class) + .hasMessage("Random elements must have unique dice ids but [2de0i0r0] occurred more than once"); + } +} diff --git a/src/test/java/de/janno/evaluator/dice/TokenizerTest.java b/src/test/java/de/janno/evaluator/dice/TokenizerTest.java index 2eac448..92cc89e 100644 --- a/src/test/java/de/janno/evaluator/dice/TokenizerTest.java +++ b/src/test/java/de/janno/evaluator/dice/TokenizerTest.java @@ -5,7 +5,6 @@ import org.junit.jupiter.api.Test; import java.util.List; -import java.util.Map; import java.util.Optional; import static org.assertj.core.api.Assertions.assertThat; @@ -16,11 +15,11 @@ class TokenizerTest { Operator d = new Operator("d", Operator.OperatorType.BINARY, Operator.Associativity.LEFT, 1, 10_000, true) { @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("dice", RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), 10_000, true))); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("dice", RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), ExpressionPosition.of(1, "t"), 10_000, true))); } @Override @@ -32,11 +31,11 @@ class TokenizerTest { }; Operator plus = new Operator("+", Operator.OperatorType.BINARY, Operator.Associativity.LEFT, 2, 10_000, true) { @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("plus", RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), 10_000, true))); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("plus", RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), ExpressionPosition.of(1, "t"), 10_000, true))); } @Override @@ -48,11 +47,11 @@ class TokenizerTest { }; Operator aRightLeft = new Operator("a", Operator.Associativity.RIGHT, 1, Operator.Associativity.LEFT, 1, 10_000, true) { @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("a", RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), 10_000, true))); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("a", RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), ExpressionPosition.of(1, "t"), 10_000, true))); } @Override @@ -65,11 +64,11 @@ class TokenizerTest { Operator aLeft = new Operator("a", Operator.OperatorType.UNARY, Operator.Associativity.LEFT, 1, 10_000, true) { @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("a", RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), 10_000, true))); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("a", RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), ExpressionPosition.of(1, "t"), 10_000, true))); } @Override @@ -82,11 +81,11 @@ class TokenizerTest { Operator aRight = new Operator("a", Operator.OperatorType.UNARY, Operator.Associativity.RIGHT, 1, 10_000, true) { @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("a", RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), 10_000, true))); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("a", RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), ExpressionPosition.of(1, "t"), 10_000, true))); } @Override @@ -156,11 +155,11 @@ void trim() throws ExpressionException { void validate() { Operator d = new Operator("d", Operator.OperatorType.BINARY, Operator.Associativity.LEFT, 20, 10_000, true) { @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("null", RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), 10_000, true))); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("null", RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), ExpressionPosition.of(1, "t"), 10_000, true))); } @Override @@ -172,11 +171,11 @@ void validate() { }; Operator d2 = new Operator("d", Operator.OperatorType.UNARY, Operator.Associativity.LEFT, 15, 10_000, true) { @Override - public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull String inputValue) { + public @NonNull RollBuilder evaluate(@NonNull List operands, @NonNull ExpressionPosition expressionPosition) { return new RollBuilder() { @Override - public @NonNull Optional> extendRoll(@NonNull Map variables) throws ExpressionException { - return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("null", RollElement.NO_TAG, RollElement.NO_COLOR)), UniqueRandomElements.empty(), ImmutableList.of(), 10_000, true))); + public @NonNull Optional> extendRoll(@NonNull RollContext rollContext) throws ExpressionException { + return Optional.of(ImmutableList.of(new Roll(toExpression(), ImmutableList.of(new RollElement("null", RollElement.NO_TAG, RollElement.NO_COLOR)), ImmutableList.of(), ImmutableList.of(), ExpressionPosition.of(1, "t"), 10_000, true))); } @Override diff --git a/src/test/java/de/janno/evaluator/dice/random/RandomNumberSupplierTest.java b/src/test/java/de/janno/evaluator/dice/random/RandomNumberSupplierTest.java index 9f65df1..43585e0 100644 --- a/src/test/java/de/janno/evaluator/dice/random/RandomNumberSupplierTest.java +++ b/src/test/java/de/janno/evaluator/dice/random/RandomNumberSupplierTest.java @@ -1,16 +1,17 @@ package de.janno.evaluator.dice.random; +import de.janno.evaluator.dice.DieId; import de.janno.evaluator.dice.ExpressionException; import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.List; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.offset; +import static org.assertj.core.api.Assertions.*; class RandomNumberSupplierTest { + private static final DieId TEST_DIE_ID = DieId.of(0, "d", 0, 0, 0); @Test void d6Test() throws ExpressionException { @@ -19,7 +20,7 @@ void d6Test() throws ExpressionException { List res = new ArrayList<>(testSize); for (int i = 0; i < testSize; i++) { - res.add(underTest.get(0, 6)); + res.add(underTest.get(0, 6, TEST_DIE_ID)); } assertThat(res).allMatch(i -> i >= 1 && i <= 6); @@ -34,7 +35,7 @@ void from10to100Test() throws ExpressionException { List res = new ArrayList<>(testSize); for (int i = 0; i < testSize; i++) { - res.add(underTest.get(9, 100)); + res.add(underTest.get(9, 100, TEST_DIE_ID)); } assertThat(res).allMatch(i -> i >= 10 && i <= 100); @@ -49,7 +50,7 @@ void negativPositivTest() throws ExpressionException { List res = new ArrayList<>(testSize); for (int i = 0; i < testSize; i++) { - res.add(underTest.get(-4, 3)); + res.add(underTest.get(-4, 3, TEST_DIE_ID)); } assertThat(res).allMatch(i -> i >= -3 && i <= 3); @@ -64,11 +65,45 @@ void negativTest() throws ExpressionException { List res = new ArrayList<>(testSize); for (int i = 0; i < testSize; i++) { - res.add(underTest.get(-7, -1)); + res.add(underTest.get(-7, -1, TEST_DIE_ID)); } assertThat(res).allMatch(i -> i >= -6 && i <= -1); assertThat(res).containsOnly(-1, -2, -3, -4, -5, -6); assertThat(res.stream().mapToInt(i -> i).average().orElseThrow()).isEqualTo(-3.5, offset(0.01)); } + + @Test + void maxMinTest() { + RandomNumberSupplier underTest = new RandomNumberSupplier(); + + assertThatThrownBy(() -> underTest.get(Integer.MAX_VALUE, Integer.MAX_VALUE, DieId.of(1, "d", 0, 2, 0))) + .isInstanceOfAny(ExpressionException.class) + .hasMessage("Cannot give a random number for minExcl =2147483647"); + } + + @Test + void maxMaxTest() { + RandomNumberSupplier underTest = new RandomNumberSupplier(); + + assertThatThrownBy(() -> underTest.get(0, Integer.MAX_VALUE, DieId.of(1, "d", 0, 2, 0))) + .isInstanceOfAny(ExpressionException.class) + .hasMessage("Cannot give a random number for maxIncl =2147483647"); + } + + @Test + void equalTest() { + RandomNumberSupplier underTest = new RandomNumberSupplier(); + + assertThatThrownBy(() -> underTest.get(0, 0, DieId.of(1, "d", 0, 2, 0))) + .isInstanceOfAny(ExpressionException.class) + .hasMessage("Random number between 0 (excl) and 0 (incl) is not possible"); + } + + @Test + void notRandom() throws ExpressionException { + RandomNumberSupplier underTest = new RandomNumberSupplier(); + + assertThat(underTest.get(0, 1, DieId.of(1, "d", 0, 2, 0))).isEqualTo(1); + } } \ No newline at end of file diff --git a/src/test/resources/expressionsAndResults.csv b/src/test/resources/expressionsAndResults.csv index 8821df9..cf2aae9 100644 --- a/src/test/resources/expressionsAndResults.csv +++ b/src/test/resources/expressionsAndResults.csv @@ -1,935 +1,934 @@ - -'1d20'|[Roll(expression='1d20', elements=[1d20], randomElementsInRoll=, childrenRolls=[])] -'d'|[Roll(expression='d', elements=[d], randomElementsInRoll=, childrenRolls=[])] -'1d20'|[Roll(expression='1d20', elements=[1d20], randomElementsInRoll=, childrenRolls=[])] -'d'|[Roll(expression='d', elements=[d], randomElementsInRoll=, childrenRolls=[])] -'d20'|[Roll(expression='d20', elements=[d20], randomElementsInRoll=, childrenRolls=[])] -(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=))k6|[Roll(expression=(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=))k6, elements=[11, 11, 10, 10, 10, 8], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], [1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], [2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], [1∈[1...4], 3∈[1...4], 4∈[1...4], 1∈[1...4]], [4∈[1...4], 1∈[1...4], 2∈[1...4], 4∈[1...4]], [2∈[1...4], 4∈[1...4], 3∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)), elements=[10, 6, 10, 11, 8, 10, 11], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], [1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], [2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], [1∈[1...4], 3∈[1...4], 4∈[1...4], 1∈[1...4]], [4∈[1...4], 1∈[1...4], 2∈[1...4], 4∈[1...4]], [2∈[1...4], 4∈[1...4], 3∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=), elements=[10, 6, 10, 11, 8, 10], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], [1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], [2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], [1∈[1...4], 3∈[1...4], 4∈[1...4], 1∈[1...4]], [4∈[1...4], 1∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=), elements=[10, 6, 10, 11, 8], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], [1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], [2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], [1∈[1...4], 3∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=), elements=[10, 6, 10, 11], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], [1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], [2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3)=)+((4d4k3)=)+((4d4k3)=), elements=[10, 6, 10], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], [1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3)=)+((4d4k3)=), elements=[10, 6], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], [1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3)=), elements=[10], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=(((4d4k3), elements=[4, 4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=(((4d4, elements=[4, 2, 2, 4], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=(((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=((4d4k3)=), elements=[6], randomElementsInRoll=[1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=((4d4k3), elements=[3, 2, 1], randomElementsInRoll=[1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=((4d4, elements=[1, 1, 3, 2], randomElementsInRoll=[1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d4k3)=), elements=[10], randomElementsInRoll=[4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=((4d4k3), elements=[4, 4, 2], randomElementsInRoll=[4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=((4d4, elements=[4, 1, 4, 2], randomElementsInRoll=[4∈[1...4], 1∈[1...4], 4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d4k3)=), elements=[11], randomElementsInRoll=[2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], childrenRolls=[Roll(expression=((4d4k3), elements=[4, 4, 3], randomElementsInRoll=[2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], childrenRolls=[Roll(expression=((4d4, elements=[2, 4, 4, 3], randomElementsInRoll=[2∈[1...4], 4∈[1...4], 4∈[1...4], 3∈[1...4]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d4k3)=), elements=[8], randomElementsInRoll=[1∈[1...4], 3∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=((4d4k3), elements=[4, 3, 1], randomElementsInRoll=[1∈[1...4], 3∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=((4d4, elements=[1, 3, 4, 1], randomElementsInRoll=[1∈[1...4], 3∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d4k3)=), elements=[10], randomElementsInRoll=[4∈[1...4], 1∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=((4d4k3), elements=[4, 4, 2], randomElementsInRoll=[4∈[1...4], 1∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=((4d4, elements=[4, 1, 2, 4], randomElementsInRoll=[4∈[1...4], 1∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d4k3)=)), elements=[11], randomElementsInRoll=[2∈[1...4], 4∈[1...4], 3∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=((4d4k3), elements=[4, 4, 3], randomElementsInRoll=[2∈[1...4], 4∈[1...4], 3∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=((4d4, elements=[2, 4, 3, 4], randomElementsInRoll=[2∈[1...4], 4∈[1...4], 3∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=))k6|[Roll(expression=(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=))k6, elements=[13, 13, 12, 11, 10, 9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], [1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], [3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], [1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], [4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], [3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)), elements=[9, 10, 12, 11, 13, 13, 9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], [1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], [3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], [1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], [4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], [3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=), elements=[9, 10, 12, 11, 13, 13], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], [1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], [3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], [1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], [4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=), elements=[9, 10, 12, 11, 13], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], [1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], [3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], [1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=), elements=[9, 10, 12, 11], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], [1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], [3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3)=)+((4d6k3)=)+((4d6k3)=), elements=[9, 10, 12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], [1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3)=)+((4d6k3)=), elements=[9, 10], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], [1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3)=), elements=[9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(((4d6k3), elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(((4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=((4d6k3)=), elements=[10], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=((4d6k3), elements=[6, 3, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=((4d6, elements=[1, 1, 6, 3], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d6k3)=), elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=((4d6k3), elements=[6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=((4d6, elements=[2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d6k3)=), elements=[11], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=((4d6k3), elements=[4, 4, 3], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=((4d6, elements=[3, 2, 4, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d6k3)=), elements=[13], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=((4d6k3), elements=[6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=((4d6, elements=[1, 6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d6k3)=), elements=[13], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=((4d6k3), elements=[6, 4, 3], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=((4d6, elements=[4, 3, 3, 6], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=((4d6k3)=)), elements=[9], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=((4d6k3), elements=[4, 3, 2], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=((4d6, elements=[3, 2, 2, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(1-d10)|[Roll(expression=(1-d10), elements=[1, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -(1D20+5)|[Roll(expression=(1D20+5), elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5), elements=[5], randomElementsInRoll=, childrenRolls=[])])] -(1d10)d2|[Roll(expression=(1d10)d2, elements=[2, 2, 2, 1, 1, 1], randomElementsInRoll=[6∈[1...10]], [2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2], 1∈[1...2], 1∈[1...2]], childrenRolls=[Roll(expression=(1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -(1d20)|[Roll(expression=(1d20), elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])] -(1d20), (2d20), (3d20)|[Roll(expression=(1d20), elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(2d20), elements=[13, 11], randomElementsInRoll=[13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(3d20), elements=[10, 11, 15], randomElementsInRoll=[10∈[1...20], 11∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])] -(1d20+1)=|[Roll(expression=(1d20+1)=, elements=[17], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20+1), elements=[16, 1], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -(1d20+2)=|[Roll(expression=(1d20+2)=, elements=[18], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20+2), elements=[16, 2], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2), elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -(1d20+3)=|[Roll(expression=(1d20+3)=, elements=[19], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20+3), elements=[16, 3], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -(1d20+4)=|[Roll(expression=(1d20+4)=, elements=[20], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20+4), elements=[16, 4], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4), elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -(1d20+5)=|[Roll(expression=(1d20+5)=, elements=[21], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20+5), elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5), elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -(1d20+6)=|[Roll(expression=(1d20+6)=, elements=[22], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20+6), elements=[16, 6], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -(1d20-1)=|[Roll(expression=(1d20-1)=, elements=[15], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20-1), elements=[16, -1], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -(1d20-2)=|[Roll(expression=(1d20-2)=, elements=[14], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20-2), elements=[16, -2], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2), elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -(1d20-3)=|[Roll(expression=(1d20-3)=, elements=[13], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20-3), elements=[16, -3], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3), elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -(1d6)|[Roll(expression=(1d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(1d6=)*10(+1d6=)|[Roll(expression=(1d6=), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=10*(+1d6=), elements=[30], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(+1d6=), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(+1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])])])] -(1d6=)*10(1d6=)|[Roll(expression=(1d6=), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=10*(1d6=), elements=[30], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1d6=), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])])] -(2D20L1)+5|[Roll(expression=(2D20L1)+5, elements=[13, 5], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2D20L1), elements=[13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2D20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -(2D20k1)+5|[Roll(expression=(2D20k1)+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2D20k1), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2D20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -(2d20L1)|[Roll(expression=(2d20L1), elements=[13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])] -(2d20k1)|[Roll(expression=(2d20k1), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])] -(2d6)|[Roll(expression=(2d6), elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(3d20k1)|[Roll(expression=(3d20k1), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=(3d20, elements=[16, 13, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])] -(3d6)|[Roll(expression=(3d6), elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(3d6=)*10|[Roll(expression=(3d6=)*10, elements=[60], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6=), elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -(4d10-2)|[Roll(expression=(4d10-2), elements=[6, 3, 1, 10, -2], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=(4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2), elements=[2], randomElementsInRoll=, childrenRolls=[])])] -(4d6)|[Roll(expression=(4d6), elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(5d6)|[Roll(expression=(5d6), elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(6d6)|[Roll(expression=(6d6), elements=[2, 3, 1, 4, 1, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(7d6)|[Roll(expression=(7d6), elements=[2, 3, 1, 4, 1, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=(7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])] -(ifE(1d20,1,1d20)+ifE(1d20,1,1d20))k1|[Roll(expression=(ifE(1d20,1,1d20)+ifE(1d20,1,1d20))k1, elements=[16], randomElementsInRoll=[16∈[1...20]], [11∈[1...20]], childrenRolls=[Roll(expression=(ifE(1d20,1,1d20)+ifE(1d20,1,1d20)), elements=[16, 11], randomElementsInRoll=[16∈[1...20]], [11∈[1...20]], childrenRolls=[Roll(expression=(ifE(1d20,1,1d20), elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d20,1,1d20)), elements=[11], randomElementsInRoll=[11∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=|[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=, elements=[12], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3, elements=[6, 4, 2], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)), elements=[2, 4, 1, 6], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[2, 4, 1], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[2, 4], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d6,1,1d6), elements=[4], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6), elements=[1], randomElementsInRoll=[1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6)), elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=, elements=[13], randomElementsInRoll=[2∈[1...6]], [6∈[1...6]], [3∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3, elements=[6, 4, 3], randomElementsInRoll=[2∈[1...6]], [6∈[1...6]], [3∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)), elements=[2, 6, 3, 4], randomElementsInRoll=[2∈[1...6]], [6∈[1...6]], [3∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[2, 6, 3], randomElementsInRoll=[2∈[1...6]], [6∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[2, 6], randomElementsInRoll=[2∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d6,1,1d6), elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6)), elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=, elements=[16], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], [6∈[1...6]], [4∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3, elements=[6, 6, 4], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], [6∈[1...6]], [4∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)), elements=[6, 6, 4, 3], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], [6∈[1...6]], [4∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[6, 6, 4], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], [6∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[6, 6], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6), elements=[6], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d6,1,1d6), elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6), elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6)), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=, elements=[10], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [5∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3, elements=[5, 3, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [5∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)), elements=[3, 2, 2, 5], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [5∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[3, 2, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[3, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d6,1,1d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6)), elements=[5], randomElementsInRoll=[5∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=, elements=[12], randomElementsInRoll=[5∈[1...6]], [3∈[1...6]], [4∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3, elements=[5, 4, 3], randomElementsInRoll=[5∈[1...6]], [3∈[1...6]], [4∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)), elements=[5, 3, 4, 2], randomElementsInRoll=[5∈[1...6]], [3∈[1...6]], [4∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[5, 3, 4], randomElementsInRoll=[5∈[1...6]], [3∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[5, 3], randomElementsInRoll=[5∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6), elements=[5], randomElementsInRoll=[5∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d6,1,1d6), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6), elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6)), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=, elements=[7], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [1∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3, elements=[3, 2, 2], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [1∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)), elements=[2, 1, 3, 2], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [1∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[2, 1, 3], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [1∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6)+ifE(1d6,1,1d6), elements=[2, 1], randomElementsInRoll=[2∈[1...6]], [1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(ifE(1d6,1,1d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d6,1,1d6), elements=[1], randomElementsInRoll=[1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=ifE(1d6,1,1d6)), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -+ 1|[Roll(expression=+1, elements=[1], randomElementsInRoll=, childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -+ 10|[Roll(expression=+10, elements=[10], randomElementsInRoll=, childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -+ 2|[Roll(expression=+2, elements=[2], randomElementsInRoll=, childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -+ 3|[Roll(expression=+3, elements=[3], randomElementsInRoll=, childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -+ 4|[Roll(expression=+4, elements=[4], randomElementsInRoll=, childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -+ 5|[Roll(expression=+5, elements=[5], randomElementsInRoll=, childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -+ 6|[Roll(expression=+6, elements=[6], randomElementsInRoll=, childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -+ 7|[Roll(expression=+7, elements=[7], randomElementsInRoll=, childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -+ 8|[Roll(expression=+8, elements=[8], randomElementsInRoll=, childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -+ 9|[Roll(expression=+9, elements=[9], randomElementsInRoll=, childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])] -+(3d6k2)|[Roll(expression=+(3d6k2), elements=[3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6k2), elements=[3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2), elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -+(3d6l2)|[Roll(expression=+(3d6l2), elements=[1, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6l2), elements=[1, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2), elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -+1|[Roll(expression=+1, elements=[1], randomElementsInRoll=, childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -+100|[Roll(expression=+100, elements=[100], randomElementsInRoll=, childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -+1d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll(expression=+1d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=1d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△', elements=[ ●, △, ⧼, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△', elements=[ ●, △, ⧼, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼', elements=[ ●, △, ⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △', elements=[ ●, △], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●', elements=[ ●], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' △', elements=[ △], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼', elements=[ ⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼'), elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])])])])] -+1d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll(expression=+1d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=1d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△', elements=[ ●△, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△', elements=[ ●△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△', elements=[ ●△], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼', elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼⧼△', elements=[ ⧼⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼△△'), elements=[ ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[])])])])] -+1d10|[Roll(expression=+1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -+1d100|[Roll(expression=+1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])])] -+1d12|[Roll(expression=+1d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -+1d20|[Roll(expression=+1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -+1d3|[Roll(expression=+1d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -+1d4|[Roll(expression=+1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -+1d6|[Roll(expression=+1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -+1d8|[Roll(expression=+1d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -+2|[Roll(expression=+2, elements=[2], randomElementsInRoll=, childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -+2d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll(expression=+2d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=2d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△', elements=[ ●, △, ⧼, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△', elements=[ ●, △, ⧼, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼', elements=[ ●, △, ⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △', elements=[ ●, △], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●', elements=[ ●], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' △', elements=[ △], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼', elements=[ ⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼'), elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])])])])] -+2d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll(expression=+2d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△, ⧼△], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=2d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△, ⧼△], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△', elements=[ ●△, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△', elements=[ ●△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△', elements=[ ●△], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼', elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼⧼△', elements=[ ⧼⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼△△'), elements=[ ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[])])])])] -+2d10|[Roll(expression=+2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -+2d12|[Roll(expression=+2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -+2d20|[Roll(expression=+2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -+2d3k1|[Roll(expression=+2d3k1, elements=[3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=+2d3, elements=[2, 3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[2, 3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -+2d4|[Roll(expression=+2d4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2d4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -+2d6|[Roll(expression=+2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -+2d8|[Roll(expression=+2d8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2d8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -+3|[Roll(expression=+3, elements=[3], randomElementsInRoll=, childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -+3D6|[Roll(expression=+3D6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3D6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -+3d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll(expression=+3d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=3d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△', elements=[ ●, △, ⧼, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△', elements=[ ●, △, ⧼, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼', elements=[ ●, △, ⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △', elements=[ ●, △], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●', elements=[ ●], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' △', elements=[ △], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼', elements=[ ⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼'), elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])])])])] -+3d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll(expression=+3d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△, ⧼△, ●△], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ●△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=3d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△, ⧼△, ●△], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ●△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△', elements=[ ●△, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△', elements=[ ●△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△', elements=[ ●△], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼', elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼⧼△', elements=[ ⧼⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼△△'), elements=[ ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[])])])])] -+3d3k1|[Roll(expression=+3d3k1, elements=[3], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=+3d3, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=3d3, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -+4D6|[Roll(expression=+4D6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4D6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -+4d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll(expression=+4d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●, ⧼△], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=4d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●, ⧼△], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△', elements=[ ●, △, ⧼, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△', elements=[ ●, △, ⧼, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼', elements=[ ●, △, ⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △', elements=[ ●, △], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●', elements=[ ●], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' △', elements=[ △], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼', elements=[ ⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼'), elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])])])])] -+4d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll(expression=+4d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△, ⧼△, ●△, ●⧼⧼], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ●△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ●⧼⧼∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=4d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ⧼△, ⧼△, ●△, ●⧼⧼], randomElementsInRoll=[ ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ●△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], ●⧼⧼∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△'), elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼', elements=[ ●△, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△'+' ⧼△', elements=[ ●△, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△'+' ⧼△', elements=[ ●△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●△', elements=[ ●△], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼', elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼⧼△', elements=[ ⧼⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼△△'), elements=[ ●⧼⧼△△], randomElementsInRoll=, childrenRolls=[])])])])] -+4d3k1|[Roll(expression=+4d3k1, elements=[3], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=+4d3, elements=[2, 3, 1, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=4d3, elements=[2, 3, 1, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -+5d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll(expression=+5d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●, ⧼△, ●], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=5d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●, ⧼△, ●], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△', elements=[ ●, △, ⧼, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△', elements=[ ●, △, ⧼, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼', elements=[ ●, △, ⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △', elements=[ ●, △], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●', elements=[ ●], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' △', elements=[ △], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼', elements=[ ⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼'), elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])])])])] -+5d10|[Roll(expression=+5d10, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5d10, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -+5d12|[Roll(expression=+5d12, elements=[8, 9, 7, 10, 7], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=5d12, elements=[8, 9, 7, 10, 7], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -+5d20|[Roll(expression=+5d20, elements=[16, 13, 11, 10, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=5d20, elements=[16, 13, 11, 10, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -+5d4|[Roll(expression=+5d4, elements=[4, 2, 2, 4, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=5d4, elements=[4, 2, 2, 4, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -+5d6|[Roll(expression=+5d6, elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5d6, elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -+5d8|[Roll(expression=+5d8, elements=[8, 2, 6, 4, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=5d8, elements=[8, 2, 6, 4, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -+6d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll(expression=+6d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●, ⧼△, ●, ●], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=6d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ △, ⧼, ●, ⧼△, ●, ●], randomElementsInRoll=[ △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼'), elements=[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△', elements=[ ●, △, ⧼, ⧼△, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼'+' ⧼△', elements=[ ●, △, ⧼, ⧼△], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △'+' ⧼', elements=[ ●, △, ⧼], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●'+' △', elements=[ ●, △], randomElementsInRoll=, childrenRolls=[Roll(expression=(' ●', elements=[ ●], randomElementsInRoll=, childrenRolls=[]), Roll(expression=' △', elements=[ △], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼', elements=[ ⧼], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ⧼△', elements=[ ⧼△], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=' ●⧼⧼'), elements=[ ●⧼⧼], randomElementsInRoll=, childrenRolls=[])])])])] -+7|[Roll(expression=+7, elements=[7], randomElementsInRoll=, childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] --1|[Roll(expression=-1, elements=[-1], randomElementsInRoll=, childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] --1d10+1|[Roll(expression=-1d10+1, elements=[-6, 1], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=-1d10, elements=[-6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] --1d3|[Roll(expression=-1d3, elements=[-2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] --1d6|[Roll(expression=-1d6, elements=[-2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] --2d3k1|[Roll(expression=-2d3k1, elements=[-2], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=-2d3, elements=[-2, -3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[2, 3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] --3d3k1|[Roll(expression=-3d3k1, elements=[-1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=-3d3, elements=[-2, -3, -1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=3d3, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] --4d3k1|[Roll(expression=-4d3k1, elements=[-1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=-4d3, elements=[-2, -3, -1, -1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=4d3, elements=[2, 3, 1, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] --5|[Roll(expression=-5, elements=[-5], randomElementsInRoll=, childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -0|[Roll(expression=0, elements=[0], randomElementsInRoll=, childrenRolls=[])] -0 + 100|[Roll(expression=0+100, elements=[0, 100], randomElementsInRoll=, childrenRolls=[Roll(expression=0, elements=[0], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -0d36|[Roll(expression=0d36, elements=[], randomElementsInRoll=, childrenRolls=[Roll(expression=0, elements=[0], randomElementsInRoll=, childrenRolls=[]), Roll(expression=36, elements=[36], randomElementsInRoll=, childrenRolls=[])])] -1|[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])] -1 100|[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])] -1 2 3|[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])] -1 d2|[Roll(expression=1d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -1 d20|[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -1 d30|[Roll(expression=1d30, elements=[26], randomElementsInRoll=[26∈[1...30]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=30, elements=[30], randomElementsInRoll=, childrenRolls=[])])] -1 d5|[Roll(expression=1d5, elements=[1], randomElementsInRoll=[1∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1+6|[Roll(expression=1+6, elements=[1, 6], randomElementsInRoll=, childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1-(1d10)|[Roll(expression=1-(1d10), elements=[1, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1-(1d10)=|[Roll(expression=1-(1d10)=, elements=[-5], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1-(1d10), elements=[1, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1-10|[Roll(expression=1-10, elements=[1, -10], randomElementsInRoll=, childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -1-100|[Roll(expression=1-100, elements=[1, -100], randomElementsInRoll=, childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -1-1d10|[Roll(expression=1-1d10, elements=[1, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1-1d104|[Roll(expression=1-1d104, elements=[1, -32], randomElementsInRoll=[32∈[1...104]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d104, elements=[32], randomElementsInRoll=[32∈[1...104]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=104, elements=[104], randomElementsInRoll=, childrenRolls=[])])])] -1-d10|[Roll(expression=1-d10, elements=[1, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -10|[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])] -100|[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])] -100 d20|[Roll(expression=100d20, elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1, 6, 13, 15, 20, 8, 16, 19, 4, 4, 13, 20, 11, 7, 14, 3, 18, 10, 14, 20, 9, 5, 8, 7, 14, 9, 3, 12, 8, 6, 11, 20, 9, 11, 1, 11, 9, 6, 8, 14, 19, 3, 20, 18, 2, 2, 12, 6, 19, 18, 16, 15, 5, 18, 20, 18, 16, 11, 20, 5, 18, 15, 18, 6, 11, 17, 10, 16, 16, 18, 10, 19, 9, 9, 8, 1, 5, 10, 9, 20, 17, 20, 11, 4, 2, 14, 13, 3, 4, 1, 12], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20], 6∈[1...20], 13∈[1...20], 15∈[1...20], 20∈[1...20], 8∈[1...20], 16∈[1...20], 19∈[1...20], 4∈[1...20], 4∈[1...20], 13∈[1...20], 20∈[1...20], 11∈[1...20], 7∈[1...20], 14∈[1...20], 3∈[1...20], 18∈[1...20], 10∈[1...20], 14∈[1...20], 20∈[1...20], 9∈[1...20], 5∈[1...20], 8∈[1...20], 7∈[1...20], 14∈[1...20], 9∈[1...20], 3∈[1...20], 12∈[1...20], 8∈[1...20], 6∈[1...20], 11∈[1...20], 20∈[1...20], 9∈[1...20], 11∈[1...20], 1∈[1...20], 11∈[1...20], 9∈[1...20], 6∈[1...20], 8∈[1...20], 14∈[1...20], 19∈[1...20], 3∈[1...20], 20∈[1...20], 18∈[1...20], 2∈[1...20], 2∈[1...20], 12∈[1...20], 6∈[1...20], 19∈[1...20], 18∈[1...20], 16∈[1...20], 15∈[1...20], 5∈[1...20], 18∈[1...20], 20∈[1...20], 18∈[1...20], 16∈[1...20], 11∈[1...20], 20∈[1...20], 5∈[1...20], 18∈[1...20], 15∈[1...20], 18∈[1...20], 6∈[1...20], 11∈[1...20], 17∈[1...20], 10∈[1...20], 16∈[1...20], 16∈[1...20], 18∈[1...20], 10∈[1...20], 19∈[1...20], 9∈[1...20], 9∈[1...20], 8∈[1...20], 1∈[1...20], 5∈[1...20], 10∈[1...20], 9∈[1...20], 20∈[1...20], 17∈[1...20], 20∈[1...20], 11∈[1...20], 4∈[1...20], 2∈[1...20], 14∈[1...20], 13∈[1...20], 3∈[1...20], 4∈[1...20], 1∈[1...20], 12∈[1...20]], childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -10d10|[Roll(expression=10d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -10d10+13d10=|[Roll(expression=10d10+13d10=, elements=[132], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10]], [6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10], 4∈[1...10], 3∈[1...10], 10∈[1...10], 1∈[1...10], 7∈[1...10]], childrenRolls=[Roll(expression=10d10+13d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3, 5, 10, 8, 6, 9, 4, 4, 3, 10, 1, 7], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10]], [6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10], 4∈[1...10], 3∈[1...10], 10∈[1...10], 1∈[1...10], 7∈[1...10]], childrenRolls=[Roll(expression=10d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=13d10, elements=[6, 3, 5, 10, 8, 6, 9, 4, 4, 3, 10, 1, 7], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10], 4∈[1...10], 3∈[1...10], 10∈[1...10], 1∈[1...10], 7∈[1...10]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -10d100|[Roll(expression=10d100, elements=[96, 73, 51, 30, 51, 55, 60, 29, 100, 41], randomElementsInRoll=[96∈[1...100], 73∈[1...100], 51∈[1...100], 30∈[1...100], 51∈[1...100], 55∈[1...100], 60∈[1...100], 29∈[1...100], 100∈[1...100], 41∈[1...100]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -10d10>6|[Roll(expression=10d10>6, elements=[10, 10, 9, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=10d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -10d12=|[Roll(expression=10d12=, elements=[86], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12], 8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=10d12, elements=[8, 9, 7, 10, 7, 7, 12, 9, 8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12], 8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -10d20|[Roll(expression=10d20, elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -10d20=|[Roll(expression=10d20=, elements=[126], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20]], childrenRolls=[Roll(expression=10d20, elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -10d2=|[Roll(expression=10d2=, elements=[16], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2], 1∈[1...2], 1∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2]], childrenRolls=[Roll(expression=10d2, elements=[2, 2, 2, 2, 1, 1, 1, 2, 2, 1], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2], 1∈[1...2], 1∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -10d4|[Roll(expression=10d4, elements=[4, 2, 2, 4, 1, 1, 3, 2, 4, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -10d4+13d10=|[Roll(expression=10d4+13d10=, elements=[100], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], [6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10], 4∈[1...10], 3∈[1...10], 10∈[1...10], 1∈[1...10], 7∈[1...10]], childrenRolls=[Roll(expression=10d4+13d10, elements=[4, 2, 2, 4, 1, 1, 3, 2, 4, 1, 6, 3, 5, 10, 8, 6, 9, 4, 4, 3, 10, 1, 7], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], [6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10], 4∈[1...10], 3∈[1...10], 10∈[1...10], 1∈[1...10], 7∈[1...10]], childrenRolls=[Roll(expression=10d4, elements=[4, 2, 2, 4, 1, 1, 3, 2, 4, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=13d10, elements=[6, 3, 5, 10, 8, 6, 9, 4, 4, 3, 10, 1, 7], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10], 4∈[1...10], 3∈[1...10], 10∈[1...10], 1∈[1...10], 7∈[1...10]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -10d4=|[Roll(expression=10d4=, elements=[24], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=10d4, elements=[4, 2, 2, 4, 1, 1, 3, 2, 4, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -10d6|[Roll(expression=10d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -10d6=|[Roll(expression=10d6=, elements=[26], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=10d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -10d6>4|[Roll(expression=10d6>4, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=10d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -10d8|[Roll(expression=10d8, elements=[8, 2, 6, 4, 5, 5, 7, 2, 8, 1], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8], 8∈[1...8], 1∈[1...8]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -111|[Roll(expression=111, elements=[111], randomElementsInRoll=, childrenRolls=[])] -11d10|[Roll(expression=11d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -11d10>6|[Roll(expression=11d10>6, elements=[10, 10, 9, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=11d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -11d6|[Roll(expression=11d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -11d6>4|[Roll(expression=11d6>4, elements=[6, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=11d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -12|[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])] -12d10|[Roll(expression=12d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -12d10>6|[Roll(expression=12d10>6, elements=[10, 10, 9, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=12d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -12d6|[Roll(expression=12d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -12d6>4|[Roll(expression=12d6>4, elements=[6, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=12d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -12d7|[Roll(expression=12d7, elements=[2, 2, 2, 6, 1, 6, 3, 1, 3, 2, 2, 2], randomElementsInRoll=[2∈[1...7], 2∈[1...7], 2∈[1...7], 6∈[1...7], 1∈[1...7], 6∈[1...7], 3∈[1...7], 1∈[1...7], 3∈[1...7], 2∈[1...7], 2∈[1...7], 2∈[1...7]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -13d10|[Roll(expression=13d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -13d10>6|[Roll(expression=13d10>6, elements=[10, 10, 9, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=13d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -13d12=|[Roll(expression=13d12=, elements=[104], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12], 8∈[1...12], 9∈[1...12], 6∈[1...12], 9∈[1...12], 3∈[1...12]], childrenRolls=[Roll(expression=13d12, elements=[8, 9, 7, 10, 7, 7, 12, 9, 8, 9, 6, 9, 3], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12], 8∈[1...12], 9∈[1...12], 6∈[1...12], 9∈[1...12], 3∈[1...12]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -13d20=|[Roll(expression=13d20=, elements=[160], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20], 6∈[1...20], 13∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=13d20, elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1, 6, 13, 15], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20], 6∈[1...20], 13∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -13d6|[Roll(expression=13d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -13d6>4|[Roll(expression=13d6>4, elements=[6, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=13d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -14d10|[Roll(expression=14d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3, 5, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -14d10>6|[Roll(expression=14d10>6, elements=[10, 10, 9, 10, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=14d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3, 5, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -14d6|[Roll(expression=14d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -14d6>4|[Roll(expression=14d6>4, elements=[6, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=14d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -15d12=|[Roll(expression=15d12=, elements=[116], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12], 8∈[1...12], 9∈[1...12], 6∈[1...12], 9∈[1...12], 3∈[1...12], 8∈[1...12], 4∈[1...12]], childrenRolls=[Roll(expression=15d12, elements=[8, 9, 7, 10, 7, 7, 12, 9, 8, 9, 6, 9, 3, 8, 4], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12], 8∈[1...12], 9∈[1...12], 6∈[1...12], 9∈[1...12], 3∈[1...12], 8∈[1...12], 4∈[1...12]], childrenRolls=[Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -15d20=|[Roll(expression=15d20=, elements=[188], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20], 6∈[1...20], 13∈[1...20], 15∈[1...20], 20∈[1...20], 8∈[1...20]], childrenRolls=[Roll(expression=15d20, elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1, 6, 13, 15, 20, 8], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20], 6∈[1...20], 13∈[1...20], 15∈[1...20], 20∈[1...20], 8∈[1...20]], childrenRolls=[Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -15d6|[Roll(expression=15d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -15d6>4|[Roll(expression=15d6>4, elements=[6, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=15d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -15d8|[Roll(expression=15d8, elements=[8, 2, 6, 4, 5, 5, 7, 2, 8, 1, 4, 2, 6, 8, 8], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8], 8∈[1...8], 1∈[1...8], 4∈[1...8], 2∈[1...8], 6∈[1...8], 8∈[1...8], 8∈[1...8]], childrenRolls=[Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -16d6|[Roll(expression=16d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -17|[Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])] -17d6|[Roll(expression=17d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -18d6|[Roll(expression=18d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -19d6|[Roll(expression=19d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6], 1∈[1...6], 6∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=19, elements=[19], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1D10|[Roll(expression=1D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -1D100|[Roll(expression=1D100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -1D100 + 1D10|[Roll(expression=1D100+1D10, elements=[96, 3], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1D100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1D10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1D12|[Roll(expression=1D12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -1D12 +1D6|[Roll(expression=1D12+1D6, elements=[8, 3], randomElementsInRoll=[8∈[1...12]], [3∈[1...6]], childrenRolls=[Roll(expression=1D12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1D6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1D12+2D6|[Roll(expression=1D12+2D6, elements=[8, 3, 1], randomElementsInRoll=[8∈[1...12]], [3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=1D12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2D6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1D12+3D 6|[Roll(expression=1D12+3D6, elements=[8, 3, 1, 4], randomElementsInRoll=[8∈[1...12]], [3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=1D12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3D6, elements=[3, 1, 4], randomElementsInRoll=[3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1D20|[Roll(expression=1D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -1D20+5|[Roll(expression=1D20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1D20+5=|[Roll(expression=1D20+5=, elements=[21], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1D20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -1D200|[Roll(expression=1D200, elements=[96], randomElementsInRoll=[96∈[1...200]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=200, elements=[200], randomElementsInRoll=, childrenRolls=[])])] -1D3|[Roll(expression=1D3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -1D4|[Roll(expression=1D4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -1D6|[Roll(expression=1D6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1D6+2|[Roll(expression=1D6+2, elements=[2, 2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1D6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -1D6+3|[Roll(expression=1D6+3, elements=[2, 3], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1D6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -1D6, 3D6|[Roll(expression=1D6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3D6, elements=[3, 1, 4], randomElementsInRoll=[3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1D6,2D6,3D6,4D6|[Roll(expression=1D6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2D6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3D6, elements=[4, 1, 1], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4D6, elements=[6, 3, 2, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1D6=|[Roll(expression=1D6=, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1D6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1D7|[Roll(expression=1D7, elements=[2], randomElementsInRoll=[2∈[1...7]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -1D8|[Roll(expression=1D8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -1D[Head/Tail]|[Roll(expression=1D[Head/Tail], elements=[Tail], randomElementsInRoll=[Tail∈[Head, Tail]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Head/Tail], elements=[Head, Tail], randomElementsInRoll=, childrenRolls=[])])] -1X100|[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])] -1d 20|[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -1d!!10|[Roll(expression=1d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -1d!!100|[Roll(expression=1d!!100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -1d!10|[Roll(expression=1d!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -1d!100|[Roll(expression=1d!100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -1d!6|[Roll(expression=1d!6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d('👍 ' + '👎 ')|[Roll(expression=1d('👍 '+'👎 '), elements=[👎 ], randomElementsInRoll=[👎 ∈[👍 , 👎 ]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=('👍 '+'👎 '), elements=[👍 , 👎 ], randomElementsInRoll=, childrenRolls=[Roll(expression=('👍 ', elements=[👍 ], randomElementsInRoll=, childrenRolls=[]), Roll(expression='👎 '), elements=[👎 ], randomElementsInRoll=, childrenRolls=[])])])] -1d0|[Roll(expression=1d0, elements=[], randomElementsInRoll=, childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=0, elements=[0], randomElementsInRoll=, childrenRolls=[])])] -1d1|[Roll(expression=1d1, elements=[1], randomElementsInRoll=[1∈[1...1]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -1d10|[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -1d10 + 1d10|[Roll(expression=1d10+1d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d10 - 1d10|[Roll(expression=1d10-1d10, elements=[6, -3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d10+1d10|[Roll(expression=1d10+1d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d10+1d2|[Roll(expression=1d10+1d2, elements=[6, 2], randomElementsInRoll=[6∈[1...10]], [2∈[1...2]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -1d10+1d4|[Roll(expression=1d10+1d4, elements=[6, 2], randomElementsInRoll=[6∈[1...10]], [2∈[1...4]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d4, elements=[2], randomElementsInRoll=[2∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -1d10+1d5|[Roll(expression=1d10+1d5, elements=[6, 3], randomElementsInRoll=[6∈[1...10]], [3∈[1...5]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d5, elements=[3], randomElementsInRoll=[3∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -1d10+1d5 =|[Roll(expression=1d10+1d5=, elements=[9], randomElementsInRoll=[6∈[1...10]], [3∈[1...5]], childrenRolls=[Roll(expression=1d10+1d5, elements=[6, 3], randomElementsInRoll=[6∈[1...10]], [3∈[1...5]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d5, elements=[3], randomElementsInRoll=[3∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -1d10+1d5=|[Roll(expression=1d10+1d5=, elements=[9], randomElementsInRoll=[6∈[1...10]], [3∈[1...5]], childrenRolls=[Roll(expression=1d10+1d5, elements=[6, 3], randomElementsInRoll=[6∈[1...10]], [3∈[1...5]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d5, elements=[3], randomElementsInRoll=[3∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -1d10+1d6|[Roll(expression=1d10+1d6, elements=[6, 3], randomElementsInRoll=[6∈[1...10]], [3∈[1...6]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d10+1d8|[Roll(expression=1d10+1d8, elements=[6, 2], randomElementsInRoll=[6∈[1...10]], [2∈[1...8]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d8, elements=[2], randomElementsInRoll=[2∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -1d10+2=|[Roll(expression=1d10+2=, elements=[8], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10+2, elements=[6, 2], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -1d10+4=|[Roll(expression=1d10+4=, elements=[10], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10+4, elements=[6, 4], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -1d10+5|[Roll(expression=1d10+5, elements=[6, 5], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1d10+6=|[Roll(expression=1d10+6=, elements=[12], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10+6, elements=[6, 6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d10+8=|[Roll(expression=1d10+8=, elements=[14], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10+8, elements=[6, 8], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -1d10, 2d10, 3d10|[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d10, elements=[3, 1], randomElementsInRoll=[3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d10, elements=[10, 1, 5], randomElementsInRoll=[10∈[1...10], 1∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -1d10-1d10|[Roll(expression=1d10-1d10, elements=[6, -3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100|[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -1d100 + 1d10|[Roll(expression=1d100+1d10, elements=[96, 3], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100+1d10|[Roll(expression=1d100+1d10, elements=[96, 3], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100+1d10=|[Roll(expression=1d100+1d10=, elements=[99], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1d100+1d10, elements=[96, 3], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d100+2d10|[Roll(expression=1d100+2d10, elements=[96, 3, 1], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d10, elements=[3, 1], randomElementsInRoll=[3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100+2d10=|[Roll(expression=1d100+2d10=, elements=[100], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=1d100+2d10, elements=[96, 3, 1], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d10, elements=[3, 1], randomElementsInRoll=[3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d100+3d10|[Roll(expression=1d100+3d10, elements=[96, 3, 1, 10], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d10, elements=[3, 1, 10], randomElementsInRoll=[3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100+3d10=|[Roll(expression=1d100+3d10=, elements=[110], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=1d100+3d10, elements=[96, 3, 1, 10], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d10, elements=[3, 1, 10], randomElementsInRoll=[3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d100-1d10|[Roll(expression=1d100-1d10, elements=[96, -3], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100-1d10=|[Roll(expression=1d100-1d10=, elements=[93], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1d100-1d10, elements=[96, -3], randomElementsInRoll=[96∈[1...100]], [3∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d100-2d10|[Roll(expression=1d100-2d10, elements=[96, -3, -1], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d10, elements=[3, 1], randomElementsInRoll=[3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100-2d10=|[Roll(expression=1d100-2d10=, elements=[92], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=1d100-2d10, elements=[96, -3, -1], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d10, elements=[3, 1], randomElementsInRoll=[3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d100-3d10|[Roll(expression=1d100-3d10, elements=[96, -3, -1, -10], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d10, elements=[3, 1, 10], randomElementsInRoll=[3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d100-3d10=|[Roll(expression=1d100-3d10=, elements=[82], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=1d100-3d10, elements=[96, -3, -1, -10], randomElementsInRoll=[96∈[1...100]], [3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=1d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d10, elements=[3, 1, 10], randomElementsInRoll=[3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d1000|[Roll(expression=1d1000, elements=[96], randomElementsInRoll=[96∈[1...1000]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1000, elements=[1000], randomElementsInRoll=, childrenRolls=[])])] -1d10000|[Roll(expression=1d10000, elements=[96], randomElementsInRoll=[96∈[1...10000]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10000, elements=[10000], randomElementsInRoll=, childrenRolls=[])])] -1d10=|[Roll(expression=1d10=, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d10>6|[Roll(expression=1d10>6, elements=[], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d11|[Roll(expression=1d11, elements=[4], randomElementsInRoll=[4∈[1...11]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[])])] -1d112|[Roll(expression=1d112, elements=[16], randomElementsInRoll=[16∈[1...112]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=112, elements=[112], randomElementsInRoll=, childrenRolls=[])])] -1d12|[Roll(expression=1d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -1d12+1=|[Roll(expression=1d12+1=, elements=[9], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1d12+1, elements=[8, 1], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -1d12+1d6|[Roll(expression=1d12+1d6, elements=[8, 3], randomElementsInRoll=[8∈[1...12]], [3∈[1...6]], childrenRolls=[Roll(expression=1d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d12+1d6=|[Roll(expression=1d12+1d6=, elements=[11], randomElementsInRoll=[8∈[1...12]], [3∈[1...6]], childrenRolls=[Roll(expression=1d12+1d6, elements=[8, 3], randomElementsInRoll=[8∈[1...12]], [3∈[1...6]], childrenRolls=[Roll(expression=1d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])])] -1d126|[Roll(expression=1d126, elements=[86], randomElementsInRoll=[86∈[1...126]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=126, elements=[126], randomElementsInRoll=, childrenRolls=[])])] -1d12=|[Roll(expression=1d12=, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -1d13|[Roll(expression=1d13, elements=[6], randomElementsInRoll=[6∈[1...13]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[])])] -1d14|[Roll(expression=1d14, elements=[2], randomElementsInRoll=[2∈[1...14]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[])])] -1d15|[Roll(expression=1d15, elements=[11], randomElementsInRoll=[11∈[1...15]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[])])] -1d15000|[Roll(expression=1d15000, elements=[5096], randomElementsInRoll=[5096∈[1...15000]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=15000, elements=[15000], randomElementsInRoll=, childrenRolls=[])])] -1d16|[Roll(expression=1d16, elements=[16], randomElementsInRoll=[16∈[1...16]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -1d17|[Roll(expression=1d17, elements=[2], randomElementsInRoll=[2∈[1...17]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])])] -1d18|[Roll(expression=1d18, elements=[14], randomElementsInRoll=[14∈[1...18]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -1d19|[Roll(expression=1d19, elements=[18], randomElementsInRoll=[18∈[1...19]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=19, elements=[19], randomElementsInRoll=, childrenRolls=[])])] -1d2|[Roll(expression=1d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -1d2('👍 ' + '👎 ')|[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2d('👍 '+'👎 '), elements=[👎 , 👎 ], randomElementsInRoll=[👎 ∈[👍 , 👎 ], 👎 ∈[👍 , 👎 ]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=('👍 '+'👎 '), elements=[👍 , 👎 ], randomElementsInRoll=, childrenRolls=[Roll(expression=('👍 ', elements=[👍 ], randomElementsInRoll=, childrenRolls=[]), Roll(expression='👎 '), elements=[👎 ], randomElementsInRoll=, childrenRolls=[])])])] -1d2+1=|[Roll(expression=1d2+1=, elements=[3], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1d2+1, elements=[2, 1], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -1d20|[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -1d20+0=|[Roll(expression=1d20+0=, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+0, elements=[16, 0], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=0, elements=[0], randomElementsInRoll=, childrenRolls=[])])])] -1d20+1|[Roll(expression=1d20+1, elements=[16, 1], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -1d20+10=|[Roll(expression=1d20+10=, elements=[26], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+10, elements=[16, 10], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d20+11=|[Roll(expression=1d20+11=, elements=[27], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+11, elements=[16, 11], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[])])])] -1d20+12|[Roll(expression=1d20+12, elements=[16, 12], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -1d20+18|[Roll(expression=1d20+18, elements=[16, 18], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -1d20+18=|[Roll(expression=1d20+18=, elements=[34], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+18, elements=[16, 18], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])])] -1d20+2|[Roll(expression=1d20+2, elements=[16, 2], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -1d20+20=|[Roll(expression=1d20+20=, elements=[36], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+20, elements=[16, 20], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -1d20+2=|[Roll(expression=1d20+2=, elements=[18], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+2, elements=[16, 2], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -1d20+3|[Roll(expression=1d20+3, elements=[16, 3], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -1d20+4|[Roll(expression=1d20+4, elements=[16, 4], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -1d20+4=|[Roll(expression=1d20+4=, elements=[20], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+4, elements=[16, 4], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -1d20+5|[Roll(expression=1d20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1d20+5=|[Roll(expression=1d20+5=, elements=[21], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -1d20+6|[Roll(expression=1d20+6, elements=[16, 6], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d20+6=|[Roll(expression=1d20+6=, elements=[22], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+6, elements=[16, 6], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d20+7=|[Roll(expression=1d20+7=, elements=[23], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+7, elements=[16, 7], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])])] -1d20+8|[Roll(expression=1d20+8, elements=[16, 8], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -1d20+8=|[Roll(expression=1d20+8=, elements=[24], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+8, elements=[16, 8], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -1d20+9=|[Roll(expression=1d20+9=, elements=[25], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20+9, elements=[16, 9], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])])] -1d20, 2d20, 3d20|[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d20, elements=[13, 11], randomElementsInRoll=[13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d20, elements=[10, 11, 15], randomElementsInRoll=[10∈[1...20], 11∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -1d20,3d6|[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[3, 1, 4], randomElementsInRoll=[3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d20-1|[Roll(expression=1d20-1, elements=[16, -1], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -1d20-2|[Roll(expression=1d20-2, elements=[16, -2], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -1d20-3|[Roll(expression=1d20-3, elements=[16, -3], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -1d20-5=|[Roll(expression=1d20-5=, elements=[11], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20-5, elements=[16, -5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -1d200|[Roll(expression=1d200, elements=[96], randomElementsInRoll=[96∈[1...200]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=200, elements=[200], randomElementsInRoll=, childrenRolls=[])])] -1d20=|[Roll(expression=1d20=, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -1d20k15|[Roll(expression=1d20k15, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[])])] -1d20k18|[Roll(expression=1d20k18, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -1d21|[Roll(expression=1d21, elements=[2], randomElementsInRoll=[2∈[1...21]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=21, elements=[21], randomElementsInRoll=, childrenRolls=[])])] -1d22|[Roll(expression=1d22, elements=[4], randomElementsInRoll=[4∈[1...22]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=22, elements=[22], randomElementsInRoll=, childrenRolls=[])])] -1d23|[Roll(expression=1d23, elements=[22], randomElementsInRoll=[22∈[1...23]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=23, elements=[23], randomElementsInRoll=, childrenRolls=[])])] -1d24|[Roll(expression=1d24, elements=[8], randomElementsInRoll=[8∈[1...24]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=24, elements=[24], randomElementsInRoll=, childrenRolls=[])])] -1d25|[Roll(expression=1d25, elements=[21], randomElementsInRoll=[21∈[1...25]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=25, elements=[25], randomElementsInRoll=, childrenRolls=[])])] -1d25+5|[Roll(expression=1d25+5, elements=[21, 5], randomElementsInRoll=[21∈[1...25]], childrenRolls=[Roll(expression=1d25, elements=[21], randomElementsInRoll=[21∈[1...25]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=25, elements=[25], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1d26|[Roll(expression=1d26, elements=[6], randomElementsInRoll=[6∈[1...26]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=26, elements=[26], randomElementsInRoll=, childrenRolls=[])])] -1d2=|[Roll(expression=1d2=, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -1d3|[Roll(expression=1d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -1d3+1=|[Roll(expression=1d3+1=, elements=[3], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1d3+1, elements=[2, 1], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -1d3, 1d4|[Roll(expression=1d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d4, elements=[2], randomElementsInRoll=[2∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -1d30|[Roll(expression=1d30, elements=[26], randomElementsInRoll=[26∈[1...30]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=30, elements=[30], randomElementsInRoll=, childrenRolls=[])])] -1d37|[Roll(expression=1d37, elements=[23], randomElementsInRoll=[23∈[1...37]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=37, elements=[37], randomElementsInRoll=, childrenRolls=[])])] -1d3d6|[Roll(expression=1d3d6, elements=[3, 1], randomElementsInRoll=[2∈[1...3]], [3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=1d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d4|[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -1d4 + 1|[Roll(expression=1d4+1, elements=[4, 1], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -1d4 + 1=|[Roll(expression=1d4+1=, elements=[5], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4+1, elements=[4, 1], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -1d4 + 1d6|[Roll(expression=1d4+1d6, elements=[4, 3], randomElementsInRoll=[4∈[1...4]], [3∈[1...6]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d4 , 1d6|[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d4+(1d20/10)|[Roll(expression=1d4+(1d20/10), elements=[4, 1], randomElementsInRoll=[4∈[1...4]], [13∈[1...20]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(1d20/10), elements=[1], randomElementsInRoll=[13∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[13], randomElementsInRoll=[13∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d4+1|[Roll(expression=1d4+1, elements=[4, 1], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -1d4+12|[Roll(expression=1d4+12, elements=[4, 12], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -1d4+15|[Roll(expression=1d4+15, elements=[4, 15], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[])])] -1d4+1d6|[Roll(expression=1d4+1d6, elements=[4, 3], randomElementsInRoll=[4∈[1...4]], [3∈[1...6]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d40|[Roll(expression=1d40, elements=[16], randomElementsInRoll=[16∈[1...40]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=40, elements=[40], randomElementsInRoll=, childrenRolls=[])])] -1d450|[Roll(expression=1d450, elements=[446], randomElementsInRoll=[446∈[1...450]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=450, elements=[450], randomElementsInRoll=, childrenRolls=[])])] -1d4=|[Roll(expression=1d4=, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -1d5|[Roll(expression=1d5, elements=[1], randomElementsInRoll=[1∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1d50|[Roll(expression=1d50, elements=[46], randomElementsInRoll=[46∈[1...50]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=50, elements=[50], randomElementsInRoll=, childrenRolls=[])])] -1d500|[Roll(expression=1d500, elements=[96], randomElementsInRoll=[96∈[1...500]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=500, elements=[500], randomElementsInRoll=, childrenRolls=[])])] -1d6|[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d6 groupC(2d6)|[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6dgroupC(2d6), elements=[1x2, 1x2, 1x3, 1x3, 1x3, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1x2∈[1x3, 1x2], 1x2∈[1x3, 1x2], 1x3∈[1x3, 1x2], 1x3∈[1x3, 1x2], 1x3∈[1x3, 1x2], 1x2∈[1x3, 1x2]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=groupC(2d6), elements=[1x3, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6), elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])])] -1d6+1|[Roll(expression=1d6+1, elements=[2, 1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -1d6+1=|[Roll(expression=1d6+1=, elements=[3], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6+1, elements=[2, 1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -1d6+2|[Roll(expression=1d6+2, elements=[2, 2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -1d6+2=|[Roll(expression=1d6+2=, elements=[4], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6+2, elements=[2, 2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -1d6+2d6|[Roll(expression=1d6+2d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6]], [3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d6+3|[Roll(expression=1d6+3, elements=[2, 3], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -1d6+3=|[Roll(expression=1d6+3=, elements=[5], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6+3, elements=[2, 3], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -1d6+4|[Roll(expression=1d6+4, elements=[2, 4], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -1d6+4=|[Roll(expression=1d6+4=, elements=[6], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6+4, elements=[2, 4], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -1d6+5|[Roll(expression=1d6+5, elements=[2, 5], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1d6+5=|[Roll(expression=1d6+5=, elements=[7], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6+5, elements=[2, 5], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -1d6+6|[Roll(expression=1d6+6, elements=[2, 6], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d6+6=|[Roll(expression=1d6+6=, elements=[8], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6+6, elements=[2, 6], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d6, 2d6, 3d6|[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[4, 1, 1], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d6, 2d6, 3d6, 4d6, 5d6, 6d6, 7d6, 8d6, 9d6, 10d6, 11d6, 12d6|[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[4, 1, 1], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6, elements=[6, 3, 2, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5d6, elements=[6, 3, 3, 2, 4], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6d6, elements=[4, 1, 6, 6, 1, 4], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7d6, elements=[3, 3, 6, 3, 2, 2, 4], randomElementsInRoll=[3∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8d6, elements=[2, 5, 5, 6, 5, 4, 3, 5], randomElementsInRoll=[2∈[1...6], 5∈[1...6], 5∈[1...6], 6∈[1...6], 5∈[1...6], 4∈[1...6], 3∈[1...6], 5∈[1...6]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=9d6, elements=[4, 6, 2, 1, 2, 5, 1, 1, 3], randomElementsInRoll=[4∈[1...6], 6∈[1...6], 2∈[1...6], 1∈[1...6], 2∈[1...6], 5∈[1...6], 1∈[1...6], 1∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10d6, elements=[5, 2, 2, 6, 1, 3, 2, 2, 4, 6], randomElementsInRoll=[5∈[1...6], 2∈[1...6], 2∈[1...6], 6∈[1...6], 1∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=11d6, elements=[2, 6, 3, 2, 2, 5, 1, 2, 2, 6, 6], randomElementsInRoll=[2∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 5∈[1...6], 1∈[1...6], 2∈[1...6], 2∈[1...6], 6∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12d6, elements=[1, 4, 3, 2, 3, 4, 6, 1, 5, 4, 2, 6], randomElementsInRoll=[1∈[1...6], 4∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 4∈[1...6], 6∈[1...6], 1∈[1...6], 5∈[1...6], 4∈[1...6], 2∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -1d6-1|[Roll(expression=1d6-1, elements=[2, -1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -1d6-1=|[Roll(expression=1d6-1=, elements=[1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6-1, elements=[2, -1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -1d6-3|[Roll(expression=1d6-3, elements=[2, -3], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -1d60|[Roll(expression=1d60, elements=[56], randomElementsInRoll=[56∈[1...60]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=60, elements=[60], randomElementsInRoll=, childrenRolls=[])])] -1d66|[Roll(expression=1d66, elements=[26], randomElementsInRoll=[26∈[1...66]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=66, elements=[66], randomElementsInRoll=, childrenRolls=[])])] -1d6=|[Roll(expression=1d6=, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -1d6>4|[Roll(expression=1d6>4, elements=[], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -1d6>=5|[Roll(expression=1d6>=5, elements=[], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -1d7|[Roll(expression=1d7, elements=[2], randomElementsInRoll=[2∈[1...7]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -1d70|[Roll(expression=1d70, elements=[16], randomElementsInRoll=[16∈[1...70]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=70, elements=[70], randomElementsInRoll=, childrenRolls=[])])] -1d8|[Roll(expression=1d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -1d8+1d10=|[Roll(expression=1d8+1d10=, elements=[11], randomElementsInRoll=[8∈[1...8]], [3∈[1...10]], childrenRolls=[Roll(expression=1d8+1d10, elements=[8, 3], randomElementsInRoll=[8∈[1...8]], [3∈[1...10]], childrenRolls=[Roll(expression=1d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10, elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d8+5d10=|[Roll(expression=1d8+5d10=, elements=[28], randomElementsInRoll=[8∈[1...8]], [3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=1d8+5d10, elements=[8, 3, 1, 10, 1, 5], randomElementsInRoll=[8∈[1...8]], [3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=1d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5d10, elements=[3, 1, 10, 1, 5], randomElementsInRoll=[3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -1d80|[Roll(expression=1d80, elements=[16], randomElementsInRoll=[16∈[1...80]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=80, elements=[80], randomElementsInRoll=, childrenRolls=[])])] -1d82|[Roll(expression=1d82, elements=[4], randomElementsInRoll=[4∈[1...82]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=82, elements=[82], randomElementsInRoll=, childrenRolls=[])])] -1d8=|[Roll(expression=1d8=, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -1d9|[Roll(expression=1d9, elements=[5], randomElementsInRoll=[5∈[1...9]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])] -1d9+1d9+1d10|[Roll(expression=1d9+1d9+1d10, elements=[5, 9, 1], randomElementsInRoll=[5∈[1...9]], [9∈[1...9]], [1∈[1...10]], childrenRolls=[Roll(expression=1d9+1d9, elements=[5, 9], randomElementsInRoll=[5∈[1...9]], [9∈[1...9]], childrenRolls=[Roll(expression=1d9, elements=[5], randomElementsInRoll=[5∈[1...9]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d9, elements=[9], randomElementsInRoll=[9∈[1...9]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1d10, elements=[1], randomElementsInRoll=[1∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -1d90|[Roll(expression=1d90, elements=[86], randomElementsInRoll=[86∈[1...90]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=90, elements=[90], randomElementsInRoll=, childrenRolls=[])])] -1d[0/1/2/3/4/5/6/7/8/9]=|[Roll(expression=1d[0/1/2/3/4/5/6/7/8/9]=, elements=[5], randomElementsInRoll=[5∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], childrenRolls=[Roll(expression=1d[0/1/2/3/4/5/6/7/8/9], elements=[5], randomElementsInRoll=[5∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/1/2/3/4/5/6/7/8/9], elements=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], randomElementsInRoll=, childrenRolls=[])])])] -1d[Head \U0001f600/Tail \U0001f985]|[Roll(expression=1d[Head \U0001f600/Tail \U0001f985], elements=[Tail \U0001f985], randomElementsInRoll=[Tail \U0001f985∈[Head \U0001f600, Tail \U0001f985]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Head \U0001f600/Tail \U0001f985], elements=[Head \U0001f600, Tail \U0001f985], randomElementsInRoll=, childrenRolls=[])])] -1d[Head 😀/Tail 🦅]|[Roll(expression=1d[Head 😀/Tail 🦅], elements=[Tail 🦅], randomElementsInRoll=[Tail 🦅∈[Head 😀, Tail 🦅]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Head 😀/Tail 🦅], elements=[Head 😀, Tail 🦅], randomElementsInRoll=, childrenRolls=[])])] -1d[Pile/Face]|[Roll(expression=1d[Pile/Face], elements=[Face], randomElementsInRoll=[Face∈[Pile, Face]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Pile/Face], elements=[Pile, Face], randomElementsInRoll=, childrenRolls=[])])] -2|[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])] -2(3d6=)k1|[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(3d6=)k1, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6=), elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2*(3d6=)k1|[Roll(expression=2*(3d6=)k1, elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(3d6=)k1, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6=), elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2*3d6L1|[Roll(expression=2*3d6L1, elements=[2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3d6L1, elements=[1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2*3d6k1|[Roll(expression=2*3d6k1, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3d6k1, elements=[3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -20|[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])] -200|[Roll(expression=200, elements=[200], randomElementsInRoll=, childrenRolls=[])] -20d20=|[Roll(expression=20d20=, elements=[244], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20], 6∈[1...20], 13∈[1...20], 15∈[1...20], 20∈[1...20], 8∈[1...20], 16∈[1...20], 19∈[1...20], 4∈[1...20], 4∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=20d20, elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1, 6, 13, 15, 20, 8, 16, 19, 4, 4, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20], 20∈[1...20], 1∈[1...20], 6∈[1...20], 13∈[1...20], 15∈[1...20], 20∈[1...20], 8∈[1...20], 16∈[1...20], 19∈[1...20], 4∈[1...20], 4∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -20d6|[Roll(expression=20d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6], 1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -26|[Roll(expression=26, elements=[26], randomElementsInRoll=, childrenRolls=[])] -2D100K1|[Roll(expression=2D100K1, elements=[96], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2D100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2D100k1|[Roll(expression=2D100k1, elements=[96], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2D100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2D100l1|[Roll(expression=2D100l1, elements=[73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2D100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2D12|[Roll(expression=2D12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -2D12+1D6|[Roll(expression=2D12+1D6, elements=[8, 9, 1], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], [1∈[1...6]], childrenRolls=[Roll(expression=2D12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1D6, elements=[1], randomElementsInRoll=[1∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -2D20|[Roll(expression=2D20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -2D4|[Roll(expression=2D4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2D4=|[Roll(expression=2D4=, elements=[6], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2D4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -2D6|[Roll(expression=2D6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -2D6+3|[Roll(expression=2D6+3, elements=[2, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2D6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -2D6=|[Roll(expression=2D6=, elements=[5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2D6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -2D8|[Roll(expression=2D8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -2D8=|[Roll(expression=2D8=, elements=[10], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2D8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -2D[Head/Tail]|[Roll(expression=2D[Head/Tail], elements=[Tail, Tail], randomElementsInRoll=[Tail∈[Head, Tail], Tail∈[Head, Tail]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Head/Tail], elements=[Head, Tail], randomElementsInRoll=, childrenRolls=[])])] -2d10|[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -2d10 =|[Roll(expression=2d10=, elements=[9], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -2d10+1d2|[Roll(expression=2d10+1d2, elements=[6, 3, 2], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [2∈[1...2]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -2d10+1d4|[Roll(expression=2d10+1d4, elements=[6, 3, 2], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [2∈[1...4]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d4, elements=[2], randomElementsInRoll=[2∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -2d10+1d5|[Roll(expression=2d10+1d5, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d5, elements=[1], randomElementsInRoll=[1∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -2d10+1d5 =|[Roll(expression=2d10+1d5=, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5]], childrenRolls=[Roll(expression=2d10+1d5, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d5, elements=[1], randomElementsInRoll=[1∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -2d10+1d5=|[Roll(expression=2d10+1d5=, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5]], childrenRolls=[Roll(expression=2d10+1d5, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d5, elements=[1], randomElementsInRoll=[1∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -2d10+1d6|[Roll(expression=2d10+1d6, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...6]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[1], randomElementsInRoll=[1∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -2d10+1d8|[Roll(expression=2d10+1d8, elements=[6, 3, 6], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [6∈[1...8]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d8, elements=[6], randomElementsInRoll=[6∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -2d10+2d5|[Roll(expression=2d10+2d5, elements=[6, 3, 1, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d5, elements=[1, 5], randomElementsInRoll=[1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -2d10+2d5=|[Roll(expression=2d10+2d5=, elements=[15], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=2d10+2d5, elements=[6, 3, 1, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], [1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d5, elements=[1, 5], randomElementsInRoll=[1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -2d10+3=|[Roll(expression=2d10+3=, elements=[12], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10+3, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -2d10+4|[Roll(expression=2d10+4, elements=[6, 3, 4], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2d100|[Roll(expression=2d100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -2d100K1|[Roll(expression=2d100K1, elements=[96], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2d100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d100L1|[Roll(expression=2d100L1, elements=[73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2d100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d100L2|[Roll(expression=2d100L2, elements=[73, 96], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2d100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d100k2|[Roll(expression=2d100k2, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2d100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d100l1|[Roll(expression=2d100l1, elements=[73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2d100, elements=[96, 73], randomElementsInRoll=[96∈[1...100], 73∈[1...100]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d10=|[Roll(expression=2d10=, elements=[9], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -2d10>6|[Roll(expression=2d10>6, elements=[], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -2d10L1|[Roll(expression=2d10L1, elements=[3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d10k1|[Roll(expression=2d10k1, elements=[6], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2d10, elements=[6, 3], randomElementsInRoll=[6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d12|[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -2d12+12|[Roll(expression=2d12+12, elements=[8, 9, 12], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -2d12+12=|[Roll(expression=2d12+12=, elements=[29], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12+12, elements=[8, 9, 12], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -2d12+16|[Roll(expression=2d12+16, elements=[8, 9, 16], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -2d12+16=|[Roll(expression=2d12+16=, elements=[33], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12+16, elements=[8, 9, 16], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])])] -2d12=|[Roll(expression=2d12=, elements=[17], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -2d12k1|[Roll(expression=2d12k1, elements=[9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d12l1|[Roll(expression=2d12l1, elements=[8], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2d12, elements=[8, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d16|[Roll(expression=2d16, elements=[16, 10], randomElementsInRoll=[16∈[1...16], 10∈[1...16]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -2d17|[Roll(expression=2d17, elements=[2, 5], randomElementsInRoll=[2∈[1...17], 5∈[1...17]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])])] -2d2|[Roll(expression=2d2, elements=[2, 2], randomElementsInRoll=[2∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d20|[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -2d20+2|[Roll(expression=2d20+2, elements=[16, 13, 2], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d20+6|[Roll(expression=2d20+6, elements=[16, 13, 6], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -2d20=|[Roll(expression=2d20=, elements=[29], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -2d20L1|[Roll(expression=2d20L1, elements=[13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d20L1=|[Roll(expression=2d20L1=, elements=[13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20L1, elements=[13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d20k1|[Roll(expression=2d20k1, elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d20k1=|[Roll(expression=2d20k1=, elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20k1, elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d20l1|[Roll(expression=2d20l1, elements=[13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2d20, elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d2=|[Roll(expression=2d2=, elements=[4], randomElementsInRoll=[2∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=2d2, elements=[2, 2], randomElementsInRoll=[2∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -2d3|[Roll(expression=2d3, elements=[2, 3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -2d30|[Roll(expression=2d30, elements=[26, 3], randomElementsInRoll=[26∈[1...30], 3∈[1...30]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=30, elements=[30], randomElementsInRoll=, childrenRolls=[])])] -2d3=|[Roll(expression=2d3=, elements=[5], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[2, 3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -2d3k1|[Roll(expression=2d3k1, elements=[3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[2, 3], randomElementsInRoll=[2∈[1...3], 3∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d4|[Roll(expression=2d4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2d4+1|[Roll(expression=2d4+1, elements=[4, 2, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2d4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d4+1=|[Roll(expression=2d4+1=, elements=[7], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2d4+1, elements=[4, 2, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2d4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d4=|[Roll(expression=2d4=, elements=[6], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2d4, elements=[4, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -2d5|[Roll(expression=2d5, elements=[1, 3], randomElementsInRoll=[1∈[1...5], 3∈[1...5]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -2d6|[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -2d6 + 2|[Roll(expression=2d6+2, elements=[2, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d6 + 2=|[Roll(expression=2d6+2=, elements=[7], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+2, elements=[2, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -2d6+ 7|[Roll(expression=2d6+7, elements=[2, 3, 7], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -2d6+(2d3k1)|[Roll(expression=2d6+(2d3k1), elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(2d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d6+(2d3k1)=|[Roll(expression=2d6+(2d3k1)=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6+(2d3k1), elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(2d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])])] -2d6+(3d3k1)|[Roll(expression=2d6+(3d3k1), elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(3d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3d3, elements=[1, 1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d6+(3d3k1)=|[Roll(expression=2d6+(3d3k1)=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6+(3d3k1), elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(3d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3d3, elements=[1, 1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])])] -2d6+(4d3k1)=|[Roll(expression=2d6+(4d3k1)=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6+(4d3k1), elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(4d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(4d3, elements=[1, 1, 1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])])] -2d6+1|[Roll(expression=2d6+1, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d6+10|[Roll(expression=2d6+10, elements=[2, 3, 10], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -2d6+10=|[Roll(expression=2d6+10=, elements=[15], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+10, elements=[2, 3, 10], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -2d6+12|[Roll(expression=2d6+12, elements=[2, 3, 12], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -2d6+12=|[Roll(expression=2d6+12=, elements=[17], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+12, elements=[2, 3, 12], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -2d6+16|[Roll(expression=2d6+16, elements=[2, 3, 16], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -2d6+16=|[Roll(expression=2d6+16=, elements=[21], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+16, elements=[2, 3, 16], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])])] -2d6+1=|[Roll(expression=2d6+1=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+1, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d6+1d3|[Roll(expression=2d6+1d3, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d3, elements=[1], randomElementsInRoll=[1∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -2d6+1d3=|[Roll(expression=2d6+1d3=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3]], childrenRolls=[Roll(expression=2d6+1d3, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d3, elements=[1], randomElementsInRoll=[1∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])])] -2d6+2|[Roll(expression=2d6+2, elements=[2, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d6+2=|[Roll(expression=2d6+2=, elements=[7], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+2, elements=[2, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -2d6+2d3k1|[Roll(expression=2d6+2d3k1, elements=[3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6+2d3, elements=[2, 3, 1, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d6+3|[Roll(expression=2d6+3, elements=[2, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -2d6+3=|[Roll(expression=2d6+3=, elements=[8], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+3, elements=[2, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -2d6+4|[Roll(expression=2d6+4, elements=[2, 3, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2d6+4=|[Roll(expression=2d6+4=, elements=[9], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+4, elements=[2, 3, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -2d6+5|[Roll(expression=2d6+5, elements=[2, 3, 5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -2d6+52d6+4|[Roll(expression=2d6+52d6+4, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6, 1, 4, 3, 3, 6, 3, 2, 2, 4, 2, 5, 5, 6, 5, 4, 3, 5, 4, 6, 2, 1, 2, 5, 1, 1, 3, 5, 2, 2, 6, 1, 3, 2, 2, 4, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6], 1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6], 4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6], 2∈[1...6], 5∈[1...6], 5∈[1...6], 6∈[1...6], 5∈[1...6], 4∈[1...6], 3∈[1...6], 5∈[1...6], 4∈[1...6], 6∈[1...6], 2∈[1...6], 1∈[1...6], 2∈[1...6], 5∈[1...6], 1∈[1...6], 1∈[1...6], 3∈[1...6], 5∈[1...6], 2∈[1...6], 2∈[1...6], 6∈[1...6], 1∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=2d6+52d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6, 1, 4, 3, 3, 6, 3, 2, 2, 4, 2, 5, 5, 6, 5, 4, 3, 5, 4, 6, 2, 1, 2, 5, 1, 1, 3, 5, 2, 2, 6, 1, 3, 2, 2, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6], 1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6], 4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6], 2∈[1...6], 5∈[1...6], 5∈[1...6], 6∈[1...6], 5∈[1...6], 4∈[1...6], 3∈[1...6], 5∈[1...6], 4∈[1...6], 6∈[1...6], 2∈[1...6], 1∈[1...6], 2∈[1...6], 5∈[1...6], 1∈[1...6], 1∈[1...6], 3∈[1...6], 5∈[1...6], 2∈[1...6], 2∈[1...6], 6∈[1...6], 1∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=52d6, elements=[1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6, 1, 4, 3, 3, 6, 3, 2, 2, 4, 2, 5, 5, 6, 5, 4, 3, 5, 4, 6, 2, 1, 2, 5, 1, 1, 3, 5, 2, 2, 6, 1, 3, 2, 2, 4], randomElementsInRoll=[1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6], 1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6], 4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6], 2∈[1...6], 5∈[1...6], 5∈[1...6], 6∈[1...6], 5∈[1...6], 4∈[1...6], 3∈[1...6], 5∈[1...6], 4∈[1...6], 6∈[1...6], 2∈[1...6], 1∈[1...6], 2∈[1...6], 5∈[1...6], 1∈[1...6], 1∈[1...6], 3∈[1...6], 5∈[1...6], 2∈[1...6], 2∈[1...6], 6∈[1...6], 1∈[1...6], 3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=52, elements=[52], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2d6+5=|[Roll(expression=2d6+5=, elements=[10], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+5, elements=[2, 3, 5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -2d6+6|[Roll(expression=2d6+6, elements=[2, 3, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -2d6+6=|[Roll(expression=2d6+6=, elements=[11], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+6, elements=[2, 3, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -2d6+7|[Roll(expression=2d6+7, elements=[2, 3, 7], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -2d6+7=|[Roll(expression=2d6+7=, elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+7, elements=[2, 3, 7], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])])] -2d6+8|[Roll(expression=2d6+8, elements=[2, 3, 8], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -2d6+8=|[Roll(expression=2d6+8=, elements=[13], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6+8, elements=[2, 3, 8], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -2d6,2d3k1|[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d3k1, elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d6,2d6+1,2d6+2,2d6+3,2d6-1,2d6-2|[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6+1, elements=[1, 4, 1], randomElementsInRoll=[1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[1, 4], randomElementsInRoll=[1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6+2, elements=[1, 1, 2], randomElementsInRoll=[1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[1, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6+3, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[6, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6-1, elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6-2, elements=[6, 3, -2], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[6, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d6,2d6,2d6,2d6,2d6,2d6,2d6|[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[1, 4], randomElementsInRoll=[1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[1, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[6, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[6, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[3, 2], randomElementsInRoll=[3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -2d6-(2d3k1)|[Roll(expression=2d6-(2d3k1), elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(2d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d6-(2d3k1)=|[Roll(expression=2d6-(2d3k1)=, elements=[4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6-(2d3k1), elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(2d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])])] -2d6-(3d3k1)|[Roll(expression=2d6-(3d3k1), elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(3d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3d3, elements=[1, 1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d6-(3d3k1)=|[Roll(expression=2d6-(3d3k1)=, elements=[4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6-(3d3k1), elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(3d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3d3, elements=[1, 1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])])] -2d6-(4d3k1)=|[Roll(expression=2d6-(4d3k1)=, elements=[4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6-(4d3k1), elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(4d3k1), elements=[1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(4d3, elements=[1, 1, 1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])])] -2d6-1|[Roll(expression=2d6-1, elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -2d6-1=|[Roll(expression=2d6-1=, elements=[4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6-1, elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -2d6-1d3|[Roll(expression=2d6-1d3, elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d3, elements=[1], randomElementsInRoll=[1∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -2d6-1d3=|[Roll(expression=2d6-1d3=, elements=[4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3]], childrenRolls=[Roll(expression=2d6-1d3, elements=[2, 3, -1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d3, elements=[1], randomElementsInRoll=[1∈[1...3]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])])] -2d6-2|[Roll(expression=2d6-2, elements=[3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d6-2=|[Roll(expression=2d6-2=, elements=[3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6-2, elements=[3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -2d6-3|[Roll(expression=2d6-3, elements=[2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -2d6-3=|[Roll(expression=2d6-3=, elements=[2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6-3, elements=[2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -2d6-4|[Roll(expression=2d6-4, elements=[2, 3, -4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2d6-4=|[Roll(expression=2d6-4=, elements=[1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6-4, elements=[2, 3, -4], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -2d6-5|[Roll(expression=2d6-5, elements=[2, 3, -5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -2d6-5=|[Roll(expression=2d6-5=, elements=[0], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6-5, elements=[2, 3, -5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -2d6=|[Roll(expression=2d6=, elements=[5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -2d6=,2d6=,2d6=,2d6=,2d6=,2d6=,2d6=|[Roll(expression=2d6=, elements=[5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=2d6=, elements=[5], randomElementsInRoll=[1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[1, 4], randomElementsInRoll=[1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=2d6=, elements=[2], randomElementsInRoll=[1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[1, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=2d6=, elements=[9], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[6, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=2d6=, elements=[5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=2d6=, elements=[9], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[6, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=2d6=, elements=[5], randomElementsInRoll=[3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[3, 2], randomElementsInRoll=[3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -2d6>4|[Roll(expression=2d6>4, elements=[], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2d6>=5|[Roll(expression=2d6>=5, elements=[], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -2d6k2|[Roll(expression=2d6k2, elements=[3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -2d6k7|[Roll(expression=2d6k7, elements=[3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -2d8|[Roll(expression=2d8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -2d8+1d20|[Roll(expression=2d8+1d20, elements=[8, 2, 11], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], [11∈[1...20]], childrenRolls=[Roll(expression=2d8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d20, elements=[11], randomElementsInRoll=[11∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -2d8+4|[Roll(expression=2d8+4, elements=[8, 2, 4], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2d8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -2d8+5d10|[Roll(expression=2d8+5d10, elements=[8, 2, 1, 10, 1, 5, 10], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], [1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=2d8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5d10, elements=[1, 10, 1, 5, 10], randomElementsInRoll=[1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -2d8=|[Roll(expression=2d8=, elements=[10], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2d8, elements=[8, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -2d9|[Roll(expression=2d9, elements=[5, 9], randomElementsInRoll=[5∈[1...9], 9∈[1...9]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])] -2d[-1/0/1/1/2/3]=|[Roll(expression=2d[-1/0/1/1/2/3]=, elements=[1], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=2d[-1/0/1/1/2/3], elements=[0, 1], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/1/2/3], elements=[-1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -2d[-1/0/1/2/3]|[Roll(expression=2d[-1/0/1/2/3], elements=[-1, 1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])] -2d[-1/0/1/2/3]=|[Roll(expression=2d[-1/0/1/2/3]=, elements=[0], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=2d[-1/0/1/2/3], elements=[-1, 1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -2d[0/1/2/3/4/5/6/7/8/9]=|[Roll(expression=2d[0/1/2/3/4/5/6/7/8/9]=, elements=[7], randomElementsInRoll=[5∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 2∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], childrenRolls=[Roll(expression=2d[0/1/2/3/4/5/6/7/8/9], elements=[5, 2], randomElementsInRoll=[5∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 2∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/1/2/3/4/5/6/7/8/9], elements=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], randomElementsInRoll=, childrenRolls=[])])])] -2d[1/0/1/1/2/3]=|[Roll(expression=2d[1/0/1/1/2/3]=, elements=[1], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=2d[1/0/1/1/2/3], elements=[0, 1], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/0/1/1/2/3], elements=[1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -2d[1/2/3/0/0/-1]|[Roll(expression=2d[1/2/3/0/0/-1], elements=[2, 3], randomElementsInRoll=[2∈[1, 2, 3, 0, 0, -1], 3∈[1, 2, 3, 0, 0, -1]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/2/3/0/0/-1], elements=[1, 2, 3, 0, 0, -1], randomElementsInRoll=, childrenRolls=[])])] -2d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll(expression=2d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=, elements=[3], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=2d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[2, 1], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], randomElementsInRoll=, childrenRolls=[])])])] -3|[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])] -3+4|[Roll(expression=3+4, elements=[3, 4], randomElementsInRoll=, childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -3D1|[Roll(expression=3D1, elements=[1, 1, 1], randomElementsInRoll=[1∈[1...1], 1∈[1...1], 1∈[1...1]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -3D12|[Roll(expression=3D12, elements=[8, 9, 7], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -3D12, 3D6|[Roll(expression=3D12, elements=[8, 9, 7], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3D6, elements=[4, 1, 1], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -3D4|[Roll(expression=3D4, elements=[4, 2, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -3D4=|[Roll(expression=3D4=, elements=[8], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=3D4, elements=[4, 2, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -3D6|[Roll(expression=3D6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -3D6=|[Roll(expression=3D6=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3D6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -3D8|[Roll(expression=3D8, elements=[8, 2, 6], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -3D8=|[Roll(expression=3D8=, elements=[16], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8]], childrenRolls=[Roll(expression=3D8, elements=[8, 2, 6], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -3d10|[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -3d10 =|[Roll(expression=3d10=, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -3d10+1d2|[Roll(expression=3d10+1d2, elements=[6, 3, 1, 2], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [2∈[1...2]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -3d10+1d4|[Roll(expression=3d10+1d4, elements=[6, 3, 1, 4], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [4∈[1...4]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -3d10+1d5=|[Roll(expression=3d10+1d5=, elements=[15], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [5∈[1...5]], childrenRolls=[Roll(expression=3d10+1d5, elements=[6, 3, 1, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [5∈[1...5]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d5, elements=[5], randomElementsInRoll=[5∈[1...5]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -3d10+1d6|[Roll(expression=3d10+1d6, elements=[6, 3, 1, 4], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [4∈[1...6]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -3d10+1d8|[Roll(expression=3d10+1d8, elements=[6, 3, 1, 4], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [4∈[1...8]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d8, elements=[4], randomElementsInRoll=[4∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -3d10+3d5 =|[Roll(expression=3d10+3d5=, elements=[21], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [5∈[1...5], 1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=3d10+3d5, elements=[6, 3, 1, 5, 1, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [5∈[1...5], 1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d5, elements=[5, 1, 5], randomElementsInRoll=[5∈[1...5], 1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -3d10+3d5=|[Roll(expression=3d10+3d5=, elements=[21], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [5∈[1...5], 1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=3d10+3d5, elements=[6, 3, 1, 5, 1, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], [5∈[1...5], 1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d5, elements=[5, 1, 5], randomElementsInRoll=[5∈[1...5], 1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])])] -3d100|[Roll(expression=3d100, elements=[96, 73, 51], randomElementsInRoll=[96∈[1...100], 73∈[1...100], 51∈[1...100]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -3d10=|[Roll(expression=3d10=, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -3d10>6|[Roll(expression=3d10>6, elements=[], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -3d10>7|[Roll(expression=3d10>7, elements=[], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -3d10L1|[Roll(expression=3d10L1, elements=[1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3d10, elements=[6, 3, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -3d12|[Roll(expression=3d12, elements=[8, 9, 7], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -3d12=|[Roll(expression=3d12=, elements=[24], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=3d12, elements=[8, 9, 7], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -3d17|[Roll(expression=3d17, elements=[2, 5, 10], randomElementsInRoll=[2∈[1...17], 5∈[1...17], 10∈[1...17]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])])] -3d2|[Roll(expression=3d2, elements=[2, 2, 2], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -3d20|[Roll(expression=3d20, elements=[16, 13, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -3d20=|[Roll(expression=3d20=, elements=[40], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=3d20, elements=[16, 13, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -3d20k1|[Roll(expression=3d20k1, elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=3d20, elements=[16, 13, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -3d3|[Roll(expression=3d3, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -3d3k1|[Roll(expression=3d3k1, elements=[3], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=3d3, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -3d4|[Roll(expression=3d4, elements=[4, 2, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -3d4=|[Roll(expression=3d4=, elements=[8], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=3d4, elements=[4, 2, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -3d6|[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -3d6+1|[Roll(expression=3d6+1, elements=[2, 3, 1, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -3d6+10|[Roll(expression=3d6+10, elements=[2, 3, 1, 10], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -3d6+10=|[Roll(expression=3d6+10=, elements=[16], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6+10, elements=[2, 3, 1, 10], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -3d6+18|[Roll(expression=3d6+18, elements=[2, 3, 1, 18], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -3d6+18=|[Roll(expression=3d6+18=, elements=[24], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6+18, elements=[2, 3, 1, 18], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])])] -3d6+2|[Roll(expression=3d6+2, elements=[2, 3, 1, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -3d6+24|[Roll(expression=3d6+24, elements=[2, 3, 1, 24], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=24, elements=[24], randomElementsInRoll=, childrenRolls=[])])] -3d6+24=|[Roll(expression=3d6+24=, elements=[30], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6+24, elements=[2, 3, 1, 24], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=24, elements=[24], randomElementsInRoll=, childrenRolls=[])])])] -3d6+3|[Roll(expression=3d6+3, elements=[2, 3, 1, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -3d6+5|[Roll(expression=3d6+5, elements=[2, 3, 1, 5], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -3d6+5=|[Roll(expression=3d6+5=, elements=[11], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6+5, elements=[2, 3, 1, 5], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -3d6+6|[Roll(expression=3d6+6, elements=[2, 3, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -3d6+6=|[Roll(expression=3d6+6=, elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6+6, elements=[2, 3, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -3d6+7|[Roll(expression=3d6+7, elements=[2, 3, 1, 7], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -3d6+7=|[Roll(expression=3d6+7=, elements=[13], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6+7, elements=[2, 3, 1, 7], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])])] -3d6+8|[Roll(expression=3d6+8, elements=[2, 3, 1, 8], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -3d6+8=|[Roll(expression=3d6+8=, elements=[14], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6+8, elements=[2, 3, 1, 8], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -3d6,3d6,3d6,3d6,3d6,3d6|[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[4, 1, 1], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[6, 3, 2], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[3, 6, 3], randomElementsInRoll=[3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[3, 2, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[4, 1, 6], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -3d6=|[Roll(expression=3d6=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -3d6=,3d6=,3d6=,3d6=,3d6=,3d6=|[Roll(expression=3d6=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[6], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[4, 1, 1], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[11], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[6, 3, 2], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[12], randomElementsInRoll=[3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[3, 6, 3], randomElementsInRoll=[3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[9], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[3, 2, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[11], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[4, 1, 6], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -3d6==3|[Roll(expression=3d6==3, elements=[3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -3d6>4|[Roll(expression=3d6>4, elements=[], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -3d6>=5|[Roll(expression=3d6>=5, elements=[], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -3d7|[Roll(expression=3d7, elements=[2, 2, 2], randomElementsInRoll=[2∈[1...7], 2∈[1...7], 2∈[1...7]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -3d8|[Roll(expression=3d8, elements=[8, 2, 6], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -3d8=|[Roll(expression=3d8=, elements=[16], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8]], childrenRolls=[Roll(expression=3d8, elements=[8, 2, 6], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -3d[-1/0/1/1/2/3]=|[Roll(expression=3d[-1/0/1/1/2/3]=, elements=[0], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=3d[-1/0/1/1/2/3], elements=[0, 1, -1], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/1/2/3], elements=[-1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -3d[-1/0/1/2/3]|[Roll(expression=3d[-1/0/1/2/3], elements=[-1, 1, -1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])] -3d[-1/0/1/2/3]=|[Roll(expression=3d[-1/0/1/2/3]=, elements=[-1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=3d[-1/0/1/2/3], elements=[-1, 1, -1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -3d[1/0/1/1/2/3]=|[Roll(expression=3d[1/0/1/1/2/3]=, elements=[2], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=3d[1/0/1/1/2/3], elements=[0, 1, 1], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/0/1/1/2/3], elements=[1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -3d[1/2/3/0/0/-1]|[Roll(expression=3d[1/2/3/0/0/-1], elements=[2, 3, 1], randomElementsInRoll=[2∈[1, 2, 3, 0, 0, -1], 3∈[1, 2, 3, 0, 0, -1], 1∈[1, 2, 3, 0, 0, -1]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/2/3/0/0/-1], elements=[1, 2, 3, 0, 0, -1], randomElementsInRoll=, childrenRolls=[])])] -3d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll(expression=3d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=, elements=[6], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=3d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[2, 1, 3], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], randomElementsInRoll=, childrenRolls=[])])])] -4|[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])] -40|[Roll(expression=40, elements=[40], randomElementsInRoll=, childrenRolls=[])] -400|[Roll(expression=400, elements=[400], randomElementsInRoll=, childrenRolls=[])] -4D12+10|[Roll(expression=4D12+10, elements=[8, 9, 7, 10, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4D12, elements=[8, 9, 7, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -4D12+10=|[Roll(expression=4D12+10=, elements=[44], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4D12+10, elements=[8, 9, 7, 10, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4D12, elements=[8, 9, 7, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -4D12+50|[Roll(expression=4D12+50, elements=[8, 9, 7, 10, 50], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4D12, elements=[8, 9, 7, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=50, elements=[50], randomElementsInRoll=, childrenRolls=[])])] -4D12+50=|[Roll(expression=4D12+50=, elements=[84], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4D12+50, elements=[8, 9, 7, 10, 50], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4D12, elements=[8, 9, 7, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=50, elements=[50], randomElementsInRoll=, childrenRolls=[])])])] -4D4|[Roll(expression=4D4, elements=[4, 2, 2, 4], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -4D4=|[Roll(expression=4D4=, elements=[12], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=4D4, elements=[4, 2, 2, 4], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -4D6|[Roll(expression=4D6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -4D6=|[Roll(expression=4D6=, elements=[10], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4D6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -4D8|[Roll(expression=4D8, elements=[8, 2, 6, 4], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -4D8=|[Roll(expression=4D8=, elements=[20], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], childrenRolls=[Roll(expression=4D8, elements=[8, 2, 6, 4], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -4d!!6|[Roll(expression=4d!!6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -4d!6|[Roll(expression=4d!6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -4d10|[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -4d10+1d2|[Roll(expression=4d10+1d2, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], [1∈[1...2]], childrenRolls=[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d2, elements=[1], randomElementsInRoll=[1∈[1...2]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -4d10+1d4|[Roll(expression=4d10+1d4, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], [1∈[1...4]], childrenRolls=[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d4, elements=[1], randomElementsInRoll=[1∈[1...4]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -4d10+1d6|[Roll(expression=4d10+1d6, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], [1∈[1...6]], childrenRolls=[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d6, elements=[1], randomElementsInRoll=[1∈[1...6]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -4d10+1d8|[Roll(expression=4d10+1d8, elements=[6, 3, 1, 10, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], [5∈[1...8]], childrenRolls=[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d8, elements=[5], randomElementsInRoll=[5∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -4d10-2|[Roll(expression=4d10-2, elements=[6, 3, 1, 10, -2], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -4d100|[Roll(expression=4d100, elements=[96, 73, 51, 30], randomElementsInRoll=[96∈[1...100], 73∈[1...100], 51∈[1...100], 30∈[1...100]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -4d10=|[Roll(expression=4d10=, elements=[20], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])] -4d10>6|[Roll(expression=4d10>6, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4d10, elements=[6, 3, 1, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -4d12|[Roll(expression=4d12, elements=[8, 9, 7, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -4d12=|[Roll(expression=4d12=, elements=[34], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4d12, elements=[8, 9, 7, 10], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -4d20|[Roll(expression=4d20, elements=[16, 13, 11, 10], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -4d20=|[Roll(expression=4d20=, elements=[50], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20]], childrenRolls=[Roll(expression=4d20, elements=[16, 13, 11, 10], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -4d2=|[Roll(expression=4d2=, elements=[8], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=4d2, elements=[2, 2, 2, 2], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -4d3|[Roll(expression=4d3, elements=[2, 3, 1, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -4d3k1|[Roll(expression=4d3k1, elements=[3], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=4d3, elements=[2, 3, 1, 1], randomElementsInRoll=[2∈[1...3], 3∈[1...3], 1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -4d4|[Roll(expression=4d4, elements=[4, 2, 2, 4], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -4d4=|[Roll(expression=4d4=, elements=[12], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=4d4, elements=[4, 2, 2, 4], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -4d5|[Roll(expression=4d5, elements=[1, 3, 1, 5], randomElementsInRoll=[1∈[1...5], 3∈[1...5], 1∈[1...5], 5∈[1...5]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -4d6|[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -4d6 k3|[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -4d6 k3=|[Roll(expression=4d6k3=, elements=[9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -4d6-1|[Roll(expression=4d6-1, elements=[2, 3, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -4d6=|[Roll(expression=4d6=, elements=[10], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -4d6>4|[Roll(expression=4d6>4, elements=[], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -4d6L1|[Roll(expression=4d6L1, elements=[1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -4d6k3|[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -4d6k3, 4d6k3, 4d6k3, 4d6k3, 4d6k3, 4d6k3|[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 3, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 1, 6, 3], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[4, 4, 3], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[3, 2, 4, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 4, 3], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[4, 3, 3, 6], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -4d6k3,4d6k3,4d6k3,4d6k3,4d6k3,4d6k3|[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 3, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 1, 6, 3], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[4, 4, 3], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[3, 2, 4, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d6k3, elements=[6, 4, 3], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[4, 3, 3, 6], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -4d6k3=|[Roll(expression=4d6k3=, elements=[9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=|[Roll(expression=4d6k3=, elements=[9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[10], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 3, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 1, 6, 3], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[11], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 4, 3], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[3, 2, 4, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[13], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[13], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 4, 3], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[4, 3, 3, 6], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=|[Roll(expression=4d6k3=, elements=[9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[10], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 3, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 1, 6, 3], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[11], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 4, 3], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[3, 2, 4, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[13], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[13], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 4, 3], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[4, 3, 3, 6], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[9], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[3, 2, 2, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -4d8|[Roll(expression=4d8, elements=[8, 2, 6, 4], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -4d8+4d10=|[Roll(expression=4d8+4d10=, elements=[45], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], [1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10]], childrenRolls=[Roll(expression=4d8+4d10, elements=[8, 2, 6, 4, 1, 5, 10, 9], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], [1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10]], childrenRolls=[Roll(expression=4d8, elements=[8, 2, 6, 4], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d10, elements=[1, 5, 10, 9], randomElementsInRoll=[1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -4d8=|[Roll(expression=4d8=, elements=[20], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], childrenRolls=[Roll(expression=4d8, elements=[8, 2, 6, 4], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -4d[-1/0/1/1/2/3]=|[Roll(expression=4d[-1/0/1/1/2/3]=, elements=[1], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=4d[-1/0/1/1/2/3], elements=[0, 1, -1, 1], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/1/2/3], elements=[-1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -4d[-1/0/1/2/3]|[Roll(expression=4d[-1/0/1/2/3], elements=[-1, 1, -1, 3], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3], 3∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])] -4d[-1/0/1/2/3]=|[Roll(expression=4d[-1/0/1/2/3]=, elements=[2], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3], 3∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=4d[-1/0/1/2/3], elements=[-1, 1, -1, 3], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3], 3∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -4d[1/0/1/1/2/3]=|[Roll(expression=4d[1/0/1/1/2/3]=, elements=[3], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=4d[1/0/1/1/2/3], elements=[0, 1, 1, 1], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/0/1/1/2/3], elements=[1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -4d[1/2/3/0/0/-1]|[Roll(expression=4d[1/2/3/0/0/-1], elements=[2, 3, 1, 0], randomElementsInRoll=[2∈[1, 2, 3, 0, 0, -1], 3∈[1, 2, 3, 0, 0, -1], 1∈[1, 2, 3, 0, 0, -1], 0∈[1, 2, 3, 0, 0, -1]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/2/3/0/0/-1], elements=[1, 2, 3, 0, 0, -1], randomElementsInRoll=, childrenRolls=[])])] -4d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll(expression=4d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=, elements=[6], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 0∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=4d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[2, 1, 3, 0], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 0∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], randomElementsInRoll=, childrenRolls=[])])])] -5|[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])] -5*(2d6+6=)|[Roll(expression=5*(2d6+6=), elements=[55], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(2d6+6=), elements=[11], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6+6, elements=[2, 3, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])])] -5*(2d6+6=),|[Roll(expression=5*(2d6+6=), elements=[55], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(2d6+6=), elements=[11], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6+6, elements=[2, 3, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])])] -5*(3d6=),|[Roll(expression=5*(3d6=), elements=[30], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(3d6=), elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])])] -5d10|[Roll(expression=5d10, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -5d100|[Roll(expression=5d100, elements=[96, 73, 51, 30, 51], randomElementsInRoll=[96∈[1...100], 73∈[1...100], 51∈[1...100], 30∈[1...100], 51∈[1...100]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -5d10<1>7|[Roll(expression=5d10<1>7, elements=[], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5d10<1, elements=[], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5d10, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -5d10>6|[Roll(expression=5d10>6, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5d10, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -5d10>7|[Roll(expression=5d10>7, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5d10, elements=[6, 3, 1, 10, 1], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -5d12|[Roll(expression=5d12, elements=[8, 9, 7, 10, 7], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -5d20|[Roll(expression=5d20, elements=[16, 13, 11, 10, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -5d20=|[Roll(expression=5d20=, elements=[61], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=5d20, elements=[16, 13, 11, 10, 11], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -5d4|[Roll(expression=5d4, elements=[4, 2, 2, 4, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -5d4=|[Roll(expression=5d4=, elements=[13], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=5d4, elements=[4, 2, 2, 4, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -5d6|[Roll(expression=5d6, elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -5d6=|[Roll(expression=5d6=, elements=[11], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5d6, elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -5d6>4|[Roll(expression=5d6>4, elements=[], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5d6, elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -5d6k3|[Roll(expression=5d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5d6, elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -5d8|[Roll(expression=5d8, elements=[8, 2, 6, 4, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -5d[-1/0/1/1/2/3]=|[Roll(expression=5d[-1/0/1/1/2/3]=, elements=[0], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=5d[-1/0/1/1/2/3], elements=[0, 1, -1, 1, -1], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3], 1∈[-1, 0, 1, 1, 2, 3], -1∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/1/2/3], elements=[-1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -5d[-1/0/1/2/3]|[Roll(expression=5d[-1/0/1/2/3], elements=[-1, 1, -1, 3, -1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3], 3∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])] -5d[-1/0/1/2/3]=|[Roll(expression=5d[-1/0/1/2/3]=, elements=[1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3], 3∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=5d[-1/0/1/2/3], elements=[-1, 1, -1, 3, -1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3], 1∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3], 3∈[-1, 0, 1, 2, 3], -1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -5d[1/0/1/1/2/3]=|[Roll(expression=5d[1/0/1/1/2/3]=, elements=[4], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=5d[1/0/1/1/2/3], elements=[0, 1, 1, 1, 1], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3], 1∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/0/1/1/2/3], elements=[1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -5d[1/2/3/0/0/-1]|[Roll(expression=5d[1/2/3/0/0/-1], elements=[2, 3, 1, 0, 1], randomElementsInRoll=[2∈[1, 2, 3, 0, 0, -1], 3∈[1, 2, 3, 0, 0, -1], 1∈[1, 2, 3, 0, 0, -1], 0∈[1, 2, 3, 0, 0, -1], 1∈[1, 2, 3, 0, 0, -1]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[1/2/3/0/0/-1], elements=[1, 2, 3, 0, 0, -1], randomElementsInRoll=, childrenRolls=[])])] -5d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll(expression=5d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=, elements=[9], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 0∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=5d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[2, 1, 3, 0, 3], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 0∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], randomElementsInRoll=, childrenRolls=[])])])] -6|[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])] -69|[Roll(expression=69, elements=[69], randomElementsInRoll=, childrenRolls=[])] -6d10|[Roll(expression=6d10, elements=[6, 3, 1, 10, 1, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -6d10>6|[Roll(expression=6d10>6, elements=[10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=6d10, elements=[6, 3, 1, 10, 1, 5], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -6d20|[Roll(expression=6d20, elements=[16, 13, 11, 10, 11, 15], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -6d20+0=|[Roll(expression=6d20+0=, elements=[76], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=6d20+0, elements=[16, 13, 11, 10, 11, 15, 0], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=6d20, elements=[16, 13, 11, 10, 11, 15], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=0, elements=[0], randomElementsInRoll=, childrenRolls=[])])])] -6d2=|[Roll(expression=6d2=, elements=[10], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2], 1∈[1...2]], childrenRolls=[Roll(expression=6d2, elements=[2, 2, 2, 2, 1, 1], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2], 1∈[1...2]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -6d4|[Roll(expression=6d4, elements=[4, 2, 2, 4, 1, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -6d4=|[Roll(expression=6d4=, elements=[14], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=6d4, elements=[4, 2, 2, 4, 1, 1], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -6d6|[Roll(expression=6d6, elements=[2, 3, 1, 4, 1, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -6d6=|[Roll(expression=6d6=, elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=6d6, elements=[2, 3, 1, 4, 1, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -6d6>4|[Roll(expression=6d6>4, elements=[], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=6d6, elements=[2, 3, 1, 4, 1, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -6d8|[Roll(expression=6d8, elements=[8, 2, 6, 4, 5, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -6d8+10d10=|[Roll(expression=6d8+10d10=, elements=[98], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=6d8+10d10, elements=[8, 2, 6, 4, 5, 5, 10, 9, 10, 1, 6, 3, 5, 10, 8, 6], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=6d8, elements=[8, 2, 6, 4, 5, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10d10, elements=[10, 9, 10, 1, 6, 3, 5, 10, 8, 6], randomElementsInRoll=[10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -6d8+6d10=|[Roll(expression=6d8+6d10=, elements=[69], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=6d8+6d10, elements=[8, 2, 6, 4, 5, 5, 10, 9, 10, 1, 6, 3], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=6d8, elements=[8, 2, 6, 4, 5, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6d10, elements=[10, 9, 10, 1, 6, 3], randomElementsInRoll=[10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -6d8+7d10=|[Roll(expression=6d8+7d10=, elements=[74], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=6d8+7d10, elements=[8, 2, 6, 4, 5, 5, 10, 9, 10, 1, 6, 3, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=6d8, elements=[8, 2, 6, 4, 5, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7d10, elements=[10, 9, 10, 1, 6, 3, 5], randomElementsInRoll=[10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -6d8+8d10=|[Roll(expression=6d8+8d10=, elements=[84], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=6d8+8d10, elements=[8, 2, 6, 4, 5, 5, 10, 9, 10, 1, 6, 3, 5, 10], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], [10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=6d8, elements=[8, 2, 6, 4, 5, 5], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8d10, elements=[10, 9, 10, 1, 6, 3, 5, 10], randomElementsInRoll=[10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -6x(d6rr1+d6rr1+d6rr1+d6rr1)k3|[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[2, 3, 4, 1], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[2, 3, 4], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], [1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[2, 3], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[4], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[1], randomElementsInRoll=[1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [2∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[6, 3, 2, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [2∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[6, 3, 2], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[6, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[6, 3, 3, 2], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[6, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 6, 4], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], [1∈[1...6]], [6∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[4, 4, 6, 6], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], [1∈[1...6]], [6∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[4, 4, 6], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], [1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[4, 4], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[6], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 4, 3], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], [3∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[4, 3, 3, 6], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], [3∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[4, 3, 3], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[4, 3], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[4], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[4, 3, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[3, 2, 2, 4], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[3, 2, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[3, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -6x(d6rr1+d6rr1+d6rr1+d6rr1)k3=|[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3=, elements=[9], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[2, 3, 4, 1], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], [1∈[1...6]], [4∈[1...6]], [1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[2, 3, 4], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], [1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[2, 3], randomElementsInRoll=[2∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[4], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[1], randomElementsInRoll=[1∈[1...6]], [1∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3=, elements=[12], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [2∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [2∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[6, 3, 2, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [2∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[6, 3, 2], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[6, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3=, elements=[12], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[6, 3, 3, 2], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[6, 3, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[6, 3], randomElementsInRoll=[6∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3=, elements=[16], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], [1∈[1...6]], [6∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 6, 4], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], [1∈[1...6]], [6∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[4, 4, 6, 6], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], [1∈[1...6]], [6∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[4, 4, 6], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], [1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[4, 4], randomElementsInRoll=[4∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[6], randomElementsInRoll=[1∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3=, elements=[13], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], [3∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[6, 4, 3], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], [3∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[4, 3, 3, 6], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], [3∈[1...6]], [6∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[4, 3, 3], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[4, 3], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], [3∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[4], randomElementsInRoll=[1∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[6], randomElementsInRoll=[6∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3=, elements=[9], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1)k3, elements=[4, 3, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1+d6rr1), elements=[3, 2, 2, 4], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], [4∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1+d6rr1, elements=[3, 2, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1+d6rr1, elements=[3, 2], randomElementsInRoll=[3∈[1...6]], [2∈[1...6]], childrenRolls=[Roll(expression=(d6rr1, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d6rr1), elements=[4], randomElementsInRoll=[4∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -6x3d6=|[Roll(expression=3d6=, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[6], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[4, 1, 1], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[11], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[6, 3, 2], randomElementsInRoll=[6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[12], randomElementsInRoll=[3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[3, 6, 3], randomElementsInRoll=[3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[9], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[3, 2, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=3d6=, elements=[11], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=3d6, elements=[4, 1, 6], randomElementsInRoll=[4∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -6x4d6k3=|[Roll(expression=4d6k3=, elements=[9], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[10], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 3, 1], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 1, 6, 3], randomElementsInRoll=[1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[12], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 3, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[2, 3, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[11], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[4, 4, 3], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[3, 2, 4, 4], randomElementsInRoll=[3∈[1...6], 2∈[1...6], 4∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[13], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[1, 6, 6, 1], randomElementsInRoll=[1∈[1...6], 6∈[1...6], 6∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4d6k3=, elements=[13], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6k3, elements=[6, 4, 3], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4d6, elements=[4, 3, 3, 6], randomElementsInRoll=[4∈[1...6], 3∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -7|[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])] -79|[Roll(expression=79, elements=[79], randomElementsInRoll=, childrenRolls=[])] -7D6|[Roll(expression=7D6, elements=[2, 3, 1, 4, 1, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -7d10|[Roll(expression=7d10, elements=[6, 3, 1, 10, 1, 5, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -7d10>6|[Roll(expression=7d10>6, elements=[10, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=7d10, elements=[6, 3, 1, 10, 1, 5, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -7d12|[Roll(expression=7d12, elements=[8, 9, 7, 10, 7, 7, 12], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -7d20=|[Roll(expression=7d20=, elements=[96], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20]], childrenRolls=[Roll(expression=7d20, elements=[16, 13, 11, 10, 11, 15, 20], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -7d4|[Roll(expression=7d4, elements=[4, 2, 2, 4, 1, 1, 3], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -7d6|[Roll(expression=7d6, elements=[2, 3, 1, 4, 1, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -7d6=|[Roll(expression=7d6=, elements=[18], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=7d6, elements=[2, 3, 1, 4, 1, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -7d6>4|[Roll(expression=7d6>4, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=7d6, elements=[2, 3, 1, 4, 1, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -8d10|[Roll(expression=8d10, elements=[6, 3, 1, 10, 1, 5, 10, 9], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -8d10>6|[Roll(expression=8d10>6, elements=[10, 10, 9], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10]], childrenRolls=[Roll(expression=8d10, elements=[6, 3, 1, 10, 1, 5, 10, 9], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -8d12=|[Roll(expression=8d12=, elements=[69], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=8d12, elements=[8, 9, 7, 10, 7, 7, 12, 9], randomElementsInRoll=[8∈[1...12], 9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12], 9∈[1...12]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])])] -8d20+0=|[Roll(expression=8d20+0=, elements=[105], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20]], childrenRolls=[Roll(expression=8d20+0, elements=[16, 13, 11, 10, 11, 15, 20, 9, 0], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20]], childrenRolls=[Roll(expression=8d20, elements=[16, 13, 11, 10, 11, 15, 20, 9], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=0, elements=[0], randomElementsInRoll=, childrenRolls=[])])])] -8d20=|[Roll(expression=8d20=, elements=[105], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20]], childrenRolls=[Roll(expression=8d20, elements=[16, 13, 11, 10, 11, 15, 20, 9], randomElementsInRoll=[16∈[1...20], 13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20], 15∈[1...20], 20∈[1...20], 9∈[1...20]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -8d2=|[Roll(expression=8d2=, elements=[13], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2], 1∈[1...2], 1∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=8d2, elements=[2, 2, 2, 2, 1, 1, 1, 2], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2], 1∈[1...2], 1∈[1...2], 2∈[1...2]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -8d4|[Roll(expression=8d4, elements=[4, 2, 2, 4, 1, 1, 3, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -8d4+7d10=|[Roll(expression=8d4+7d10=, elements=[62], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10]], childrenRolls=[Roll(expression=8d4+7d10, elements=[4, 2, 2, 4, 1, 1, 3, 2, 10, 1, 6, 3, 5, 10, 8], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10]], childrenRolls=[Roll(expression=8d4, elements=[4, 2, 2, 4, 1, 1, 3, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7d10, elements=[10, 1, 6, 3, 5, 10, 8], randomElementsInRoll=[10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -8d4=|[Roll(expression=8d4=, elements=[19], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=8d4, elements=[4, 2, 2, 4, 1, 1, 3, 2], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -8d6|[Roll(expression=8d6, elements=[2, 3, 1, 4, 1, 1, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -8d6+7d10=|[Roll(expression=8d6+7d10=, elements=[64], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10]], childrenRolls=[Roll(expression=8d6+7d10, elements=[2, 3, 1, 4, 1, 1, 6, 3, 10, 1, 6, 3, 5, 10, 8], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10]], childrenRolls=[Roll(expression=8d6, elements=[2, 3, 1, 4, 1, 1, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7d10, elements=[10, 1, 6, 3, 5, 10, 8], randomElementsInRoll=[10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -8d6=|[Roll(expression=8d6=, elements=[21], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=8d6, elements=[2, 3, 1, 4, 1, 1, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -8d6>4|[Roll(expression=8d6>4, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=8d6, elements=[2, 3, 1, 4, 1, 1, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -8d8|[Roll(expression=8d8, elements=[8, 2, 6, 4, 5, 5, 7, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -8d8+10d10=|[Roll(expression=8d8+10d10=, elements=[101], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10]], childrenRolls=[Roll(expression=8d8+10d10, elements=[8, 2, 6, 4, 5, 5, 7, 2, 10, 1, 6, 3, 5, 10, 8, 6, 9, 4], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10]], childrenRolls=[Roll(expression=8d8, elements=[8, 2, 6, 4, 5, 5, 7, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10d10, elements=[10, 1, 6, 3, 5, 10, 8, 6, 9, 4], randomElementsInRoll=[10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10], 9∈[1...10], 4∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -8d8+8d10=|[Roll(expression=8d8+8d10=, elements=[88], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=8d8+8d10, elements=[8, 2, 6, 4, 5, 5, 7, 2, 10, 1, 6, 3, 5, 10, 8, 6], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8]], [10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=8d8, elements=[8, 2, 6, 4, 5, 5, 7, 2], randomElementsInRoll=[8∈[1...8], 2∈[1...8], 6∈[1...8], 4∈[1...8], 5∈[1...8], 5∈[1...8], 7∈[1...8], 2∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8d10, elements=[10, 1, 6, 3, 5, 10, 8, 6], randomElementsInRoll=[10∈[1...10], 1∈[1...10], 6∈[1...10], 3∈[1...10], 5∈[1...10], 10∈[1...10], 8∈[1...10], 6∈[1...10]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -9|[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])] -99|[Roll(expression=99, elements=[99], randomElementsInRoll=, childrenRolls=[])] -999|[Roll(expression=999, elements=[999], randomElementsInRoll=, childrenRolls=[])] -9d10|[Roll(expression=9d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -9d10>6|[Roll(expression=9d10>6, elements=[10, 10, 9, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=9d10, elements=[6, 3, 1, 10, 1, 5, 10, 9, 10], randomElementsInRoll=[6∈[1...10], 3∈[1...10], 1∈[1...10], 10∈[1...10], 1∈[1...10], 5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10]], childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -9d4|[Roll(expression=9d4, elements=[4, 2, 2, 4, 1, 1, 3, 2, 4], randomElementsInRoll=[4∈[1...4], 2∈[1...4], 2∈[1...4], 4∈[1...4], 1∈[1...4], 1∈[1...4], 3∈[1...4], 2∈[1...4], 4∈[1...4]], childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -9d6|[Roll(expression=9d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -9d6>4|[Roll(expression=9d6>4, elements=[6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=9d6, elements=[2, 3, 1, 4, 1, 1, 6, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -D!!10+10|[Roll(expression=D!!10+10, elements=[6, 10], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -D!!10+11|[Roll(expression=D!!10+11, elements=[6, 11], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[])])] -D!!10+12|[Roll(expression=D!!10+12, elements=[6, 12], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -D!!10+13|[Roll(expression=D!!10+13, elements=[6, 13], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[])])] -D!!10+14|[Roll(expression=D!!10+14, elements=[6, 14], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[])])] -D!!10+15|[Roll(expression=D!!10+15, elements=[6, 15], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[])])] -D!!10+16|[Roll(expression=D!!10+16, elements=[6, 16], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -D!!10+17|[Roll(expression=D!!10+17, elements=[6, 17], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])])] -D!!10+18|[Roll(expression=D!!10+18, elements=[6, 18], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -D!!10+19|[Roll(expression=D!!10+19, elements=[6, 19], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=19, elements=[19], randomElementsInRoll=, childrenRolls=[])])] -D!!10+20|[Roll(expression=D!!10+20, elements=[6, 20], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -D!!10+6|[Roll(expression=D!!10+6, elements=[6, 6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -D!!10+7|[Roll(expression=D!!10+7, elements=[6, 7], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -D!!10+8|[Roll(expression=D!!10+8, elements=[6, 8], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -D10|[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -D10+10|[Roll(expression=D10+10, elements=[6, 10], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -D10+11|[Roll(expression=D10+11, elements=[6, 11], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[])])] -D10+12|[Roll(expression=D10+12, elements=[6, 12], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -D10+13|[Roll(expression=D10+13, elements=[6, 13], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[])])] -D10+14|[Roll(expression=D10+14, elements=[6, 14], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[])])] -D10+15|[Roll(expression=D10+15, elements=[6, 15], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[])])] -D10+16|[Roll(expression=D10+16, elements=[6, 16], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -D10+17|[Roll(expression=D10+17, elements=[6, 17], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])])] -D10+18|[Roll(expression=D10+18, elements=[6, 18], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -D10+19|[Roll(expression=D10+19, elements=[6, 19], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=19, elements=[19], randomElementsInRoll=, childrenRolls=[])])] -D10+20|[Roll(expression=D10+20, elements=[6, 20], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -D10+6|[Roll(expression=D10+6, elements=[6, 6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -D10+7|[Roll(expression=D10+7, elements=[6, 7], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -D10+8|[Roll(expression=D10+8, elements=[6, 8], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=D10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -D100|[Roll(expression=D100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -D100k2|[Roll(expression=D100k2, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=D100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -D100l2|[Roll(expression=D100l2, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=D100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -D12|[Roll(expression=D12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -D20|[Roll(expression=D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -D20+3|[Roll(expression=D20+3, elements=[16, 3], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -D20+5|[Roll(expression=D20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -D3|[Roll(expression=D3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -D4|[Roll(expression=D4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -D4+D4|[Roll(expression=D4+D4, elements=[4, 2], randomElementsInRoll=[4∈[1...4]], [2∈[1...4]], childrenRolls=[Roll(expression=D4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=D4, elements=[2], randomElementsInRoll=[2∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -D6|[Roll(expression=D6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -D8|[Roll(expression=D8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -D8=|[Roll(expression=D8=, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=D8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -[1D6]|[Roll(expression=[1D6], elements=[1D6], randomElementsInRoll=, childrenRolls=[])] -[1_button:1D6]|[Roll(expression=[1_button:1D6], elements=[1_button:1D6], randomElementsInRoll=, childrenRolls=[])] -[1d10+1d10]|[Roll(expression=[1d10+1d10], elements=[1d10+1d10], randomElementsInRoll=, childrenRolls=[])] -[4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=]k6|[Roll(expression=[4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=]k6, elements=[4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=], randomElementsInRoll=, childrenRolls=[Roll(expression=[4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=], elements=[4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -asc(2d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=asc(2d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(2d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -asc(d6)|[Roll(expression=asc(d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(d6), elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -asc(d6c)|[Roll(expression=asc(d6c), elements=[1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(d6c), elements=[1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])])] -color(10d6,'red')|[Roll(expression=color(10d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2, red:3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(11d6,'red')|[Roll(expression=color(11d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2, red:3, red:6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=(11, elements=[11], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(12d6,'red')|[Roll(expression=color(12d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2, red:3, red:6, red:3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(1D20+5=,'green')|[Roll(expression=color(1D20+5=,'green'), elements=[green:21], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1D20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1D20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -color(1d6,'red')|[Roll(expression=color(1d6,'red'), elements=[red:2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(1d6-1, 'red')|[Roll(expression=color(1d6-1,'red'), elements=[red:2, red:-1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -color(2d6,'red')|[Roll(expression=color(2d6,'red'), elements=[red:2, red:3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(3d6,'red')|[Roll(expression=color(3d6,'red'), elements=[red:2, red:3, red:1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(4d6,'red')|[Roll(expression=color(4d6,'red'), elements=[red:2, red:3, red:1, red:4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(5d6,'red')|[Roll(expression=color(5d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(69, 'cyan')|[Roll(expression=color(69,'cyan'), elements=[cyan:69], randomElementsInRoll=, childrenRolls=[])] -color(6d6,'red')|[Roll(expression=color(6d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1, red:1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(7d6,'red')|[Roll(expression=color(7d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=(7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(8d6,'red')|[Roll(expression=color(8d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(9d6,'red')|[Roll(expression=color(9d6,'red'), elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=(9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -color(D4, 'red')|[Roll(expression=color(D4,'red'), elements=[red:4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -color(d100, 'purple')|[Roll(expression=color(d100,'purple'), elements=[purple:96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -color(d20, 'red')|[Roll(expression=color(d20,'red'), elements=[red:16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -concat(2d6=,-2d3k1)|[Roll(expression=concat(2d6=,-2d3k1), elements=[5-1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2d6=, elements=[5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=-2d3k1), elements=[-1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=-2d3, elements=[-1, -1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -concat(2d6=,-2d3k1=)|[Roll(expression=concat(2d6=,-2d3k1=), elements=[5-1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2d6=, elements=[5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=-2d3k1=), elements=[-1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=-2d3k1, elements=[-1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=-2d3, elements=[-1, -1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])])] -concat(2d6=,-2d3l1)|[Roll(expression=concat(2d6=,-2d3l1), elements=[5-1], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], [1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=(2d6=, elements=[5], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6, elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=-2d3l1), elements=[-1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=-2d3, elements=[-1, -1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2d3, elements=[1, 1], randomElementsInRoll=[1∈[1...3], 1∈[1...3]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=1), elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -d!!10|[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -d!!10+10|[Roll(expression=d!!10+10, elements=[6, 10], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -d!!10+11|[Roll(expression=d!!10+11, elements=[6, 11], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[])])] -d!!10+12|[Roll(expression=d!!10+12, elements=[6, 12], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -d!!10+13|[Roll(expression=d!!10+13, elements=[6, 13], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[])])] -d!!10+14|[Roll(expression=d!!10+14, elements=[6, 14], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[])])] -d!!10+15|[Roll(expression=d!!10+15, elements=[6, 15], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[])])] -d!!10+16|[Roll(expression=d!!10+16, elements=[6, 16], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -d!!10+17|[Roll(expression=d!!10+17, elements=[6, 17], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])])] -d!!10+18|[Roll(expression=d!!10+18, elements=[6, 18], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -d!!10+19|[Roll(expression=d!!10+19, elements=[6, 19], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=19, elements=[19], randomElementsInRoll=, childrenRolls=[])])] -d!!10+20|[Roll(expression=d!!10+20, elements=[6, 20], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -d!!10+6|[Roll(expression=d!!10+6, elements=[6, 6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -d!!10+7|[Roll(expression=d!!10+7, elements=[6, 7], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -d!!10+8|[Roll(expression=d!!10+8, elements=[6, 8], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -d!!10+9|[Roll(expression=d!!10+9, elements=[6, 9], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])] -d!!2|[Roll(expression=d!!2, elements=[9], randomElementsInRoll=[2∈[1...2], 2∈[1...2], 2∈[1...2], 2∈[1...2], 1∈[1...2]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -d10|[Roll(expression=d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])])] -d10+7|[Roll(expression=d10+7, elements=[6, 7], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -d10+9|[Roll(expression=d10+9, elements=[6, 9], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])] -d100|[Roll(expression=d100, elements=[96], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -d10d12|[Roll(expression=d10d12, elements=[9, 7, 10, 7, 7, 12], randomElementsInRoll=[6∈[1...10]], [9∈[1...12], 7∈[1...12], 10∈[1...12], 7∈[1...12], 7∈[1...12], 12∈[1...12]], childrenRolls=[Roll(expression=d10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -d11|[Roll(expression=d11, elements=[4], randomElementsInRoll=[4∈[1...11]], childrenRolls=[Roll(expression=11, elements=[11], randomElementsInRoll=, childrenRolls=[])])] -d12|[Roll(expression=d12, elements=[8], randomElementsInRoll=[8∈[1...12]], childrenRolls=[Roll(expression=12, elements=[12], randomElementsInRoll=, childrenRolls=[])])] -d13|[Roll(expression=d13, elements=[6], randomElementsInRoll=[6∈[1...13]], childrenRolls=[Roll(expression=13, elements=[13], randomElementsInRoll=, childrenRolls=[])])] -d14|[Roll(expression=d14, elements=[2], randomElementsInRoll=[2∈[1...14]], childrenRolls=[Roll(expression=14, elements=[14], randomElementsInRoll=, childrenRolls=[])])] -d15|[Roll(expression=d15, elements=[11], randomElementsInRoll=[11∈[1...15]], childrenRolls=[Roll(expression=15, elements=[15], randomElementsInRoll=, childrenRolls=[])])] -d16|[Roll(expression=d16, elements=[16], randomElementsInRoll=[16∈[1...16]], childrenRolls=[Roll(expression=16, elements=[16], randomElementsInRoll=, childrenRolls=[])])] -d17|[Roll(expression=d17, elements=[2], randomElementsInRoll=[2∈[1...17]], childrenRolls=[Roll(expression=17, elements=[17], randomElementsInRoll=, childrenRolls=[])])] -d18|[Roll(expression=d18, elements=[14], randomElementsInRoll=[14∈[1...18]], childrenRolls=[Roll(expression=18, elements=[18], randomElementsInRoll=, childrenRolls=[])])] -d19|[Roll(expression=d19, elements=[18], randomElementsInRoll=[18∈[1...19]], childrenRolls=[Roll(expression=19, elements=[19], randomElementsInRoll=, childrenRolls=[])])] -d2|[Roll(expression=d2, elements=[2], randomElementsInRoll=[2∈[1...2]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -d20|[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -d20 d100|[Roll(expression=d20d100, elements=[73, 51, 30, 51, 55, 60, 29, 100, 41, 66, 13, 55, 80, 28, 36, 19], randomElementsInRoll=[16∈[1...20]], [73∈[1...100], 51∈[1...100], 30∈[1...100], 51∈[1...100], 55∈[1...100], 60∈[1...100], 29∈[1...100], 100∈[1...100], 41∈[1...100], 66∈[1...100], 13∈[1...100], 55∈[1...100], 80∈[1...100], 28∈[1...100], 36∈[1...100], 19∈[1...100]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -d20 + 8|[Roll(expression=d20+8, elements=[16, 8], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -d20+1=|[Roll(expression=d20+1=, elements=[17], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20+1, elements=[16, 1], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -d20+2|[Roll(expression=d20+2, elements=[16, 2], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])] -d20+2=|[Roll(expression=d20+2=, elements=[18], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20+2, elements=[16, 2], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -d20+3=|[Roll(expression=d20+3=, elements=[19], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20+3, elements=[16, 3], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -d20+4|[Roll(expression=d20+4, elements=[16, 4], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -d20+4=|[Roll(expression=d20+4=, elements=[20], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20+4, elements=[16, 4], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -d20+5|[Roll(expression=d20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -d20+5=|[Roll(expression=d20+5=, elements=[21], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20+5, elements=[16, 5], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -d20, 3d20|[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d20, elements=[13, 11, 10], randomElementsInRoll=[13∈[1...20], 11∈[1...20], 10∈[1...20]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -d20, d100|[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d100, elements=[73], randomElementsInRoll=[73∈[1...100]], childrenRolls=[Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -d20,4d20,5d10,2d6|[Roll(expression=d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=4d20, elements=[13, 11, 10, 11], randomElementsInRoll=[13∈[1...20], 11∈[1...20], 10∈[1...20], 11∈[1...20]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5d10, elements=[5, 10, 9, 10, 1], randomElementsInRoll=[5∈[1...10], 10∈[1...10], 9∈[1...10], 10∈[1...10], 1∈[1...10]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[6, 3], randomElementsInRoll=[6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -d24|[Roll(expression=d24, elements=[8], randomElementsInRoll=[8∈[1...24]], childrenRolls=[Roll(expression=24, elements=[24], randomElementsInRoll=, childrenRolls=[])])] -d3|[Roll(expression=d3, elements=[2], randomElementsInRoll=[2∈[1...3]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])] -d30|[Roll(expression=d30, elements=[26], randomElementsInRoll=[26∈[1...30]], childrenRolls=[Roll(expression=30, elements=[30], randomElementsInRoll=, childrenRolls=[])])] -d4|[Roll(expression=d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -d4+1=|[Roll(expression=d4+1=, elements=[5], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=d4+1, elements=[4, 1], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -d4+3=|[Roll(expression=d4+3=, elements=[7], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=d4+3, elements=[4, 3], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=d4, elements=[4], randomElementsInRoll=[4∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -d420|[Roll(expression=d420, elements=[296], randomElementsInRoll=[296∈[1...420]], childrenRolls=[Roll(expression=420, elements=[420], randomElementsInRoll=, childrenRolls=[])])] -d47|[Roll(expression=d47, elements=[45], randomElementsInRoll=[45∈[1...47]], childrenRolls=[Roll(expression=47, elements=[47], randomElementsInRoll=, childrenRolls=[])])] -d5|[Roll(expression=d5, elements=[1], randomElementsInRoll=[1∈[1...5]], childrenRolls=[Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])] -d6|[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -d6 x2|[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])] -d6+1=|[Roll(expression=d6+1=, elements=[3], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=d6+1, elements=[2, 1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -d6, 2d6|[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -d6, d6|[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -d6,2d6|[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -d6,2d6=|[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2d6=, elements=[4], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2d6, elements=[3, 1], randomElementsInRoll=[3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -d6,3d6|[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3d6, elements=[3, 1, 4], randomElementsInRoll=[3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -d6-1|[Roll(expression=d6-1, elements=[2, -1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -d6-1, d6, d6+1|[Roll(expression=d6-1, elements=[2, -1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6, elements=[3], randomElementsInRoll=[3∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d6+1, elements=[1, 1], randomElementsInRoll=[1∈[1...6]], childrenRolls=[Roll(expression=d6, elements=[1], randomElementsInRoll=[1∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -d6-1=|[Roll(expression=d6-1=, elements=[1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=d6-1, elements=[2, -1], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=d6, elements=[2], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -d69|[Roll(expression=d69, elements=[68], randomElementsInRoll=[68∈[1...69]], childrenRolls=[Roll(expression=69, elements=[69], randomElementsInRoll=, childrenRolls=[])])] -d7|[Roll(expression=d7, elements=[2], randomElementsInRoll=[2∈[1...7]], childrenRolls=[Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -d8|[Roll(expression=d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])] -d8 + 10 + d4 +d4|[Roll(expression=d8+10+d4+d4, elements=[8, 10, 2, 2], randomElementsInRoll=[8∈[1...8]], [2∈[1...4]], [2∈[1...4]], childrenRolls=[Roll(expression=d8+10+d4, elements=[8, 10, 2], randomElementsInRoll=[8∈[1...8]], [2∈[1...4]], childrenRolls=[Roll(expression=d8+10, elements=[8, 10], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=d4, elements=[2], randomElementsInRoll=[2∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=d4, elements=[2], randomElementsInRoll=[2∈[1...4]], childrenRolls=[Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -d8+1=|[Roll(expression=d8+1=, elements=[9], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=d8+1, elements=[8, 1], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])])] -d8+3=|[Roll(expression=d8+3=, elements=[11], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=d8+3, elements=[8, 3], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=3, elements=[3], randomElementsInRoll=, childrenRolls=[])])])] -d8+5=|[Roll(expression=d8+5=, elements=[13], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=d8+5, elements=[8, 5], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=d8, elements=[8], randomElementsInRoll=[8∈[1...8]], childrenRolls=[Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=5, elements=[5], randomElementsInRoll=, childrenRolls=[])])])] -d9|[Roll(expression=d9, elements=[5], randomElementsInRoll=[5∈[1...9]], childrenRolls=[Roll(expression=9, elements=[9], randomElementsInRoll=, childrenRolls=[])])] -d[-1/0/1/1/2/3]=|[Roll(expression=d[-1/0/1/1/2/3]=, elements=[0], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=d[-1/0/1/1/2/3], elements=[0], randomElementsInRoll=[0∈[-1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=[-1/0/1/1/2/3], elements=[-1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -d[-1/0/1/2/3]|[Roll(expression=d[-1/0/1/2/3], elements=[-1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])] -d[-1/0/1/2/3]=|[Roll(expression=d[-1/0/1/2/3]=, elements=[-1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=d[-1/0/1/2/3], elements=[-1], randomElementsInRoll=[-1∈[-1, 0, 1, 2, 3]], childrenRolls=[Roll(expression=[-1/0/1/2/3], elements=[-1, 0, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -d[-9/-8/-7/-6/-5/-4/-3/-2/-1/0/2/2/2/2/2/2/2/2/2/2/3/3/3/3/3/3/3/3/3/3/4/4/4/4/4/4/4/4/4/4/5/5/5/5/5/5/5/5/5/5/6/6/6/6/6/6/6/6/6/6/7/7/7/7/7/7/7/7/7/7/8/8/8/8/8/8/8/8/8/8/9/9/9/9/9/9/9/9/9/9/11/12/13/14/15/16/17/18/19/20]|[Roll(expression=d[-9/-8/-7/-6/-5/-4/-3/-2/-1/0/2/2/2/2/2/2/2/2/2/2/3/3/3/3/3/3/3/3/3/3/4/4/4/4/4/4/4/4/4/4/5/5/5/5/5/5/5/5/5/5/6/6/6/6/6/6/6/6/6/6/7/7/7/7/7/7/7/7/7/7/8/8/8/8/8/8/8/8/8/8/9/9/9/9/9/9/9/9/9/9/11/12/13/14/15/16/17/18/19/20], elements=[16], randomElementsInRoll=[16∈[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]], childrenRolls=[Roll(expression=[-9/-8/-7/-6/-5/-4/-3/-2/-1/0/2/2/2/2/2/2/2/2/2/2/3/3/3/3/3/3/3/3/3/3/4/4/4/4/4/4/4/4/4/4/5/5/5/5/5/5/5/5/5/5/6/6/6/6/6/6/6/6/6/6/7/7/7/7/7/7/7/7/7/7/8/8/8/8/8/8/8/8/8/8/9/9/9/9/9/9/9/9/9/9/11/12/13/14/15/16/17/18/19/20], elements=[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], randomElementsInRoll=, childrenRolls=[])])] -d[1,2,3,0,0,-1]|[Roll(expression=d[1,2,3,0,0,-1], elements=[2], randomElementsInRoll=[2∈[1, 2, 3, 0, 0, -1]], childrenRolls=[Roll(expression=[1,2,3,0,0,-1], elements=[1, 2, 3, 0, 0, -1], randomElementsInRoll=, childrenRolls=[])])] -d[1/0/1/1/2/3]=|[Roll(expression=d[1/0/1/1/2/3]=, elements=[0], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=d[1/0/1/1/2/3], elements=[0], randomElementsInRoll=[0∈[1, 0, 1, 1, 2, 3]], childrenRolls=[Roll(expression=[1/0/1/1/2/3], elements=[1, 0, 1, 1, 2, 3], randomElementsInRoll=, childrenRolls=[])])])] -d[1/2/3/0/0/-1]|[Roll(expression=d[1/2/3/0/0/-1], elements=[2], randomElementsInRoll=[2∈[1, 2, 3, 0, 0, -1]], childrenRolls=[Roll(expression=[1/2/3/0/0/-1], elements=[1, 2, 3, 0, 0, -1], randomElementsInRoll=, childrenRolls=[])])] -d[11/12/13/14/15/16/21/22/23/24/25/26/31/32/33/34/35/36/41/42/43/44/45/46/51/52/53/54/55/56/61/62/63/64/65/66]|[Roll(expression=d[11/12/13/14/15/16/21/22/23/24/25/26/31/32/33/34/35/36/41/42/43/44/45/46/51/52/53/54/55/56/61/62/63/64/65/66], elements=[62], randomElementsInRoll=[62∈[11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52, 53, 54, 55, 56, 61, 62, 63, 64, 65, 66]], childrenRolls=[Roll(expression=[11/12/13/14/15/16/21/22/23/24/25/26/31/32/33/34/35/36/41/42/43/44/45/46/51/52/53/54/55/56/61/62/63/64/65/66], elements=[11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52, 53, 54, 55, 56, 61, 62, 63, 64, 65, 66], randomElementsInRoll=, childrenRolls=[])])] -d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll(expression=d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=, elements=[2], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[2], randomElementsInRoll=[2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]], childrenRolls=[Roll(expression=[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0], elements=[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], randomElementsInRoll=, childrenRolls=[])])])] -d[destreza/fuerza/inteligencia/sabiduria/Doom]+1d8|[Roll(expression=d[destreza/fuerza/inteligencia/sabiduria/Doom]+1d8, elements=[destreza, 2], randomElementsInRoll=[destreza∈[destreza, fuerza, inteligencia, sabiduria, Doom]], [2∈[1...8]], childrenRolls=[Roll(expression=d[destreza/fuerza/inteligencia/sabiduria/Doom], elements=[destreza], randomElementsInRoll=[destreza∈[destreza, fuerza, inteligencia, sabiduria, Doom]], childrenRolls=[Roll(expression=[destreza/fuerza/inteligencia/sabiduria/Doom], elements=[destreza, fuerza, inteligencia, sabiduria, Doom], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d8, elements=[2], randomElementsInRoll=[2∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -d[destreza/fuerza/inteligencia/sabiduria]+1d8|[Roll(expression=d[destreza/fuerza/inteligencia/sabiduria]+1d8, elements=[sabiduria, 2], randomElementsInRoll=[sabiduria∈[destreza, fuerza, inteligencia, sabiduria]], [2∈[1...8]], childrenRolls=[Roll(expression=d[destreza/fuerza/inteligencia/sabiduria], elements=[sabiduria], randomElementsInRoll=[sabiduria∈[destreza, fuerza, inteligencia, sabiduria]], childrenRolls=[Roll(expression=[destreza/fuerza/inteligencia/sabiduria], elements=[destreza, fuerza, inteligencia, sabiduria], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d8, elements=[2], randomElementsInRoll=[2∈[1...8]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=8, elements=[8], randomElementsInRoll=, childrenRolls=[])])])] -d[fuerza/destreza/sabiduria/inteligencia]|[Roll(expression=d[fuerza/destreza/sabiduria/inteligencia], elements=[inteligencia], randomElementsInRoll=[inteligencia∈[fuerza, destreza, sabiduria, inteligencia]], childrenRolls=[Roll(expression=[fuerza/destreza/sabiduria/inteligencia], elements=[fuerza, destreza, sabiduria, inteligencia], randomElementsInRoll=, childrenRolls=[])])] -desc(1d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=desc(1d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(1d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -desc(2d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=desc(2d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(2d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -desc(3d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=desc(3d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(3d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -desc(4d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=desc(4d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Partial, Failure, Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(4d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -desc(5d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=desc(5d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Partial, Failure, Failure, Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(5d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -desc(6d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=desc(6d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Partial, Failure, Failure, Failure, Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(6d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -desc(7d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll(expression=desc(7d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Success, Partial, Failure, Failure, Failure, Failure, Failure], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Success∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(7d[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Failure, Failure, Success], randomElementsInRoll=[Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Partial∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Failure∈[Failure, Failure, Failure, Partial, Partial, Success], Success∈[Failure, Failure, Failure, Partial, Partial, Success]], childrenRolls=[Roll(expression=(7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[Failure/Failure/Failure/Partial/Partial/Success]), elements=[Failure, Failure, Failure, Partial, Partial, Success], randomElementsInRoll=, childrenRolls=[])])])] -groupC (10d6)|[Roll(expression=groupC(10d6), elements=[3x1, 3x3, 2x2, 1x4, 1x6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(10d6), elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (2d6)|[Roll(expression=groupC(2d6), elements=[1x3, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2d6), elements=[2, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (3d6)|[Roll(expression=groupC(3d6), elements=[1x1, 1x3, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3d6), elements=[2, 3, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (4d6)|[Roll(expression=groupC(4d6), elements=[1x1, 1x4, 1x3, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(4d6), elements=[2, 3, 1, 4], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (5d6)|[Roll(expression=groupC(5d6), elements=[2x1, 1x4, 1x3, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(5d6), elements=[2, 3, 1, 4, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (6d6)|[Roll(expression=groupC(6d6), elements=[3x1, 1x4, 1x3, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(6d6), elements=[2, 3, 1, 4, 1, 1], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6]], childrenRolls=[Roll(expression=(6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (7d6)|[Roll(expression=groupC(7d6), elements=[3x1, 1x4, 1x3, 1x6, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=(7d6), elements=[2, 3, 1, 4, 1, 1, 6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6]], childrenRolls=[Roll(expression=(7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (8d6)|[Roll(expression=groupC(8d6), elements=[3x1, 2x3, 1x4, 1x6, 1x2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(8d6), elements=[2, 3, 1, 4, 1, 1, 6, 3], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6]], childrenRolls=[Roll(expression=(8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -groupC (9d6)|[Roll(expression=groupC(9d6), elements=[3x1, 2x3, 2x2, 1x4, 1x6], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=(9d6), elements=[2, 3, 1, 4, 1, 1, 6, 3, 2], randomElementsInRoll=[2∈[1...6], 3∈[1...6], 1∈[1...6], 4∈[1...6], 1∈[1...6], 1∈[1...6], 6∈[1...6], 3∈[1...6], 2∈[1...6]], childrenRolls=[Roll(expression=(9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6), elements=[6], randomElementsInRoll=, childrenRolls=[])])])] -ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Fail')|[Roll(expression=ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Fail'), elements=[Fail], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])])] -ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Failure')|[Roll(expression=ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Failure'), elements=[Failure], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])])] -ifE(2d[0/0/0/1/1/3]l1,3,'Success',1,'Partial','Failure')|[Roll(expression=ifE(2d[0/0/0/1/1/3]l1,3,'Success',1,'Partial','Failure'), elements=[Failure], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2d[0/0/0/1/1/3], elements=[0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[])])] -ifG((1-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((1-1d10)=,0,'Success','Fail'), elements=[Fail], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((1-1d10), elements=[1, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((10-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((10-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((10-1d10), elements=[10, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((10, elements=[10], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((11-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((11-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((11-1d10), elements=[11, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((11, elements=[11], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((12-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((12-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((12-1d10), elements=[12, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((12, elements=[12], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((13-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((13-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((13-1d10), elements=[13, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((13, elements=[13], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((14-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((14-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((14-1d10), elements=[14, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((14, elements=[14], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((15-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((15-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((15-1d10), elements=[15, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((15, elements=[15], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((2-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((2-1d10)=,0,'Success','Fail'), elements=[Fail], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((2-1d10), elements=[2, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((3-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((3-1d10)=,0,'Success','Fail'), elements=[Fail], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((3-1d10), elements=[3, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((4-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((4-1d10)=,0,'Success','Fail'), elements=[Fail], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((4-1d10), elements=[4, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((5-1d10)=,-1,'Success','Fail' )|[Roll(expression=ifG((5-1d10)=,-1,'Success','Fail'), elements=[Fail], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((5-1d10), elements=[5, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((5-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((5-1d10)=,0,'Success','Fail'), elements=[Fail], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((5-1d10), elements=[5, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((6-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((6-1d10)=,0,'Success','Fail'), elements=[Fail], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((6-1d10), elements=[], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((7-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((7-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((7-1d10), elements=[7, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((8-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((8-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((8-1d10), elements=[8, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((8, elements=[8], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG((9-1d10)=,0,'Success','Fail' )|[Roll(expression=ifG((9-1d10)=,0,'Success','Fail'), elements=[Success], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((9-1d10), elements=[9, -6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=((9, elements=[9], randomElementsInRoll=, childrenRolls=[]), Roll(expression=1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -ifG(2d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll(expression=ifG(2d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail'), elements=[Fail], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2d[0/0/0/1/1/3]k2, elements=[0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2d[0/0/0/1/1/3], elements=[0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(2d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll(expression=ifG(2d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure'), elements=[Failure], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2d[0/0/0/1/1/3]k2, elements=[0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2d[0/0/0/1/1/3], elements=[0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(3d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll(expression=ifG(3d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail'), elements=[Fail], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(3d[0/0/0/1/1/3]k2, elements=[0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(3d[0/0/0/1/1/3], elements=[0, 0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(3d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll(expression=ifG(3d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure'), elements=[Failure], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(3d[0/0/0/1/1/3]k2, elements=[0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(3d[0/0/0/1/1/3], elements=[0, 0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(3, elements=[3], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(4d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll(expression=ifG(4d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail'), elements=[Partial], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(4d[0/0/0/1/1/3]k2, elements=[1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(4d[0/0/0/1/1/3], elements=[0, 0, 0, 1], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(4d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll(expression=ifG(4d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure'), elements=[Partial], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(4d[0/0/0/1/1/3]k2, elements=[1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(4d[0/0/0/1/1/3], elements=[0, 0, 0, 1], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(4, elements=[4], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(5d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll(expression=ifG(5d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail'), elements=[Partial], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(5d[0/0/0/1/1/3]k2, elements=[1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(5d[0/0/0/1/1/3], elements=[0, 0, 0, 1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(5d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll(expression=ifG(5d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure'), elements=[Partial], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(5d[0/0/0/1/1/3]k2, elements=[1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(5d[0/0/0/1/1/3], elements=[0, 0, 0, 1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(5, elements=[5], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(6d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll(expression=ifG(6d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail'), elements=[Partial], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(6d[0/0/0/1/1/3]k2, elements=[1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(6d[0/0/0/1/1/3], elements=[0, 0, 0, 1, 0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(6d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll(expression=ifG(6d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure'), elements=[Partial], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(6d[0/0/0/1/1/3]k2, elements=[1, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(6d[0/0/0/1/1/3], elements=[0, 0, 0, 1, 0, 0], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(6, elements=[6], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(7d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll(expression=ifG(7d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail'), elements=[Success], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 3∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(7d[0/0/0/1/1/3]k2, elements=[3, 1], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 3∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(7d[0/0/0/1/1/3], elements=[0, 0, 0, 1, 0, 0, 3], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 3∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifG(7d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll(expression=ifG(7d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure'), elements=[Success], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 3∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(7d[0/0/0/1/1/3]k2, elements=[3, 1], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 3∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(7d[0/0/0/1/1/3], elements=[0, 0, 0, 1, 0, 0, 3], randomElementsInRoll=[0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 1∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 0∈[0, 0, 0, 1, 1, 3], 3∈[0, 0, 0, 1, 1, 3]], childrenRolls=[Roll(expression=(7, elements=[7], randomElementsInRoll=, childrenRolls=[]), Roll(expression=[0/0/0/1/1/3], elements=[0, 0, 0, 1, 1, 3], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=2, elements=[2], randomElementsInRoll=, childrenRolls=[])])])] -ifL(1d100,10,'Réussi','Raté')|[Roll(expression=ifL(1d100,10,'Réussi','Raté'), elements=[Raté], randomElementsInRoll=[96∈[1...100]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=100, elements=[100], randomElementsInRoll=, childrenRolls=[])])] -ifL(1d20,1, '💩 ',10,'😱 ' ,17, '😵‍💫 ' , '🤐 ')|[Roll(expression=ifL(1d20,1,'💩 ',10,'😱 ',17,'😵‍💫 ','🤐 '), elements=[😵‍💫 ], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -ifL(1d20,2, '💩 ',10,'😱 ' ,17, '😵‍💫 ' , '🤐 ')|[Roll(expression=ifL(1d20,2,'💩 ',10,'😱 ',17,'😵‍💫 ','🤐 '), elements=[😵‍💫 ], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -ifL(1d20,2,'💥',20, '💯 ')ifE(1d20,1,'test')|[Roll(expression=ifL(1d20,2,'💥',20,'💯 '), elements=[💯 ], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=ifE(1d20,1,'test'), elements=[13], randomElementsInRoll=[13∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[]), Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])])] -ifL(1d6,3,'low','high')|[Roll(expression=ifL(1d6,3,'low','high'), elements=[low], randomElementsInRoll=[2∈[1...6]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=6, elements=[6], randomElementsInRoll=, childrenRolls=[])])] -max(1d!!10)-min(1d!!10)=|[Roll(expression=max(1d!!10)-min(1d!!10)=, elements=[3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d!!10)-min(1d!!10), elements=[6, -3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d!!10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1d!!10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=min(1d!!10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1d!!10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])])] -max(1d!!10)-min(1d10)=|[Roll(expression=max(1d!!10)-min(1d10)=, elements=[3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d!!10)-min(1d10), elements=[6, -3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d!!10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1d!!10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=min(1d10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1d10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])])] -max(1d!!10-1d10)=|[Roll(expression=max(1d!!10-1d10)=, elements=[6], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d!!10-1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=(1d!!10-1d10), elements=[6, -3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=(1d!!10, elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10, elements=[10], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])])] -max(1d10)-min(1d10)|[Roll(expression=max(1d10)-min(1d10), elements=[6, -3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=min(1d10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1d10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])] -max(1d10)-min(1d10)=|[Roll(expression=max(1d10)-min(1d10)=, elements=[3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d10)-min(1d10), elements=[6, -3], randomElementsInRoll=[6∈[1...10]], [3∈[1...10]], childrenRolls=[Roll(expression=max(1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1d10), elements=[6], randomElementsInRoll=[6∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=min(1d10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1d10), elements=[3], randomElementsInRoll=[3∈[1...10]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=10), elements=[10], randomElementsInRoll=, childrenRolls=[])])])])])] -max(1d20,1d20)|[Roll(expression=max(1d20,1d20), elements=[16], randomElementsInRoll=[16∈[1...20]], [13∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d20), elements=[13], randomElementsInRoll=[13∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -max(1d20,1d20)+4|[Roll(expression=max(1d20,1d20)+4, elements=[16, 4], randomElementsInRoll=[16∈[1...20]], [13∈[1...20]], childrenRolls=[Roll(expression=max(1d20,1d20), elements=[16], randomElementsInRoll=[16∈[1...20]], [13∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d20), elements=[13], randomElementsInRoll=[13∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -max(1d20,1d20)+7|[Roll(expression=max(1d20,1d20)+7, elements=[16, 7], randomElementsInRoll=[16∈[1...20]], [13∈[1...20]], childrenRolls=[Roll(expression=max(1d20,1d20), elements=[16], randomElementsInRoll=[16∈[1...20]], [13∈[1...20]], childrenRolls=[Roll(expression=(1d20, elements=[16], randomElementsInRoll=[16∈[1...20]], childrenRolls=[Roll(expression=(1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20, elements=[20], randomElementsInRoll=, childrenRolls=[])]), Roll(expression=1d20), elements=[13], randomElementsInRoll=[13∈[1...20]], childrenRolls=[Roll(expression=1, elements=[1], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -max(2d20)|[Roll(expression=max(2d20), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20), elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])])] -max(2d20)+4|[Roll(expression=max(2d20)+4, elements=[16, 4], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=max(2d20), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20), elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])] -max(2d20)+4=|[Roll(expression=max(2d20)+4=, elements=[20], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=max(2d20)+4, elements=[16, 4], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=max(2d20), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20), elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=4, elements=[4], randomElementsInRoll=, childrenRolls=[])])])] -max(2d20)+7|[Roll(expression=max(2d20)+7, elements=[16, 7], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=max(2d20), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20), elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])] -max(2d20)+7=|[Roll(expression=max(2d20)+7=, elements=[23], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=max(2d20)+7, elements=[16, 7], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=max(2d20), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20), elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])]), Roll(expression=7, elements=[7], randomElementsInRoll=, childrenRolls=[])])])] -max(2d20)=|[Roll(expression=max(2d20)=, elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=max(2d20), elements=[16], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2d20), elements=[16, 13], randomElementsInRoll=[16∈[1...20], 13∈[1...20]], childrenRolls=[Roll(expression=(2, elements=[2], randomElementsInRoll=, childrenRolls=[]), Roll(expression=20), elements=[20], randomElementsInRoll=, childrenRolls=[])])])])] \ No newline at end of file +'1d20'|[Roll{expression=''1d20'', randomElementsInRoll=[], elements=[1d20]}] +'d'|[Roll{expression=''d'', randomElementsInRoll=[], elements=[d]}] +'1d20'|[Roll{expression=''1d20'', randomElementsInRoll=[], elements=[1d20]}] +'d'|[Roll{expression=''d'', randomElementsInRoll=[], elements=[d]}] +'d20'|[Roll{expression=''d20'', randomElementsInRoll=[], elements=[d20]}] +(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=))k6|[Roll{expression='(((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=)+((4d4k3)=))k6', randomElementsInRoll=[[4de0i0r0=4∈[1...4], 4de0i1r0=2∈[1...4], 4de0i2r0=2∈[1...4], 4de0i3r0=4∈[1...4]], [15de0i0r0=1∈[1...4], 15de0i1r0=1∈[1...4], 15de0i2r0=3∈[1...4], 15de0i3r0=2∈[1...4]], [26de0i0r0=4∈[1...4], 26de0i1r0=1∈[1...4], 26de0i2r0=4∈[1...4], 26de0i3r0=2∈[1...4]], [37de0i0r0=2∈[1...4], 37de0i1r0=4∈[1...4], 37de0i2r0=4∈[1...4], 37de0i3r0=3∈[1...4]], [48de0i0r0=1∈[1...4], 48de0i1r0=3∈[1...4], 48de0i2r0=4∈[1...4], 48de0i3r0=1∈[1...4]], [59de0i0r0=4∈[1...4], 59de0i1r0=1∈[1...4], 59de0i2r0=2∈[1...4], 59de0i3r0=4∈[1...4]], [70de0i0r0=2∈[1...4], 70de0i1r0=4∈[1...4], 70de0i2r0=3∈[1...4], 70de0i3r0=4∈[1...4]]], elements=[11, 11, 10, 10, 10, 8]}] +(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=))k6|[Roll{expression='(((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=)+((4d6k3)=))k6', randomElementsInRoll=[[4de0i0r0=2∈[1...6], 4de0i1r0=3∈[1...6], 4de0i2r0=1∈[1...6], 4de0i3r0=4∈[1...6]], [15de0i0r0=1∈[1...6], 15de0i1r0=1∈[1...6], 15de0i2r0=6∈[1...6], 15de0i3r0=3∈[1...6]], [26de0i0r0=2∈[1...6], 26de0i1r0=3∈[1...6], 26de0i2r0=6∈[1...6], 26de0i3r0=3∈[1...6]], [37de0i0r0=3∈[1...6], 37de0i1r0=2∈[1...6], 37de0i2r0=4∈[1...6], 37de0i3r0=4∈[1...6]], [48de0i0r0=1∈[1...6], 48de0i1r0=6∈[1...6], 48de0i2r0=6∈[1...6], 48de0i3r0=1∈[1...6]], [59de0i0r0=4∈[1...6], 59de0i1r0=3∈[1...6], 59de0i2r0=3∈[1...6], 59de0i3r0=6∈[1...6]], [70de0i0r0=3∈[1...6], 70de0i1r0=2∈[1...6], 70de0i2r0=2∈[1...6], 70de0i3r0=4∈[1...6]]], elements=[13, 13, 12, 11, 10, 9]}] +(1-d10)|[Roll{expression='(1-d10)', randomElementsInRoll=[[3de0i0r0=6∈[1...10]]], elements=[1, -6]}] +(1D20+5)|[Roll{expression='(1D20+5)', randomElementsInRoll=[[2De0i0r0=16∈[1...20]]], elements=[16, 5]}] +(1d10)d2|[Roll{expression='(1d10)d2', randomElementsInRoll=[[2de0i0r0=6∈[1...10]], [6de0i0r0=2∈[1...2], 6de0i1r0=2∈[1...2], 6de0i2r0=2∈[1...2], 6de0i3r0=1∈[1...2], 6de0i4r0=1∈[1...2], 6de0i5r0=1∈[1...2]]], elements=[2, 2, 2, 1, 1, 1]}] +(1d20)|[Roll{expression='(1d20)', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[16]}] +(1d20), (2d20), (3d20)|[Roll{expression='(1d20)', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[16]}, Roll{expression='(2d20)', randomElementsInRoll=[[10de0i0r0=13∈[1...20], 10de0i1r0=11∈[1...20]]], elements=[13, 11]}, Roll{expression='(3d20)', randomElementsInRoll=[[18de0i0r0=10∈[1...20], 18de0i1r0=11∈[1...20], 18de0i2r0=15∈[1...20]]], elements=[10, 11, 15]}] +(1d20+1)=|[Roll{expression='(1d20+1)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[17]}] +(1d20+2)=|[Roll{expression='(1d20+2)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[18]}] +(1d20+3)=|[Roll{expression='(1d20+3)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[19]}] +(1d20+4)=|[Roll{expression='(1d20+4)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[20]}] +(1d20+5)=|[Roll{expression='(1d20+5)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[21]}] +(1d20+6)=|[Roll{expression='(1d20+6)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[22]}] +(1d20-1)=|[Roll{expression='(1d20-1)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[15]}] +(1d20-2)=|[Roll{expression='(1d20-2)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[14]}] +(1d20-3)=|[Roll{expression='(1d20-3)=', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[13]}] +(1d6)|[Roll{expression='(1d6)', randomElementsInRoll=[[2de0i0r0=2∈[1...6]]], elements=[2]}] +(1d6=)*10(+1d6=)|[Roll{expression='(1d6=)', randomElementsInRoll=[[2de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='10*(+1d6=)', randomElementsInRoll=[[12de0i0r0=3∈[1...6]]], elements=[30]}] +(1d6=)*10(1d6=)|[Roll{expression='(1d6=)', randomElementsInRoll=[[2de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='10*(1d6=)', randomElementsInRoll=[[11de0i0r0=3∈[1...6]]], elements=[30]}] +(2D20L1)+5|[Roll{expression='(2D20L1)+5', randomElementsInRoll=[[2De0i0r0=16∈[1...20], 2De0i1r0=13∈[1...20]]], elements=[13, 5]}] +(2D20k1)+5|[Roll{expression='(2D20k1)+5', randomElementsInRoll=[[2De0i0r0=16∈[1...20], 2De0i1r0=13∈[1...20]]], elements=[16, 5]}] +(2d20L1)|[Roll{expression='(2d20L1)', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20]]], elements=[13]}] +(2d20k1)|[Roll{expression='(2d20k1)', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20]]], elements=[16]}] +(2d6)|[Roll{expression='(2d6)', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6]]], elements=[2, 3]}] +(3d20k1)|[Roll{expression='(3d20k1)', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20], 2de0i2r0=11∈[1...20]]], elements=[16]}] +(3d6)|[Roll{expression='(3d6)', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6]]], elements=[2, 3, 1]}] +(3d6=)*10|[Roll{expression='(3d6=)*10', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6]]], elements=[60]}] +(4d10-2)|[Roll{expression='(4d10-2)', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10]]], elements=[6, 3, 1, 10, -2]}] +(4d6)|[Roll{expression='(4d6)', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6]]], elements=[2, 3, 1, 4]}] +(5d6)|[Roll{expression='(5d6)', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6]]], elements=[2, 3, 1, 4, 1]}] +(6d6)|[Roll{expression='(6d6)', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6]]], elements=[2, 3, 1, 4, 1, 1]}] +(7d6)|[Roll{expression='(7d6)', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6]}] +(ifE(1d20,1,1d20)+ifE(1d20,1,1d20))k1|[Roll{expression='(ifE(1d20,1,1d20)+ifE(1d20,1,1d20))k1', randomElementsInRoll=[[6de0i0r0=16∈[1...20]], [23de0i0r0=11∈[1...20]]], elements=[16]}] +(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=,(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=|[Roll{expression='(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=', randomElementsInRoll=[[6de0i0r0=2∈[1...6]], [21de0i0r0=1∈[1...6]], [27de0i0r0=4∈[1...6]], [36de0i0r0=1∈[1...6]], [42de0i0r0=1∈[1...6]], [51de0i0r0=6∈[1...6]]], elements=[12]}, Roll{expression='(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=', randomElementsInRoll=[[71de0i0r0=2∈[1...6]], [86de0i0r0=6∈[1...6]], [101de0i0r0=3∈[1...6]], [116de0i0r0=4∈[1...6]]], elements=[13]}, Roll{expression='(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=', randomElementsInRoll=[[136de0i0r0=1∈[1...6]], [142de0i0r0=6∈[1...6]], [151de0i0r0=6∈[1...6]], [166de0i0r0=4∈[1...6]], [181de0i0r0=3∈[1...6]]], elements=[16]}, Roll{expression='(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=', randomElementsInRoll=[[201de0i0r0=3∈[1...6]], [216de0i0r0=2∈[1...6]], [231de0i0r0=2∈[1...6]], [246de0i0r0=5∈[1...6]]], elements=[10]}, Roll{expression='(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=', randomElementsInRoll=[[266de0i0r0=5∈[1...6]], [281de0i0r0=3∈[1...6]], [296de0i0r0=4∈[1...6]], [311de0i0r0=2∈[1...6]]], elements=[12]}, Roll{expression='(ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6)+ifE(1d6,1,1d6))k3=', randomElementsInRoll=[[331de0i0r0=2∈[1...6]], [346de0i0r0=1∈[1...6]], [352de0i0r0=1∈[1...6]], [361de0i0r0=3∈[1...6]], [376de0i0r0=2∈[1...6]]], elements=[7]}] ++ 1|[Roll{expression='+1', randomElementsInRoll=[], elements=[1]}] ++ 10|[Roll{expression='+10', randomElementsInRoll=[], elements=[10]}] ++ 2|[Roll{expression='+2', randomElementsInRoll=[], elements=[2]}] ++ 3|[Roll{expression='+3', randomElementsInRoll=[], elements=[3]}] ++ 4|[Roll{expression='+4', randomElementsInRoll=[], elements=[4]}] ++ 5|[Roll{expression='+5', randomElementsInRoll=[], elements=[5]}] ++ 6|[Roll{expression='+6', randomElementsInRoll=[], elements=[6]}] ++ 7|[Roll{expression='+7', randomElementsInRoll=[], elements=[7]}] ++ 8|[Roll{expression='+8', randomElementsInRoll=[], elements=[8]}] ++ 9|[Roll{expression='+9', randomElementsInRoll=[], elements=[9]}] ++(3d6k2)|[Roll{expression='+(3d6k2)', randomElementsInRoll=[[3de0i0r0=2∈[1...6], 3de0i1r0=3∈[1...6], 3de0i2r0=1∈[1...6]]], elements=[3, 2]}] ++(3d6l2)|[Roll{expression='+(3d6l2)', randomElementsInRoll=[[3de0i0r0=2∈[1...6], 3de0i1r0=3∈[1...6], 3de0i2r0=1∈[1...6]]], elements=[1, 2]}] ++1|[Roll{expression='+1', randomElementsInRoll=[], elements=[1]}] ++100|[Roll{expression='+100', randomElementsInRoll=[], elements=[100]}] ++1d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll{expression='+1d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼')', randomElementsInRoll=[[2de0i0r0= △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]]], elements=[ △]}] ++1d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll{expression='+1d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△')', randomElementsInRoll=[[2de0i0r0= ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]]], elements=[ ⧼△]}] ++1d10|[Roll{expression='+1d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10]]], elements=[6]}] ++1d100|[Roll{expression='+1d100', randomElementsInRoll=[[2de0i0r0=96∈[1...100]]], elements=[96]}] ++1d12|[Roll{expression='+1d12', randomElementsInRoll=[[2de0i0r0=8∈[1...12]]], elements=[8]}] ++1d20|[Roll{expression='+1d20', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[16]}] ++1d3|[Roll{expression='+1d3', randomElementsInRoll=[[2de0i0r0=2∈[1...3]]], elements=[2]}] ++1d4|[Roll{expression='+1d4', randomElementsInRoll=[[2de0i0r0=4∈[1...4]]], elements=[4]}] ++1d6|[Roll{expression='+1d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6]]], elements=[2]}] ++1d8|[Roll{expression='+1d8', randomElementsInRoll=[[2de0i0r0=8∈[1...8]]], elements=[8]}] ++2|[Roll{expression='+2', randomElementsInRoll=[], elements=[2]}] ++2d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll{expression='+2d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼')', randomElementsInRoll=[[2de0i0r0= △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i1r0= ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]]], elements=[ △, ⧼]}] ++2d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll{expression='+2d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△')', randomElementsInRoll=[[2de0i0r0= ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], 2de0i1r0= ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]]], elements=[ ⧼△, ⧼△]}] ++2d10|[Roll{expression='+2d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10]]], elements=[6, 3]}] ++2d12|[Roll{expression='+2d12', randomElementsInRoll=[[2de0i0r0=8∈[1...12], 2de0i1r0=9∈[1...12]]], elements=[8, 9]}] ++2d20|[Roll{expression='+2d20', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20]]], elements=[16, 13]}] ++2d3k1|[Roll{expression='+2d3k1', randomElementsInRoll=[[2de0i0r0=2∈[1...3], 2de0i1r0=3∈[1...3]]], elements=[3]}] ++2d4|[Roll{expression='+2d4', randomElementsInRoll=[[2de0i0r0=4∈[1...4], 2de0i1r0=2∈[1...4]]], elements=[4, 2]}] ++2d6|[Roll{expression='+2d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6]]], elements=[2, 3]}] ++2d8|[Roll{expression='+2d8', randomElementsInRoll=[[2de0i0r0=8∈[1...8], 2de0i1r0=2∈[1...8]]], elements=[8, 2]}] ++3|[Roll{expression='+3', randomElementsInRoll=[], elements=[3]}] ++3D6|[Roll{expression='+3D6', randomElementsInRoll=[[2De0i0r0=2∈[1...6], 2De0i1r0=3∈[1...6], 2De0i2r0=1∈[1...6]]], elements=[2, 3, 1]}] ++3d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll{expression='+3d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼')', randomElementsInRoll=[[2de0i0r0= △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i1r0= ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i2r0= ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]]], elements=[ △, ⧼, ●]}] ++3d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll{expression='+3d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△')', randomElementsInRoll=[[2de0i0r0= ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], 2de0i1r0= ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], 2de0i2r0= ●△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]]], elements=[ ⧼△, ⧼△, ●△]}] ++3d3k1|[Roll{expression='+3d3k1', randomElementsInRoll=[[2de0i0r0=2∈[1...3], 2de0i1r0=3∈[1...3], 2de0i2r0=1∈[1...3]]], elements=[3]}] ++4D6|[Roll{expression='+4D6', randomElementsInRoll=[[2De0i0r0=2∈[1...6], 2De0i1r0=3∈[1...6], 2De0i2r0=1∈[1...6], 2De0i3r0=4∈[1...6]]], elements=[2, 3, 1, 4]}] ++4d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll{expression='+4d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼')', randomElementsInRoll=[[2de0i0r0= △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i1r0= ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i2r0= ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i3r0= ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]]], elements=[ △, ⧼, ●, ⧼△]}] ++4d(' ●△' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼' + ' ⧼⧼△' + ' ●⧼⧼△△')|[Roll{expression='+4d(' ●△'+' ⧼△'+' ⧼△'+' ●⧼⧼'+' ⧼⧼△'+' ●⧼⧼△△')', randomElementsInRoll=[[2de0i0r0= ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], 2de0i1r0= ⧼△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], 2de0i2r0= ●△∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△], 2de0i3r0= ●⧼⧼∈[ ●△, ⧼△, ⧼△, ●⧼⧼, ⧼⧼△, ●⧼⧼△△]]], elements=[ ⧼△, ⧼△, ●△, ●⧼⧼]}] ++4d3k1|[Roll{expression='+4d3k1', randomElementsInRoll=[[2de0i0r0=2∈[1...3], 2de0i1r0=3∈[1...3], 2de0i2r0=1∈[1...3], 2de0i3r0=1∈[1...3]]], elements=[3]}] ++5d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll{expression='+5d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼')', randomElementsInRoll=[[2de0i0r0= △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i1r0= ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i2r0= ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i3r0= ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i4r0= ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]]], elements=[ △, ⧼, ●, ⧼△, ●]}] ++5d10|[Roll{expression='+5d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10]]], elements=[6, 3, 1, 10, 1]}] ++5d12|[Roll{expression='+5d12', randomElementsInRoll=[[2de0i0r0=8∈[1...12], 2de0i1r0=9∈[1...12], 2de0i2r0=7∈[1...12], 2de0i3r0=10∈[1...12], 2de0i4r0=7∈[1...12]]], elements=[8, 9, 7, 10, 7]}] ++5d20|[Roll{expression='+5d20', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20], 2de0i2r0=11∈[1...20], 2de0i3r0=10∈[1...20], 2de0i4r0=11∈[1...20]]], elements=[16, 13, 11, 10, 11]}] ++5d4|[Roll{expression='+5d4', randomElementsInRoll=[[2de0i0r0=4∈[1...4], 2de0i1r0=2∈[1...4], 2de0i2r0=2∈[1...4], 2de0i3r0=4∈[1...4], 2de0i4r0=1∈[1...4]]], elements=[4, 2, 2, 4, 1]}] ++5d6|[Roll{expression='+5d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6]]], elements=[2, 3, 1, 4, 1]}] ++5d8|[Roll{expression='+5d8', randomElementsInRoll=[[2de0i0r0=8∈[1...8], 2de0i1r0=2∈[1...8], 2de0i2r0=6∈[1...8], 2de0i3r0=4∈[1...8], 2de0i4r0=5∈[1...8]]], elements=[8, 2, 6, 4, 5]}] ++6d(' ●' + ' △' + ' ⧼' + ' ⧼△' + ' ⧼△' + ' ●⧼⧼')|[Roll{expression='+6d(' ●'+' △'+' ⧼'+' ⧼△'+' ⧼△'+' ●⧼⧼')', randomElementsInRoll=[[2de0i0r0= △∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i1r0= ⧼∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i2r0= ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i3r0= ⧼△∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i4r0= ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼], 2de0i5r0= ●∈[ ●, △, ⧼, ⧼△, ⧼△, ●⧼⧼]]], elements=[ △, ⧼, ●, ⧼△, ●, ●]}] ++7|[Roll{expression='+7', randomElementsInRoll=[], elements=[7]}] +-1|[Roll{expression='-1', randomElementsInRoll=[], elements=[-1]}] +-1d10+1|[Roll{expression='-1d10+1', randomElementsInRoll=[[2de0i0r0=6∈[1...10]]], elements=[-6, 1]}] +-1d3|[Roll{expression='-1d3', randomElementsInRoll=[[2de0i0r0=2∈[1...3]]], elements=[-2]}] +-1d6|[Roll{expression='-1d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6]]], elements=[-2]}] +-2d3k1|[Roll{expression='-2d3k1', randomElementsInRoll=[[2de0i0r0=2∈[1...3], 2de0i1r0=3∈[1...3]]], elements=[-2]}] +-3d3k1|[Roll{expression='-3d3k1', randomElementsInRoll=[[2de0i0r0=2∈[1...3], 2de0i1r0=3∈[1...3], 2de0i2r0=1∈[1...3]]], elements=[-1]}] +-4d3k1|[Roll{expression='-4d3k1', randomElementsInRoll=[[2de0i0r0=2∈[1...3], 2de0i1r0=3∈[1...3], 2de0i2r0=1∈[1...3], 2de0i3r0=1∈[1...3]]], elements=[-1]}] +-5|[Roll{expression='-5', randomElementsInRoll=[], elements=[-5]}] +0|[Roll{expression='0', randomElementsInRoll=[], elements=[0]}] +0 + 100|[Roll{expression='0+100', randomElementsInRoll=[], elements=[0, 100]}] +0d36|[Roll{expression='0d36', randomElementsInRoll=[], elements=[]}] +1|[Roll{expression='1', randomElementsInRoll=[], elements=[1]}] +1 100|[Roll{expression='1', randomElementsInRoll=[], elements=[1]}, Roll{expression='100', randomElementsInRoll=[], elements=[100]}] +1 2 3|[Roll{expression='1', randomElementsInRoll=[], elements=[1]}, Roll{expression='2', randomElementsInRoll=[], elements=[2]}, Roll{expression='3', randomElementsInRoll=[], elements=[3]}] +1 d2|[Roll{expression='1d2', randomElementsInRoll=[[2de0i0r0=2∈[1...2]]], elements=[2]}] +1 d20|[Roll{expression='1d20', randomElementsInRoll=[[2de0i0r0=16∈[1...20]]], elements=[16]}] +1 d30|[Roll{expression='1d30', randomElementsInRoll=[[2de0i0r0=26∈[1...30]]], elements=[26]}] +1 d5|[Roll{expression='1d5', randomElementsInRoll=[[2de0i0r0=1∈[1...5]]], elements=[1]}] +1+6|[Roll{expression='1+6', randomElementsInRoll=[], elements=[1, 6]}] +1-(1d10)|[Roll{expression='1-(1d10)', randomElementsInRoll=[[4de0i0r0=6∈[1...10]]], elements=[1, -6]}] +1-(1d10)=|[Roll{expression='1-(1d10)=', randomElementsInRoll=[[4de0i0r0=6∈[1...10]]], elements=[-5]}] +1-10|[Roll{expression='1-10', randomElementsInRoll=[], elements=[1, -10]}] +1-100|[Roll{expression='1-100', randomElementsInRoll=[], elements=[1, -100]}] +1-1d10|[Roll{expression='1-1d10', randomElementsInRoll=[[3de0i0r0=6∈[1...10]]], elements=[1, -6]}] +1-1d104|[Roll{expression='1-1d104', randomElementsInRoll=[[3de0i0r0=32∈[1...104]]], elements=[1, -32]}] +1-d10|[Roll{expression='1-d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10]]], elements=[1, -6]}] +10|[Roll{expression='10', randomElementsInRoll=[], elements=[10]}] +100|[Roll{expression='100', randomElementsInRoll=[], elements=[100]}] +100 d20|[Roll{expression='100d20', randomElementsInRoll=[[4de0i0r0=16∈[1...20], 4de0i1r0=13∈[1...20], 4de0i2r0=11∈[1...20], 4de0i3r0=10∈[1...20], 4de0i4r0=11∈[1...20], 4de0i5r0=15∈[1...20], 4de0i6r0=20∈[1...20], 4de0i7r0=9∈[1...20], 4de0i8r0=20∈[1...20], 4de0i9r0=1∈[1...20], 4de0i10r0=6∈[1...20], 4de0i11r0=13∈[1...20], 4de0i12r0=15∈[1...20], 4de0i13r0=20∈[1...20], 4de0i14r0=8∈[1...20], 4de0i15r0=16∈[1...20], 4de0i16r0=19∈[1...20], 4de0i17r0=4∈[1...20], 4de0i18r0=4∈[1...20], 4de0i19r0=13∈[1...20], 4de0i20r0=20∈[1...20], 4de0i21r0=11∈[1...20], 4de0i22r0=7∈[1...20], 4de0i23r0=14∈[1...20], 4de0i24r0=3∈[1...20], 4de0i25r0=18∈[1...20], 4de0i26r0=10∈[1...20], 4de0i27r0=14∈[1...20], 4de0i28r0=20∈[1...20], 4de0i29r0=9∈[1...20], 4de0i30r0=5∈[1...20], 4de0i31r0=8∈[1...20], 4de0i32r0=7∈[1...20], 4de0i33r0=14∈[1...20], 4de0i34r0=9∈[1...20], 4de0i35r0=3∈[1...20], 4de0i36r0=12∈[1...20], 4de0i37r0=8∈[1...20], 4de0i38r0=6∈[1...20], 4de0i39r0=11∈[1...20], 4de0i40r0=20∈[1...20], 4de0i41r0=9∈[1...20], 4de0i42r0=11∈[1...20], 4de0i43r0=1∈[1...20], 4de0i44r0=11∈[1...20], 4de0i45r0=9∈[1...20], 4de0i46r0=6∈[1...20], 4de0i47r0=8∈[1...20], 4de0i48r0=14∈[1...20], 4de0i49r0=19∈[1...20], 4de0i50r0=3∈[1...20], 4de0i51r0=20∈[1...20], 4de0i52r0=18∈[1...20], 4de0i53r0=2∈[1...20], 4de0i54r0=2∈[1...20], 4de0i55r0=12∈[1...20], 4de0i56r0=6∈[1...20], 4de0i57r0=19∈[1...20], 4de0i58r0=18∈[1...20], 4de0i59r0=16∈[1...20], 4de0i60r0=15∈[1...20], 4de0i61r0=5∈[1...20], 4de0i62r0=18∈[1...20], 4de0i63r0=20∈[1...20], 4de0i64r0=18∈[1...20], 4de0i65r0=16∈[1...20], 4de0i66r0=11∈[1...20], 4de0i67r0=20∈[1...20], 4de0i68r0=5∈[1...20], 4de0i69r0=18∈[1...20], 4de0i70r0=15∈[1...20], 4de0i71r0=18∈[1...20], 4de0i72r0=6∈[1...20], 4de0i73r0=11∈[1...20], 4de0i74r0=17∈[1...20], 4de0i75r0=10∈[1...20], 4de0i76r0=16∈[1...20], 4de0i77r0=16∈[1...20], 4de0i78r0=18∈[1...20], 4de0i79r0=10∈[1...20], 4de0i80r0=19∈[1...20], 4de0i81r0=9∈[1...20], 4de0i82r0=9∈[1...20], 4de0i83r0=8∈[1...20], 4de0i84r0=1∈[1...20], 4de0i85r0=5∈[1...20], 4de0i86r0=10∈[1...20], 4de0i87r0=9∈[1...20], 4de0i88r0=20∈[1...20], 4de0i89r0=17∈[1...20], 4de0i90r0=20∈[1...20], 4de0i91r0=11∈[1...20], 4de0i92r0=4∈[1...20], 4de0i93r0=2∈[1...20], 4de0i94r0=14∈[1...20], 4de0i95r0=13∈[1...20], 4de0i96r0=3∈[1...20], 4de0i97r0=4∈[1...20], 4de0i98r0=1∈[1...20], 4de0i99r0=12∈[1...20]]], elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1, 6, 13, 15, 20, 8, 16, 19, 4, 4, 13, 20, 11, 7, 14, 3, 18, 10, 14, 20, 9, 5, 8, 7, 14, 9, 3, 12, 8, 6, 11, 20, 9, 11, 1, 11, 9, 6, 8, 14, 19, 3, 20, 18, 2, 2, 12, 6, 19, 18, 16, 15, 5, 18, 20, 18, 16, 11, 20, 5, 18, 15, 18, 6, 11, 17, 10, 16, 16, 18, 10, 19, 9, 9, 8, 1, 5, 10, 9, 20, 17, 20, 11, 4, 2, 14, 13, 3, 4, 1, 12]}] +10d10|[Roll{expression='10d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1]}] +10d10+13d10=|[Roll{expression='10d10+13d10=', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10]], [8de0i0r0=6∈[1...10], 8de0i1r0=3∈[1...10], 8de0i2r0=5∈[1...10], 8de0i3r0=10∈[1...10], 8de0i4r0=8∈[1...10], 8de0i5r0=6∈[1...10], 8de0i6r0=9∈[1...10], 8de0i7r0=4∈[1...10], 8de0i8r0=4∈[1...10], 8de0i9r0=3∈[1...10], 8de0i10r0=10∈[1...10], 8de0i11r0=1∈[1...10], 8de0i12r0=7∈[1...10]]], elements=[132]}] +10d100|[Roll{expression='10d100', randomElementsInRoll=[[2de0i0r0=96∈[1...100], 2de0i1r0=73∈[1...100], 2de0i2r0=51∈[1...100], 2de0i3r0=30∈[1...100], 2de0i4r0=51∈[1...100], 2de0i5r0=55∈[1...100], 2de0i6r0=60∈[1...100], 2de0i7r0=29∈[1...100], 2de0i8r0=100∈[1...100], 2de0i9r0=41∈[1...100]]], elements=[96, 73, 51, 30, 51, 55, 60, 29, 100, 41]}] +10d10>6|[Roll{expression='10d10>6', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10]]], elements=[10, 10, 9, 10]}] +10d12=|[Roll{expression='10d12=', randomElementsInRoll=[[2de0i0r0=8∈[1...12], 2de0i1r0=9∈[1...12], 2de0i2r0=7∈[1...12], 2de0i3r0=10∈[1...12], 2de0i4r0=7∈[1...12], 2de0i5r0=7∈[1...12], 2de0i6r0=12∈[1...12], 2de0i7r0=9∈[1...12], 2de0i8r0=8∈[1...12], 2de0i9r0=9∈[1...12]]], elements=[86]}] +10d20|[Roll{expression='10d20', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20], 2de0i2r0=11∈[1...20], 2de0i3r0=10∈[1...20], 2de0i4r0=11∈[1...20], 2de0i5r0=15∈[1...20], 2de0i6r0=20∈[1...20], 2de0i7r0=9∈[1...20], 2de0i8r0=20∈[1...20], 2de0i9r0=1∈[1...20]]], elements=[16, 13, 11, 10, 11, 15, 20, 9, 20, 1]}] +10d20=|[Roll{expression='10d20=', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20], 2de0i2r0=11∈[1...20], 2de0i3r0=10∈[1...20], 2de0i4r0=11∈[1...20], 2de0i5r0=15∈[1...20], 2de0i6r0=20∈[1...20], 2de0i7r0=9∈[1...20], 2de0i8r0=20∈[1...20], 2de0i9r0=1∈[1...20]]], elements=[126]}] +10d2=|[Roll{expression='10d2=', randomElementsInRoll=[[2de0i0r0=2∈[1...2], 2de0i1r0=2∈[1...2], 2de0i2r0=2∈[1...2], 2de0i3r0=2∈[1...2], 2de0i4r0=1∈[1...2], 2de0i5r0=1∈[1...2], 2de0i6r0=1∈[1...2], 2de0i7r0=2∈[1...2], 2de0i8r0=2∈[1...2], 2de0i9r0=1∈[1...2]]], elements=[16]}] +10d4|[Roll{expression='10d4', randomElementsInRoll=[[2de0i0r0=4∈[1...4], 2de0i1r0=2∈[1...4], 2de0i2r0=2∈[1...4], 2de0i3r0=4∈[1...4], 2de0i4r0=1∈[1...4], 2de0i5r0=1∈[1...4], 2de0i6r0=3∈[1...4], 2de0i7r0=2∈[1...4], 2de0i8r0=4∈[1...4], 2de0i9r0=1∈[1...4]]], elements=[4, 2, 2, 4, 1, 1, 3, 2, 4, 1]}] +10d4+13d10=|[Roll{expression='10d4+13d10=', randomElementsInRoll=[[2de0i0r0=4∈[1...4], 2de0i1r0=2∈[1...4], 2de0i2r0=2∈[1...4], 2de0i3r0=4∈[1...4], 2de0i4r0=1∈[1...4], 2de0i5r0=1∈[1...4], 2de0i6r0=3∈[1...4], 2de0i7r0=2∈[1...4], 2de0i8r0=4∈[1...4], 2de0i9r0=1∈[1...4]], [7de0i0r0=6∈[1...10], 7de0i1r0=3∈[1...10], 7de0i2r0=5∈[1...10], 7de0i3r0=10∈[1...10], 7de0i4r0=8∈[1...10], 7de0i5r0=6∈[1...10], 7de0i6r0=9∈[1...10], 7de0i7r0=4∈[1...10], 7de0i8r0=4∈[1...10], 7de0i9r0=3∈[1...10], 7de0i10r0=10∈[1...10], 7de0i11r0=1∈[1...10], 7de0i12r0=7∈[1...10]]], elements=[100]}] +10d4=|[Roll{expression='10d4=', randomElementsInRoll=[[2de0i0r0=4∈[1...4], 2de0i1r0=2∈[1...4], 2de0i2r0=2∈[1...4], 2de0i3r0=4∈[1...4], 2de0i4r0=1∈[1...4], 2de0i5r0=1∈[1...4], 2de0i6r0=3∈[1...4], 2de0i7r0=2∈[1...4], 2de0i8r0=4∈[1...4], 2de0i9r0=1∈[1...4]]], elements=[24]}] +10d6|[Roll{expression='10d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3]}] +10d6=|[Roll{expression='10d6=', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6]]], elements=[26]}] +10d6>4|[Roll{expression='10d6>4', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6]]], elements=[6]}] +10d8|[Roll{expression='10d8', randomElementsInRoll=[[2de0i0r0=8∈[1...8], 2de0i1r0=2∈[1...8], 2de0i2r0=6∈[1...8], 2de0i3r0=4∈[1...8], 2de0i4r0=5∈[1...8], 2de0i5r0=5∈[1...8], 2de0i6r0=7∈[1...8], 2de0i7r0=2∈[1...8], 2de0i8r0=8∈[1...8], 2de0i9r0=1∈[1...8]]], elements=[8, 2, 6, 4, 5, 5, 7, 2, 8, 1]}] +111|[Roll{expression='111', randomElementsInRoll=[], elements=[111]}] +11d10|[Roll{expression='11d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6]}] +11d10>6|[Roll{expression='11d10>6', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10]]], elements=[10, 10, 9, 10]}] +11d6|[Roll{expression='11d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6]}] +11d6>4|[Roll{expression='11d6>4', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6]]], elements=[6, 6]}] +12|[Roll{expression='12', randomElementsInRoll=[], elements=[12]}] +12d10|[Roll{expression='12d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10], 2de0i11r0=3∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3]}] +12d10>6|[Roll{expression='12d10>6', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10], 2de0i11r0=3∈[1...10]]], elements=[10, 10, 9, 10]}] +12d6|[Roll{expression='12d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3]}] +12d6>4|[Roll{expression='12d6>4', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6]]], elements=[6, 6]}] +12d7|[Roll{expression='12d7', randomElementsInRoll=[[2de0i0r0=2∈[1...7], 2de0i1r0=2∈[1...7], 2de0i2r0=2∈[1...7], 2de0i3r0=6∈[1...7], 2de0i4r0=1∈[1...7], 2de0i5r0=6∈[1...7], 2de0i6r0=3∈[1...7], 2de0i7r0=1∈[1...7], 2de0i8r0=3∈[1...7], 2de0i9r0=2∈[1...7], 2de0i10r0=2∈[1...7], 2de0i11r0=2∈[1...7]]], elements=[2, 2, 2, 6, 1, 6, 3, 1, 3, 2, 2, 2]}] +13d10|[Roll{expression='13d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10], 2de0i11r0=3∈[1...10], 2de0i12r0=5∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3, 5]}] +13d10>6|[Roll{expression='13d10>6', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10], 2de0i11r0=3∈[1...10], 2de0i12r0=5∈[1...10]]], elements=[10, 10, 9, 10]}] +13d12=|[Roll{expression='13d12=', randomElementsInRoll=[[2de0i0r0=8∈[1...12], 2de0i1r0=9∈[1...12], 2de0i2r0=7∈[1...12], 2de0i3r0=10∈[1...12], 2de0i4r0=7∈[1...12], 2de0i5r0=7∈[1...12], 2de0i6r0=12∈[1...12], 2de0i7r0=9∈[1...12], 2de0i8r0=8∈[1...12], 2de0i9r0=9∈[1...12], 2de0i10r0=6∈[1...12], 2de0i11r0=9∈[1...12], 2de0i12r0=3∈[1...12]]], elements=[104]}] +13d20=|[Roll{expression='13d20=', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20], 2de0i2r0=11∈[1...20], 2de0i3r0=10∈[1...20], 2de0i4r0=11∈[1...20], 2de0i5r0=15∈[1...20], 2de0i6r0=20∈[1...20], 2de0i7r0=9∈[1...20], 2de0i8r0=20∈[1...20], 2de0i9r0=1∈[1...20], 2de0i10r0=6∈[1...20], 2de0i11r0=13∈[1...20], 2de0i12r0=15∈[1...20]]], elements=[160]}] +13d6|[Roll{expression='13d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3]}] +13d6>4|[Roll{expression='13d6>4', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6]]], elements=[6, 6]}] +14d10|[Roll{expression='14d10', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10], 2de0i11r0=3∈[1...10], 2de0i12r0=5∈[1...10], 2de0i13r0=10∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10, 9, 10, 1, 6, 3, 5, 10]}] +14d10>6|[Roll{expression='14d10>6', randomElementsInRoll=[[2de0i0r0=6∈[1...10], 2de0i1r0=3∈[1...10], 2de0i2r0=1∈[1...10], 2de0i3r0=10∈[1...10], 2de0i4r0=1∈[1...10], 2de0i5r0=5∈[1...10], 2de0i6r0=10∈[1...10], 2de0i7r0=9∈[1...10], 2de0i8r0=10∈[1...10], 2de0i9r0=1∈[1...10], 2de0i10r0=6∈[1...10], 2de0i11r0=3∈[1...10], 2de0i12r0=5∈[1...10], 2de0i13r0=10∈[1...10]]], elements=[10, 10, 9, 10, 10]}] +14d6|[Roll{expression='14d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2]}] +14d6>4|[Roll{expression='14d6>4', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6]]], elements=[6, 6]}] +15d12=|[Roll{expression='15d12=', randomElementsInRoll=[[2de0i0r0=8∈[1...12], 2de0i1r0=9∈[1...12], 2de0i2r0=7∈[1...12], 2de0i3r0=10∈[1...12], 2de0i4r0=7∈[1...12], 2de0i5r0=7∈[1...12], 2de0i6r0=12∈[1...12], 2de0i7r0=9∈[1...12], 2de0i8r0=8∈[1...12], 2de0i9r0=9∈[1...12], 2de0i10r0=6∈[1...12], 2de0i11r0=9∈[1...12], 2de0i12r0=3∈[1...12], 2de0i13r0=8∈[1...12], 2de0i14r0=4∈[1...12]]], elements=[116]}] +15d20=|[Roll{expression='15d20=', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20], 2de0i2r0=11∈[1...20], 2de0i3r0=10∈[1...20], 2de0i4r0=11∈[1...20], 2de0i5r0=15∈[1...20], 2de0i6r0=20∈[1...20], 2de0i7r0=9∈[1...20], 2de0i8r0=20∈[1...20], 2de0i9r0=1∈[1...20], 2de0i10r0=6∈[1...20], 2de0i11r0=13∈[1...20], 2de0i12r0=15∈[1...20], 2de0i13r0=20∈[1...20], 2de0i14r0=8∈[1...20]]], elements=[188]}] +15d6|[Roll{expression='15d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6], 2de0i14r0=4∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4]}] +15d6>4|[Roll{expression='15d6>4', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6], 2de0i14r0=4∈[1...6]]], elements=[6, 6]}] +15d8|[Roll{expression='15d8', randomElementsInRoll=[[2de0i0r0=8∈[1...8], 2de0i1r0=2∈[1...8], 2de0i2r0=6∈[1...8], 2de0i3r0=4∈[1...8], 2de0i4r0=5∈[1...8], 2de0i5r0=5∈[1...8], 2de0i6r0=7∈[1...8], 2de0i7r0=2∈[1...8], 2de0i8r0=8∈[1...8], 2de0i9r0=1∈[1...8], 2de0i10r0=4∈[1...8], 2de0i11r0=2∈[1...8], 2de0i12r0=6∈[1...8], 2de0i13r0=8∈[1...8], 2de0i14r0=8∈[1...8]]], elements=[8, 2, 6, 4, 5, 5, 7, 2, 8, 1, 4, 2, 6, 8, 8]}] +16d6|[Roll{expression='16d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6], 2de0i14r0=4∈[1...6], 2de0i15r0=4∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4]}] +17|[Roll{expression='17', randomElementsInRoll=[], elements=[17]}] +17d6|[Roll{expression='17d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6], 2de0i14r0=4∈[1...6], 2de0i15r0=4∈[1...6], 2de0i16r0=1∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1]}] +18d6|[Roll{expression='18d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6], 2de0i14r0=4∈[1...6], 2de0i15r0=4∈[1...6], 2de0i16r0=1∈[1...6], 2de0i17r0=6∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6]}] +19d6|[Roll{expression='19d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6], 2de0i14r0=4∈[1...6], 2de0i15r0=4∈[1...6], 2de0i16r0=1∈[1...6], 2de0i17r0=6∈[1...6], 2de0i18r0=6∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6]}] +1D10|[Roll{expression='1D10', randomElementsInRoll=[[1De0i0r0=6∈[1...10]]], elements=[6]}] +1D100|[Roll{expression='1D100', randomElementsInRoll=[[1De0i0r0=96∈[1...100]]], elements=[96]}] +1D100 + 1D10|[Roll{expression='1D100+1D10', randomElementsInRoll=[[1De0i0r0=96∈[1...100]], [9De0i0r0=3∈[1...10]]], elements=[96, 3]}] +1D12|[Roll{expression='1D12', randomElementsInRoll=[[1De0i0r0=8∈[1...12]]], elements=[8]}] +1D12 +1D6|[Roll{expression='1D12+1D6', randomElementsInRoll=[[1De0i0r0=8∈[1...12]], [7De0i0r0=3∈[1...6]]], elements=[8, 3]}] +1D12+2D6|[Roll{expression='1D12+2D6', randomElementsInRoll=[[1De0i0r0=8∈[1...12]], [6De0i0r0=3∈[1...6], 6De0i1r0=1∈[1...6]]], elements=[8, 3, 1]}] +1D12+3D 6|[Roll{expression='1D12+3D6', randomElementsInRoll=[[1De0i0r0=8∈[1...12]], [6De0i0r0=3∈[1...6], 6De0i1r0=1∈[1...6], 6De0i2r0=4∈[1...6]]], elements=[8, 3, 1, 4]}] +1D20|[Roll{expression='1D20', randomElementsInRoll=[[1De0i0r0=16∈[1...20]]], elements=[16]}] +1D20+5|[Roll{expression='1D20+5', randomElementsInRoll=[[1De0i0r0=16∈[1...20]]], elements=[16, 5]}] +1D20+5=|[Roll{expression='1D20+5=', randomElementsInRoll=[[1De0i0r0=16∈[1...20]]], elements=[21]}] +1D200|[Roll{expression='1D200', randomElementsInRoll=[[1De0i0r0=96∈[1...200]]], elements=[96]}] +1D3|[Roll{expression='1D3', randomElementsInRoll=[[1De0i0r0=2∈[1...3]]], elements=[2]}] +1D4|[Roll{expression='1D4', randomElementsInRoll=[[1De0i0r0=4∈[1...4]]], elements=[4]}] +1D6|[Roll{expression='1D6', randomElementsInRoll=[[1De0i0r0=2∈[1...6]]], elements=[2]}] +1D6+2|[Roll{expression='1D6+2', randomElementsInRoll=[[1De0i0r0=2∈[1...6]]], elements=[2, 2]}] +1D6+3|[Roll{expression='1D6+3', randomElementsInRoll=[[1De0i0r0=2∈[1...6]]], elements=[2, 3]}] +1D6, 3D6|[Roll{expression='1D6', randomElementsInRoll=[[1De0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='3D6', randomElementsInRoll=[[6De0i0r0=3∈[1...6], 6De0i1r0=1∈[1...6], 6De0i2r0=4∈[1...6]]], elements=[3, 1, 4]}] +1D6,2D6,3D6,4D6|[Roll{expression='1D6', randomElementsInRoll=[[1De0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='2D6', randomElementsInRoll=[[5De0i0r0=3∈[1...6], 5De0i1r0=1∈[1...6]]], elements=[3, 1]}, Roll{expression='3D6', randomElementsInRoll=[[9De0i0r0=4∈[1...6], 9De0i1r0=1∈[1...6], 9De0i2r0=1∈[1...6]]], elements=[4, 1, 1]}, Roll{expression='4D6', randomElementsInRoll=[[13De0i0r0=6∈[1...6], 13De0i1r0=3∈[1...6], 13De0i2r0=2∈[1...6], 13De0i3r0=3∈[1...6]]], elements=[6, 3, 2, 3]}] +1D6=|[Roll{expression='1D6=', randomElementsInRoll=[[1De0i0r0=2∈[1...6]]], elements=[2]}] +1D7|[Roll{expression='1D7', randomElementsInRoll=[[1De0i0r0=2∈[1...7]]], elements=[2]}] +1D8|[Roll{expression='1D8', randomElementsInRoll=[[1De0i0r0=8∈[1...8]]], elements=[8]}] +1D[Head/Tail]|[Roll{expression='1D[Head/Tail]', randomElementsInRoll=[[1De0i0r0=Tail∈[Head, Tail]]], elements=[Tail]}] +1X100|[Roll{expression='100', randomElementsInRoll=[], elements=[100]}] +1d 20|[Roll{expression='1d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}] +1d!!10|[Roll{expression='1d!!10', randomElementsInRoll=[[1d!!e0i0r0=6∈[1...10]]], elements=[6]}] +1d!!100|[Roll{expression='1d!!100', randomElementsInRoll=[[1d!!e0i0r0=96∈[1...100]]], elements=[96]}] +1d!10|[Roll{expression='1d!10', randomElementsInRoll=[[1d!e0i0r0=6∈[1...10]]], elements=[6]}] +1d!100|[Roll{expression='1d!100', randomElementsInRoll=[[1d!e0i0r0=96∈[1...100]]], elements=[96]}] +1d!6|[Roll{expression='1d!6', randomElementsInRoll=[[1d!e0i0r0=2∈[1...6]]], elements=[2]}] +1d('👍 ' + '👎 ')|[Roll{expression='1d('👍 '+'👎 ')', randomElementsInRoll=[[1de0i0r0=👎 ∈[👍 , 👎 ]]], elements=[👎 ]}] +1d0|[Roll{expression='1d0', randomElementsInRoll=[], elements=[]}] +1d1|[Roll{expression='1d1', randomElementsInRoll=[[1de0i0r0=1∈[1...1]]], elements=[1]}] +1d10|[Roll{expression='1d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[6]}] +1d10 + 1d10|[Roll{expression='1d10+1d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [8de0i0r0=3∈[1...10]]], elements=[6, 3]}] +1d10 - 1d10|[Roll{expression='1d10-1d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [8de0i0r0=3∈[1...10]]], elements=[6, -3]}] +1d10+1d10|[Roll{expression='1d10+1d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=3∈[1...10]]], elements=[6, 3]}] +1d10+1d2|[Roll{expression='1d10+1d2', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=2∈[1...2]]], elements=[6, 2]}] +1d10+1d4|[Roll{expression='1d10+1d4', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=2∈[1...4]]], elements=[6, 2]}] +1d10+1d5|[Roll{expression='1d10+1d5', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=3∈[1...5]]], elements=[6, 3]}] +1d10+1d5 =|[Roll{expression='1d10+1d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=3∈[1...5]]], elements=[9]}] +1d10+1d5=|[Roll{expression='1d10+1d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=3∈[1...5]]], elements=[9]}] +1d10+1d6|[Roll{expression='1d10+1d6', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=3∈[1...6]]], elements=[6, 3]}] +1d10+1d8|[Roll{expression='1d10+1d8', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=2∈[1...8]]], elements=[6, 2]}] +1d10+2=|[Roll{expression='1d10+2=', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[8]}] +1d10+4=|[Roll{expression='1d10+4=', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[10]}] +1d10+5|[Roll{expression='1d10+5', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[6, 5]}] +1d10+6=|[Roll{expression='1d10+6=', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[12]}] +1d10+8=|[Roll{expression='1d10+8=', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[14]}] +1d10, 2d10, 3d10|[Roll{expression='1d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[6]}, Roll{expression='2d10', randomElementsInRoll=[[7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10]]], elements=[3, 1]}, Roll{expression='3d10', randomElementsInRoll=[[13de0i0r0=10∈[1...10], 13de0i1r0=1∈[1...10], 13de0i2r0=5∈[1...10]]], elements=[10, 1, 5]}] +1d10-1d10|[Roll{expression='1d10-1d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10]], [6de0i0r0=3∈[1...10]]], elements=[6, -3]}] +1d100|[Roll{expression='1d100', randomElementsInRoll=[[1de0i0r0=96∈[1...100]]], elements=[96]}] +1d100 + 1d10|[Roll{expression='1d100+1d10', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [9de0i0r0=3∈[1...10]]], elements=[96, 3]}] +1d100+1d10|[Roll{expression='1d100+1d10', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10]]], elements=[96, 3]}] +1d100+1d10=|[Roll{expression='1d100+1d10=', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10]]], elements=[99]}] +1d100+2d10|[Roll{expression='1d100+2d10', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10]]], elements=[96, 3, 1]}] +1d100+2d10=|[Roll{expression='1d100+2d10=', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10]]], elements=[100]}] +1d100+3d10|[Roll{expression='1d100+3d10', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10], 7de0i2r0=10∈[1...10]]], elements=[96, 3, 1, 10]}] +1d100+3d10=|[Roll{expression='1d100+3d10=', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10], 7de0i2r0=10∈[1...10]]], elements=[110]}] +1d100-1d10|[Roll{expression='1d100-1d10', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10]]], elements=[96, -3]}] +1d100-1d10=|[Roll{expression='1d100-1d10=', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10]]], elements=[93]}] +1d100-2d10|[Roll{expression='1d100-2d10', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10]]], elements=[96, -3, -1]}] +1d100-2d10=|[Roll{expression='1d100-2d10=', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10]]], elements=[92]}] +1d100-3d10|[Roll{expression='1d100-3d10', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10], 7de0i2r0=10∈[1...10]]], elements=[96, -3, -1, -10]}] +1d100-3d10=|[Roll{expression='1d100-3d10=', randomElementsInRoll=[[1de0i0r0=96∈[1...100]], [7de0i0r0=3∈[1...10], 7de0i1r0=1∈[1...10], 7de0i2r0=10∈[1...10]]], elements=[82]}] +1d1000|[Roll{expression='1d1000', randomElementsInRoll=[[1de0i0r0=96∈[1...1000]]], elements=[96]}] +1d10000|[Roll{expression='1d10000', randomElementsInRoll=[[1de0i0r0=96∈[1...10000]]], elements=[96]}] +1d10=|[Roll{expression='1d10=', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[6]}] +1d10>6|[Roll{expression='1d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10]]], elements=[]}] +1d11|[Roll{expression='1d11', randomElementsInRoll=[[1de0i0r0=4∈[1...11]]], elements=[4]}] +1d112|[Roll{expression='1d112', randomElementsInRoll=[[1de0i0r0=16∈[1...112]]], elements=[16]}] +1d12|[Roll{expression='1d12', randomElementsInRoll=[[1de0i0r0=8∈[1...12]]], elements=[8]}] +1d12+1=|[Roll{expression='1d12+1=', randomElementsInRoll=[[1de0i0r0=8∈[1...12]]], elements=[9]}] +1d12+1d6|[Roll{expression='1d12+1d6', randomElementsInRoll=[[1de0i0r0=8∈[1...12]], [6de0i0r0=3∈[1...6]]], elements=[8, 3]}] +1d12+1d6=|[Roll{expression='1d12+1d6=', randomElementsInRoll=[[1de0i0r0=8∈[1...12]], [6de0i0r0=3∈[1...6]]], elements=[11]}] +1d126|[Roll{expression='1d126', randomElementsInRoll=[[1de0i0r0=86∈[1...126]]], elements=[86]}] +1d12=|[Roll{expression='1d12=', randomElementsInRoll=[[1de0i0r0=8∈[1...12]]], elements=[8]}] +1d13|[Roll{expression='1d13', randomElementsInRoll=[[1de0i0r0=6∈[1...13]]], elements=[6]}] +1d14|[Roll{expression='1d14', randomElementsInRoll=[[1de0i0r0=2∈[1...14]]], elements=[2]}] +1d15|[Roll{expression='1d15', randomElementsInRoll=[[1de0i0r0=11∈[1...15]]], elements=[11]}] +1d15000|[Roll{expression='1d15000', randomElementsInRoll=[[1de0i0r0=5096∈[1...15000]]], elements=[5096]}] +1d16|[Roll{expression='1d16', randomElementsInRoll=[[1de0i0r0=16∈[1...16]]], elements=[16]}] +1d17|[Roll{expression='1d17', randomElementsInRoll=[[1de0i0r0=2∈[1...17]]], elements=[2]}] +1d18|[Roll{expression='1d18', randomElementsInRoll=[[1de0i0r0=14∈[1...18]]], elements=[14]}] +1d19|[Roll{expression='1d19', randomElementsInRoll=[[1de0i0r0=18∈[1...19]]], elements=[18]}] +1d2|[Roll{expression='1d2', randomElementsInRoll=[[1de0i0r0=2∈[1...2]]], elements=[2]}] +1d2('👍 ' + '👎 ')|[Roll{expression='1', randomElementsInRoll=[], elements=[1]}, Roll{expression='2d('👍 '+'👎 ')', randomElementsInRoll=[[1de0i0r0=👎 ∈[👍 , 👎 ], 1de0i1r0=👎 ∈[👍 , 👎 ]]], elements=[👎 , 👎 ]}] +1d2+1=|[Roll{expression='1d2+1=', randomElementsInRoll=[[1de0i0r0=2∈[1...2]]], elements=[3]}] +1d20|[Roll{expression='1d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}] +1d20+0=|[Roll{expression='1d20+0=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}] +1d20+1|[Roll{expression='1d20+1', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 1]}] +1d20+10=|[Roll{expression='1d20+10=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[26]}] +1d20+11=|[Roll{expression='1d20+11=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[27]}] +1d20+12|[Roll{expression='1d20+12', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 12]}] +1d20+18|[Roll{expression='1d20+18', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 18]}] +1d20+18=|[Roll{expression='1d20+18=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[34]}] +1d20+2|[Roll{expression='1d20+2', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 2]}] +1d20+20=|[Roll{expression='1d20+20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[36]}] +1d20+2=|[Roll{expression='1d20+2=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[18]}] +1d20+3|[Roll{expression='1d20+3', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 3]}] +1d20+4|[Roll{expression='1d20+4', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 4]}] +1d20+4=|[Roll{expression='1d20+4=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[20]}] +1d20+5|[Roll{expression='1d20+5', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 5]}] +1d20+5=|[Roll{expression='1d20+5=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[21]}] +1d20+6|[Roll{expression='1d20+6', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 6]}] +1d20+6=|[Roll{expression='1d20+6=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[22]}] +1d20+7=|[Roll{expression='1d20+7=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[23]}] +1d20+8|[Roll{expression='1d20+8', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, 8]}] +1d20+8=|[Roll{expression='1d20+8=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[24]}] +1d20+9=|[Roll{expression='1d20+9=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[25]}] +1d20, 2d20, 3d20|[Roll{expression='1d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}, Roll{expression='2d20', randomElementsInRoll=[[7de0i0r0=13∈[1...20], 7de0i1r0=11∈[1...20]]], elements=[13, 11]}, Roll{expression='3d20', randomElementsInRoll=[[13de0i0r0=10∈[1...20], 13de0i1r0=11∈[1...20], 13de0i2r0=15∈[1...20]]], elements=[10, 11, 15]}] +1d20,3d6|[Roll{expression='1d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}, Roll{expression='3d6', randomElementsInRoll=[[6de0i0r0=3∈[1...6], 6de0i1r0=1∈[1...6], 6de0i2r0=4∈[1...6]]], elements=[3, 1, 4]}] +1d20-1|[Roll{expression='1d20-1', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, -1]}] +1d20-2|[Roll{expression='1d20-2', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, -2]}] +1d20-3|[Roll{expression='1d20-3', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16, -3]}] +1d20-5=|[Roll{expression='1d20-5=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[11]}] +1d200|[Roll{expression='1d200', randomElementsInRoll=[[1de0i0r0=96∈[1...200]]], elements=[96]}] +1d20=|[Roll{expression='1d20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}] +1d20k15|[Roll{expression='1d20k15', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}] +1d20k18|[Roll{expression='1d20k18', randomElementsInRoll=[[1de0i0r0=16∈[1...20]]], elements=[16]}] +1d21|[Roll{expression='1d21', randomElementsInRoll=[[1de0i0r0=2∈[1...21]]], elements=[2]}] +1d22|[Roll{expression='1d22', randomElementsInRoll=[[1de0i0r0=4∈[1...22]]], elements=[4]}] +1d23|[Roll{expression='1d23', randomElementsInRoll=[[1de0i0r0=22∈[1...23]]], elements=[22]}] +1d24|[Roll{expression='1d24', randomElementsInRoll=[[1de0i0r0=8∈[1...24]]], elements=[8]}] +1d25|[Roll{expression='1d25', randomElementsInRoll=[[1de0i0r0=21∈[1...25]]], elements=[21]}] +1d25+5|[Roll{expression='1d25+5', randomElementsInRoll=[[1de0i0r0=21∈[1...25]]], elements=[21, 5]}] +1d26|[Roll{expression='1d26', randomElementsInRoll=[[1de0i0r0=6∈[1...26]]], elements=[6]}] +1d2=|[Roll{expression='1d2=', randomElementsInRoll=[[1de0i0r0=2∈[1...2]]], elements=[2]}] +1d3|[Roll{expression='1d3', randomElementsInRoll=[[1de0i0r0=2∈[1...3]]], elements=[2]}] +1d3+1=|[Roll{expression='1d3+1=', randomElementsInRoll=[[1de0i0r0=2∈[1...3]]], elements=[3]}] +1d3, 1d4|[Roll{expression='1d3', randomElementsInRoll=[[1de0i0r0=2∈[1...3]]], elements=[2]}, Roll{expression='1d4', randomElementsInRoll=[[6de0i0r0=2∈[1...4]]], elements=[2]}] +1d30|[Roll{expression='1d30', randomElementsInRoll=[[1de0i0r0=26∈[1...30]]], elements=[26]}] +1d37|[Roll{expression='1d37', randomElementsInRoll=[[1de0i0r0=23∈[1...37]]], elements=[23]}] +1d3d6|[Roll{expression='1d3d6', randomElementsInRoll=[[1de0i0r0=2∈[1...3]], [3de0i0r0=3∈[1...6], 3de0i1r0=1∈[1...6]]], elements=[3, 1]}] +1d4|[Roll{expression='1d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[4]}] +1d4 + 1|[Roll{expression='1d4+1', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[4, 1]}] +1d4 + 1=|[Roll{expression='1d4+1=', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[5]}] +1d4 + 1d6|[Roll{expression='1d4+1d6', randomElementsInRoll=[[1de0i0r0=4∈[1...4]], [7de0i0r0=3∈[1...6]]], elements=[4, 3]}] +1d4 , 1d6|[Roll{expression='1d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[4]}, Roll{expression='1d6', randomElementsInRoll=[[7de0i0r0=3∈[1...6]]], elements=[3]}] +1d4+(1d20/10)|[Roll{expression='1d4+(1d20/10)', randomElementsInRoll=[[1de0i0r0=4∈[1...4]], [6de0i0r0=13∈[1...20]]], elements=[4, 1]}] +1d4+1|[Roll{expression='1d4+1', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[4, 1]}] +1d4+12|[Roll{expression='1d4+12', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[4, 12]}] +1d4+15|[Roll{expression='1d4+15', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[4, 15]}] +1d4+1d6|[Roll{expression='1d4+1d6', randomElementsInRoll=[[1de0i0r0=4∈[1...4]], [5de0i0r0=3∈[1...6]]], elements=[4, 3]}] +1d40|[Roll{expression='1d40', randomElementsInRoll=[[1de0i0r0=16∈[1...40]]], elements=[16]}] +1d450|[Roll{expression='1d450', randomElementsInRoll=[[1de0i0r0=446∈[1...450]]], elements=[446]}] +1d4=|[Roll{expression='1d4=', randomElementsInRoll=[[1de0i0r0=4∈[1...4]]], elements=[4]}] +1d5|[Roll{expression='1d5', randomElementsInRoll=[[1de0i0r0=1∈[1...5]]], elements=[1]}] +1d50|[Roll{expression='1d50', randomElementsInRoll=[[1de0i0r0=46∈[1...50]]], elements=[46]}] +1d500|[Roll{expression='1d500', randomElementsInRoll=[[1de0i0r0=96∈[1...500]]], elements=[96]}] +1d6|[Roll{expression='1d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2]}] +1d6 groupC(2d6)|[Roll{expression='1', randomElementsInRoll=[], elements=[1]}, Roll{expression='6dgroupC(2d6)', randomElementsInRoll=[[1de0i0r0=1x2∈[1x3, 1x2], 1de0i1r0=1x2∈[1x3, 1x2], 1de0i2r0=1x3∈[1x3, 1x2], 1de0i3r0=1x3∈[1x3, 1x2], 1de0i4r0=1x3∈[1x3, 1x2], 1de0i5r0=1x2∈[1x3, 1x2]], [12de0i0r0=2∈[1...6], 12de0i1r0=3∈[1...6]]], elements=[1x2, 1x2, 1x3, 1x3, 1x3, 1x2]}] +1d6+1|[Roll{expression='1d6+1', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, 1]}] +1d6+1=|[Roll{expression='1d6+1=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[3]}] +1d6+2|[Roll{expression='1d6+2', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, 2]}] +1d6+2=|[Roll{expression='1d6+2=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[4]}] +1d6+2d6|[Roll{expression='1d6+2d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6]], [5de0i0r0=3∈[1...6], 5de0i1r0=1∈[1...6]]], elements=[2, 3, 1]}] +1d6+3|[Roll{expression='1d6+3', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, 3]}] +1d6+3=|[Roll{expression='1d6+3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[5]}] +1d6+4|[Roll{expression='1d6+4', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, 4]}] +1d6+4=|[Roll{expression='1d6+4=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[6]}] +1d6+5|[Roll{expression='1d6+5', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, 5]}] +1d6+5=|[Roll{expression='1d6+5=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[7]}] +1d6+6|[Roll{expression='1d6+6', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, 6]}] +1d6+6=|[Roll{expression='1d6+6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[8]}] +1d6, 2d6, 3d6|[Roll{expression='1d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='2d6', randomElementsInRoll=[[6de0i0r0=3∈[1...6], 6de0i1r0=1∈[1...6]]], elements=[3, 1]}, Roll{expression='3d6', randomElementsInRoll=[[11de0i0r0=4∈[1...6], 11de0i1r0=1∈[1...6], 11de0i2r0=1∈[1...6]]], elements=[4, 1, 1]}] +1d6, 2d6, 3d6, 4d6, 5d6, 6d6, 7d6, 8d6, 9d6, 10d6, 11d6, 12d6|[Roll{expression='1d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='2d6', randomElementsInRoll=[[6de0i0r0=3∈[1...6], 6de0i1r0=1∈[1...6]]], elements=[3, 1]}, Roll{expression='3d6', randomElementsInRoll=[[11de0i0r0=4∈[1...6], 11de0i1r0=1∈[1...6], 11de0i2r0=1∈[1...6]]], elements=[4, 1, 1]}, Roll{expression='4d6', randomElementsInRoll=[[16de0i0r0=6∈[1...6], 16de0i1r0=3∈[1...6], 16de0i2r0=2∈[1...6], 16de0i3r0=3∈[1...6]]], elements=[6, 3, 2, 3]}, Roll{expression='5d6', randomElementsInRoll=[[21de0i0r0=6∈[1...6], 21de0i1r0=3∈[1...6], 21de0i2r0=3∈[1...6], 21de0i3r0=2∈[1...6], 21de0i4r0=4∈[1...6]]], elements=[6, 3, 3, 2, 4]}, Roll{expression='6d6', randomElementsInRoll=[[26de0i0r0=4∈[1...6], 26de0i1r0=1∈[1...6], 26de0i2r0=6∈[1...6], 26de0i3r0=6∈[1...6], 26de0i4r0=1∈[1...6], 26de0i5r0=4∈[1...6]]], elements=[4, 1, 6, 6, 1, 4]}, Roll{expression='7d6', randomElementsInRoll=[[31de0i0r0=3∈[1...6], 31de0i1r0=3∈[1...6], 31de0i2r0=6∈[1...6], 31de0i3r0=3∈[1...6], 31de0i4r0=2∈[1...6], 31de0i5r0=2∈[1...6], 31de0i6r0=4∈[1...6]]], elements=[3, 3, 6, 3, 2, 2, 4]}, Roll{expression='8d6', randomElementsInRoll=[[36de0i0r0=2∈[1...6], 36de0i1r0=5∈[1...6], 36de0i2r0=5∈[1...6], 36de0i3r0=6∈[1...6], 36de0i4r0=5∈[1...6], 36de0i5r0=4∈[1...6], 36de0i6r0=3∈[1...6], 36de0i7r0=5∈[1...6]]], elements=[2, 5, 5, 6, 5, 4, 3, 5]}, Roll{expression='9d6', randomElementsInRoll=[[41de0i0r0=4∈[1...6], 41de0i1r0=6∈[1...6], 41de0i2r0=2∈[1...6], 41de0i3r0=1∈[1...6], 41de0i4r0=2∈[1...6], 41de0i5r0=5∈[1...6], 41de0i6r0=1∈[1...6], 41de0i7r0=1∈[1...6], 41de0i8r0=3∈[1...6]]], elements=[4, 6, 2, 1, 2, 5, 1, 1, 3]}, Roll{expression='10d6', randomElementsInRoll=[[47de0i0r0=5∈[1...6], 47de0i1r0=2∈[1...6], 47de0i2r0=2∈[1...6], 47de0i3r0=6∈[1...6], 47de0i4r0=1∈[1...6], 47de0i5r0=3∈[1...6], 47de0i6r0=2∈[1...6], 47de0i7r0=2∈[1...6], 47de0i8r0=4∈[1...6], 47de0i9r0=6∈[1...6]]], elements=[5, 2, 2, 6, 1, 3, 2, 2, 4, 6]}, Roll{expression='11d6', randomElementsInRoll=[[53de0i0r0=2∈[1...6], 53de0i1r0=6∈[1...6], 53de0i2r0=3∈[1...6], 53de0i3r0=2∈[1...6], 53de0i4r0=2∈[1...6], 53de0i5r0=5∈[1...6], 53de0i6r0=1∈[1...6], 53de0i7r0=2∈[1...6], 53de0i8r0=2∈[1...6], 53de0i9r0=6∈[1...6], 53de0i10r0=6∈[1...6]]], elements=[2, 6, 3, 2, 2, 5, 1, 2, 2, 6, 6]}, Roll{expression='12d6', randomElementsInRoll=[[59de0i0r0=1∈[1...6], 59de0i1r0=4∈[1...6], 59de0i2r0=3∈[1...6], 59de0i3r0=2∈[1...6], 59de0i4r0=3∈[1...6], 59de0i5r0=4∈[1...6], 59de0i6r0=6∈[1...6], 59de0i7r0=1∈[1...6], 59de0i8r0=5∈[1...6], 59de0i9r0=4∈[1...6], 59de0i10r0=2∈[1...6], 59de0i11r0=6∈[1...6]]], elements=[1, 4, 3, 2, 3, 4, 6, 1, 5, 4, 2, 6]}] +1d6-1|[Roll{expression='1d6-1', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, -1]}] +1d6-1=|[Roll{expression='1d6-1=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[1]}] +1d6-3|[Roll{expression='1d6-3', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2, -3]}] +1d60|[Roll{expression='1d60', randomElementsInRoll=[[1de0i0r0=56∈[1...60]]], elements=[56]}] +1d66|[Roll{expression='1d66', randomElementsInRoll=[[1de0i0r0=26∈[1...66]]], elements=[26]}] +1d6=|[Roll{expression='1d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[2]}] +1d6>4|[Roll{expression='1d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[]}] +1d6>=5|[Roll{expression='1d6>=5', randomElementsInRoll=[[1de0i0r0=2∈[1...6]]], elements=[]}] +1d7|[Roll{expression='1d7', randomElementsInRoll=[[1de0i0r0=2∈[1...7]]], elements=[2]}] +1d70|[Roll{expression='1d70', randomElementsInRoll=[[1de0i0r0=16∈[1...70]]], elements=[16]}] +1d8|[Roll{expression='1d8', randomElementsInRoll=[[1de0i0r0=8∈[1...8]]], elements=[8]}] +1d8+1d10=|[Roll{expression='1d8+1d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8]], [5de0i0r0=3∈[1...10]]], elements=[11]}] +1d8+5d10=|[Roll{expression='1d8+5d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8]], [5de0i0r0=3∈[1...10], 5de0i1r0=1∈[1...10], 5de0i2r0=10∈[1...10], 5de0i3r0=1∈[1...10], 5de0i4r0=5∈[1...10]]], elements=[28]}] +1d80|[Roll{expression='1d80', randomElementsInRoll=[[1de0i0r0=16∈[1...80]]], elements=[16]}] +1d82|[Roll{expression='1d82', randomElementsInRoll=[[1de0i0r0=4∈[1...82]]], elements=[4]}] +1d8=|[Roll{expression='1d8=', randomElementsInRoll=[[1de0i0r0=8∈[1...8]]], elements=[8]}] +1d9|[Roll{expression='1d9', randomElementsInRoll=[[1de0i0r0=5∈[1...9]]], elements=[5]}] +1d9+1d9+1d10|[Roll{expression='1d9+1d9+1d10', randomElementsInRoll=[[1de0i0r0=5∈[1...9]], [5de0i0r0=9∈[1...9]], [9de0i0r0=1∈[1...10]]], elements=[5, 9, 1]}] +1d90|[Roll{expression='1d90', randomElementsInRoll=[[1de0i0r0=86∈[1...90]]], elements=[86]}] +1d[0/1/2/3/4/5/6/7/8/9]=|[Roll{expression='1d[0/1/2/3/4/5/6/7/8/9]=', randomElementsInRoll=[[1de0i0r0=5∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]], elements=[5]}] +1d[Head \U0001f600/Tail \U0001f985]|[Roll{expression='1d[Head \U0001f600/Tail \U0001f985]', randomElementsInRoll=[[1de0i0r0=Tail \U0001f985∈[Head \U0001f600, Tail \U0001f985]]], elements=[Tail \U0001f985]}] +1d[Head 😀/Tail 🦅]|[Roll{expression='1d[Head 😀/Tail 🦅]', randomElementsInRoll=[[1de0i0r0=Tail 🦅∈[Head 😀, Tail 🦅]]], elements=[Tail 🦅]}] +1d[Pile/Face]|[Roll{expression='1d[Pile/Face]', randomElementsInRoll=[[1de0i0r0=Face∈[Pile, Face]]], elements=[Face]}] +2|[Roll{expression='2', randomElementsInRoll=[], elements=[2]}] +2(3d6=)k1|[Roll{expression='2', randomElementsInRoll=[], elements=[2]}, Roll{expression='(3d6=)k1', randomElementsInRoll=[[3de0i0r0=2∈[1...6], 3de0i1r0=3∈[1...6], 3de0i2r0=1∈[1...6]]], elements=[6]}] +2*(3d6=)k1|[Roll{expression='2*(3d6=)k1', randomElementsInRoll=[[4de0i0r0=2∈[1...6], 4de0i1r0=3∈[1...6], 4de0i2r0=1∈[1...6]]], elements=[12]}] +2*3d6L1|[Roll{expression='2*3d6L1', randomElementsInRoll=[[3de0i0r0=2∈[1...6], 3de0i1r0=3∈[1...6], 3de0i2r0=1∈[1...6]]], elements=[2]}] +2*3d6k1|[Roll{expression='2*3d6k1', randomElementsInRoll=[[3de0i0r0=2∈[1...6], 3de0i1r0=3∈[1...6], 3de0i2r0=1∈[1...6]]], elements=[6]}] +20|[Roll{expression='20', randomElementsInRoll=[], elements=[20]}] +200|[Roll{expression='200', randomElementsInRoll=[], elements=[200]}] +20d20=|[Roll{expression='20d20=', randomElementsInRoll=[[2de0i0r0=16∈[1...20], 2de0i1r0=13∈[1...20], 2de0i2r0=11∈[1...20], 2de0i3r0=10∈[1...20], 2de0i4r0=11∈[1...20], 2de0i5r0=15∈[1...20], 2de0i6r0=20∈[1...20], 2de0i7r0=9∈[1...20], 2de0i8r0=20∈[1...20], 2de0i9r0=1∈[1...20], 2de0i10r0=6∈[1...20], 2de0i11r0=13∈[1...20], 2de0i12r0=15∈[1...20], 2de0i13r0=20∈[1...20], 2de0i14r0=8∈[1...20], 2de0i15r0=16∈[1...20], 2de0i16r0=19∈[1...20], 2de0i17r0=4∈[1...20], 2de0i18r0=4∈[1...20], 2de0i19r0=13∈[1...20]]], elements=[244]}] +20d6|[Roll{expression='20d6', randomElementsInRoll=[[2de0i0r0=2∈[1...6], 2de0i1r0=3∈[1...6], 2de0i2r0=1∈[1...6], 2de0i3r0=4∈[1...6], 2de0i4r0=1∈[1...6], 2de0i5r0=1∈[1...6], 2de0i6r0=6∈[1...6], 2de0i7r0=3∈[1...6], 2de0i8r0=2∈[1...6], 2de0i9r0=3∈[1...6], 2de0i10r0=6∈[1...6], 2de0i11r0=3∈[1...6], 2de0i12r0=3∈[1...6], 2de0i13r0=2∈[1...6], 2de0i14r0=4∈[1...6], 2de0i15r0=4∈[1...6], 2de0i16r0=1∈[1...6], 2de0i17r0=6∈[1...6], 2de0i18r0=6∈[1...6], 2de0i19r0=1∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6, 1]}] +26|[Roll{expression='26', randomElementsInRoll=[], elements=[26]}] +2D100K1|[Roll{expression='2D100K1', randomElementsInRoll=[[1De0i0r0=96∈[1...100], 1De0i1r0=73∈[1...100]]], elements=[96]}] +2D100k1|[Roll{expression='2D100k1', randomElementsInRoll=[[1De0i0r0=96∈[1...100], 1De0i1r0=73∈[1...100]]], elements=[96]}] +2D100l1|[Roll{expression='2D100l1', randomElementsInRoll=[[1De0i0r0=96∈[1...100], 1De0i1r0=73∈[1...100]]], elements=[73]}] +2D12|[Roll{expression='2D12', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12]]], elements=[8, 9]}] +2D12+1D6|[Roll{expression='2D12+1D6', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12]], [6De0i0r0=1∈[1...6]]], elements=[8, 9, 1]}] +2D20|[Roll{expression='2D20', randomElementsInRoll=[[1De0i0r0=16∈[1...20], 1De0i1r0=13∈[1...20]]], elements=[16, 13]}] +2D4|[Roll{expression='2D4', randomElementsInRoll=[[1De0i0r0=4∈[1...4], 1De0i1r0=2∈[1...4]]], elements=[4, 2]}] +2D4=|[Roll{expression='2D4=', randomElementsInRoll=[[1De0i0r0=4∈[1...4], 1De0i1r0=2∈[1...4]]], elements=[6]}] +2D6|[Roll{expression='2D6', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6]]], elements=[2, 3]}] +2D6+3|[Roll{expression='2D6+3', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6]]], elements=[2, 3, 3]}] +2D6=|[Roll{expression='2D6=', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6]]], elements=[5]}] +2D8|[Roll{expression='2D8', randomElementsInRoll=[[1De0i0r0=8∈[1...8], 1De0i1r0=2∈[1...8]]], elements=[8, 2]}] +2D8=|[Roll{expression='2D8=', randomElementsInRoll=[[1De0i0r0=8∈[1...8], 1De0i1r0=2∈[1...8]]], elements=[10]}] +2D[Head/Tail]|[Roll{expression='2D[Head/Tail]', randomElementsInRoll=[[1De0i0r0=Tail∈[Head, Tail], 1De0i1r0=Tail∈[Head, Tail]]], elements=[Tail, Tail]}] +2d10|[Roll{expression='2d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[6, 3]}] +2d10 =|[Roll{expression='2d10=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[9]}] +2d10+1d2|[Roll{expression='2d10+1d2', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=2∈[1...2]]], elements=[6, 3, 2]}] +2d10+1d4|[Roll{expression='2d10+1d4', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=2∈[1...4]]], elements=[6, 3, 2]}] +2d10+1d5|[Roll{expression='2d10+1d5', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=1∈[1...5]]], elements=[6, 3, 1]}] +2d10+1d5 =|[Roll{expression='2d10+1d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=1∈[1...5]]], elements=[10]}] +2d10+1d5=|[Roll{expression='2d10+1d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=1∈[1...5]]], elements=[10]}] +2d10+1d6|[Roll{expression='2d10+1d6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=1∈[1...6]]], elements=[6, 3, 1]}] +2d10+1d8|[Roll{expression='2d10+1d8', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=6∈[1...8]]], elements=[6, 3, 6]}] +2d10+2d5|[Roll{expression='2d10+2d5', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=1∈[1...5], 6de0i1r0=5∈[1...5]]], elements=[6, 3, 1, 5]}] +2d10+2d5=|[Roll{expression='2d10+2d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]], [6de0i0r0=1∈[1...5], 6de0i1r0=5∈[1...5]]], elements=[15]}] +2d10+3=|[Roll{expression='2d10+3=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[12]}] +2d10+4|[Roll{expression='2d10+4', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[6, 3, 4]}] +2d100|[Roll{expression='2d100', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100]]], elements=[96, 73]}] +2d100K1|[Roll{expression='2d100K1', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100]]], elements=[96]}] +2d100L1|[Roll{expression='2d100L1', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100]]], elements=[73]}] +2d100L2|[Roll{expression='2d100L2', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100]]], elements=[73, 96]}] +2d100k2|[Roll{expression='2d100k2', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100]]], elements=[96, 73]}] +2d100l1|[Roll{expression='2d100l1', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100]]], elements=[73]}] +2d10=|[Roll{expression='2d10=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[9]}] +2d10>6|[Roll{expression='2d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[]}] +2d10L1|[Roll{expression='2d10L1', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[3]}] +2d10k1|[Roll{expression='2d10k1', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10]]], elements=[6]}] +2d12|[Roll{expression='2d12', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[8, 9]}] +2d12+12|[Roll{expression='2d12+12', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[8, 9, 12]}] +2d12+12=|[Roll{expression='2d12+12=', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[29]}] +2d12+16|[Roll{expression='2d12+16', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[8, 9, 16]}] +2d12+16=|[Roll{expression='2d12+16=', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[33]}] +2d12=|[Roll{expression='2d12=', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[17]}] +2d12k1|[Roll{expression='2d12k1', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[9]}] +2d12l1|[Roll{expression='2d12l1', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12]]], elements=[8]}] +2d16|[Roll{expression='2d16', randomElementsInRoll=[[1de0i0r0=16∈[1...16], 1de0i1r0=10∈[1...16]]], elements=[16, 10]}] +2d17|[Roll{expression='2d17', randomElementsInRoll=[[1de0i0r0=2∈[1...17], 1de0i1r0=5∈[1...17]]], elements=[2, 5]}] +2d2|[Roll{expression='2d2', randomElementsInRoll=[[1de0i0r0=2∈[1...2], 1de0i1r0=2∈[1...2]]], elements=[2, 2]}] +2d20|[Roll{expression='2d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[16, 13]}] +2d20+2|[Roll{expression='2d20+2', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[16, 13, 2]}] +2d20+6|[Roll{expression='2d20+6', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[16, 13, 6]}] +2d20=|[Roll{expression='2d20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[29]}] +2d20L1|[Roll{expression='2d20L1', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[13]}] +2d20L1=|[Roll{expression='2d20L1=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[13]}] +2d20k1|[Roll{expression='2d20k1', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[16]}] +2d20k1=|[Roll{expression='2d20k1=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[16]}] +2d20l1|[Roll{expression='2d20l1', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20]]], elements=[13]}] +2d2=|[Roll{expression='2d2=', randomElementsInRoll=[[1de0i0r0=2∈[1...2], 1de0i1r0=2∈[1...2]]], elements=[4]}] +2d3|[Roll{expression='2d3', randomElementsInRoll=[[1de0i0r0=2∈[1...3], 1de0i1r0=3∈[1...3]]], elements=[2, 3]}] +2d30|[Roll{expression='2d30', randomElementsInRoll=[[1de0i0r0=26∈[1...30], 1de0i1r0=3∈[1...30]]], elements=[26, 3]}] +2d3=|[Roll{expression='2d3=', randomElementsInRoll=[[1de0i0r0=2∈[1...3], 1de0i1r0=3∈[1...3]]], elements=[5]}] +2d3k1|[Roll{expression='2d3k1', randomElementsInRoll=[[1de0i0r0=2∈[1...3], 1de0i1r0=3∈[1...3]]], elements=[3]}] +2d4|[Roll{expression='2d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4]]], elements=[4, 2]}] +2d4+1|[Roll{expression='2d4+1', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4]]], elements=[4, 2, 1]}] +2d4+1=|[Roll{expression='2d4+1=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4]]], elements=[7]}] +2d4=|[Roll{expression='2d4=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4]]], elements=[6]}] +2d5|[Roll{expression='2d5', randomElementsInRoll=[[1de0i0r0=1∈[1...5], 1de0i1r0=3∈[1...5]]], elements=[1, 3]}] +2d6|[Roll{expression='2d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3]}] +2d6 + 2|[Roll{expression='2d6+2', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 2]}] +2d6 + 2=|[Roll{expression='2d6+2=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[7]}] +2d6+ 7|[Roll{expression='2d6+7', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 7]}] +2d6+(2d3k1)|[Roll{expression='2d6+(2d3k1)', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3]]], elements=[2, 3, 1]}] +2d6+(2d3k1)=|[Roll{expression='2d6+(2d3k1)=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3]]], elements=[6]}] +2d6+(3d3k1)|[Roll{expression='2d6+(3d3k1)', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3], 6de0i2r0=1∈[1...3]]], elements=[2, 3, 1]}] +2d6+(3d3k1)=|[Roll{expression='2d6+(3d3k1)=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3], 6de0i2r0=1∈[1...3]]], elements=[6]}] +2d6+(4d3k1)=|[Roll{expression='2d6+(4d3k1)=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3], 6de0i2r0=1∈[1...3], 6de0i3r0=1∈[1...3]]], elements=[6]}] +2d6+1|[Roll{expression='2d6+1', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 1]}] +2d6+10|[Roll{expression='2d6+10', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 10]}] +2d6+10=|[Roll{expression='2d6+10=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[15]}] +2d6+12|[Roll{expression='2d6+12', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 12]}] +2d6+12=|[Roll{expression='2d6+12=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[17]}] +2d6+16|[Roll{expression='2d6+16', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 16]}] +2d6+16=|[Roll{expression='2d6+16=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[21]}] +2d6+1=|[Roll{expression='2d6+1=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[6]}] +2d6+1d3|[Roll{expression='2d6+1d3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [5de0i0r0=1∈[1...3]]], elements=[2, 3, 1]}] +2d6+1d3=|[Roll{expression='2d6+1d3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [5de0i0r0=1∈[1...3]]], elements=[6]}] +2d6+2|[Roll{expression='2d6+2', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 2]}] +2d6+2=|[Roll{expression='2d6+2=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[7]}] +2d6+2d3k1|[Roll{expression='2d6+2d3k1', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [5de0i0r0=1∈[1...3], 5de0i1r0=1∈[1...3]]], elements=[3]}] +2d6+3|[Roll{expression='2d6+3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 3]}] +2d6+3=|[Roll{expression='2d6+3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[8]}] +2d6+4|[Roll{expression='2d6+4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 4]}] +2d6+4=|[Roll{expression='2d6+4=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[9]}] +2d6+5|[Roll{expression='2d6+5', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 5]}] +2d6+52d6+4|[Roll{expression='2d6+52d6+4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...6], 6de0i1r0=4∈[1...6], 6de0i2r0=1∈[1...6], 6de0i3r0=1∈[1...6], 6de0i4r0=6∈[1...6], 6de0i5r0=3∈[1...6], 6de0i6r0=2∈[1...6], 6de0i7r0=3∈[1...6], 6de0i8r0=6∈[1...6], 6de0i9r0=3∈[1...6], 6de0i10r0=3∈[1...6], 6de0i11r0=2∈[1...6], 6de0i12r0=4∈[1...6], 6de0i13r0=4∈[1...6], 6de0i14r0=1∈[1...6], 6de0i15r0=6∈[1...6], 6de0i16r0=6∈[1...6], 6de0i17r0=1∈[1...6], 6de0i18r0=4∈[1...6], 6de0i19r0=3∈[1...6], 6de0i20r0=3∈[1...6], 6de0i21r0=6∈[1...6], 6de0i22r0=3∈[1...6], 6de0i23r0=2∈[1...6], 6de0i24r0=2∈[1...6], 6de0i25r0=4∈[1...6], 6de0i26r0=2∈[1...6], 6de0i27r0=5∈[1...6], 6de0i28r0=5∈[1...6], 6de0i29r0=6∈[1...6], 6de0i30r0=5∈[1...6], 6de0i31r0=4∈[1...6], 6de0i32r0=3∈[1...6], 6de0i33r0=5∈[1...6], 6de0i34r0=4∈[1...6], 6de0i35r0=6∈[1...6], 6de0i36r0=2∈[1...6], 6de0i37r0=1∈[1...6], 6de0i38r0=2∈[1...6], 6de0i39r0=5∈[1...6], 6de0i40r0=1∈[1...6], 6de0i41r0=1∈[1...6], 6de0i42r0=3∈[1...6], 6de0i43r0=5∈[1...6], 6de0i44r0=2∈[1...6], 6de0i45r0=2∈[1...6], 6de0i46r0=6∈[1...6], 6de0i47r0=1∈[1...6], 6de0i48r0=3∈[1...6], 6de0i49r0=2∈[1...6], 6de0i50r0=2∈[1...6], 6de0i51r0=4∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2, 3, 6, 3, 3, 2, 4, 4, 1, 6, 6, 1, 4, 3, 3, 6, 3, 2, 2, 4, 2, 5, 5, 6, 5, 4, 3, 5, 4, 6, 2, 1, 2, 5, 1, 1, 3, 5, 2, 2, 6, 1, 3, 2, 2, 4, 4]}] +2d6+5=|[Roll{expression='2d6+5=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[10]}] +2d6+6|[Roll{expression='2d6+6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 6]}] +2d6+6=|[Roll{expression='2d6+6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[11]}] +2d6+7|[Roll{expression='2d6+7', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 7]}] +2d6+7=|[Roll{expression='2d6+7=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[12]}] +2d6+8|[Roll{expression='2d6+8', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, 8]}] +2d6+8=|[Roll{expression='2d6+8=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[13]}] +2d6,2d3k1|[Roll{expression='2d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3]}, Roll{expression='2d3k1', randomElementsInRoll=[[5de0i0r0=1∈[1...3], 5de0i1r0=1∈[1...3]]], elements=[1]}] +2d6,2d6+1,2d6+2,2d6+3,2d6-1,2d6-2|[Roll{expression='2d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3]}, Roll{expression='2d6+1', randomElementsInRoll=[[5de0i0r0=1∈[1...6], 5de0i1r0=4∈[1...6]]], elements=[1, 4, 1]}, Roll{expression='2d6+2', randomElementsInRoll=[[11de0i0r0=1∈[1...6], 11de0i1r0=1∈[1...6]]], elements=[1, 1, 2]}, Roll{expression='2d6+3', randomElementsInRoll=[[17de0i0r0=6∈[1...6], 17de0i1r0=3∈[1...6]]], elements=[6, 3, 3]}, Roll{expression='2d6-1', randomElementsInRoll=[[23de0i0r0=2∈[1...6], 23de0i1r0=3∈[1...6]]], elements=[2, 3, -1]}, Roll{expression='2d6-2', randomElementsInRoll=[[29de0i0r0=6∈[1...6], 29de0i1r0=3∈[1...6]]], elements=[6, 3, -2]}] +2d6,2d6,2d6,2d6,2d6,2d6,2d6|[Roll{expression='2d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3]}, Roll{expression='2d6', randomElementsInRoll=[[5de0i0r0=1∈[1...6], 5de0i1r0=4∈[1...6]]], elements=[1, 4]}, Roll{expression='2d6', randomElementsInRoll=[[9de0i0r0=1∈[1...6], 9de0i1r0=1∈[1...6]]], elements=[1, 1]}, Roll{expression='2d6', randomElementsInRoll=[[13de0i0r0=6∈[1...6], 13de0i1r0=3∈[1...6]]], elements=[6, 3]}, Roll{expression='2d6', randomElementsInRoll=[[17de0i0r0=2∈[1...6], 17de0i1r0=3∈[1...6]]], elements=[2, 3]}, Roll{expression='2d6', randomElementsInRoll=[[21de0i0r0=6∈[1...6], 21de0i1r0=3∈[1...6]]], elements=[6, 3]}, Roll{expression='2d6', randomElementsInRoll=[[25de0i0r0=3∈[1...6], 25de0i1r0=2∈[1...6]]], elements=[3, 2]}] +2d6-(2d3k1)|[Roll{expression='2d6-(2d3k1)', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3]]], elements=[2, 3, -1]}] +2d6-(2d3k1)=|[Roll{expression='2d6-(2d3k1)=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3]]], elements=[4]}] +2d6-(3d3k1)|[Roll{expression='2d6-(3d3k1)', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3], 6de0i2r0=1∈[1...3]]], elements=[2, 3, -1]}] +2d6-(3d3k1)=|[Roll{expression='2d6-(3d3k1)=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3], 6de0i2r0=1∈[1...3]]], elements=[4]}] +2d6-(4d3k1)=|[Roll{expression='2d6-(4d3k1)=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [6de0i0r0=1∈[1...3], 6de0i1r0=1∈[1...3], 6de0i2r0=1∈[1...3], 6de0i3r0=1∈[1...3]]], elements=[4]}] +2d6-1|[Roll{expression='2d6-1', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, -1]}] +2d6-1=|[Roll{expression='2d6-1=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[4]}] +2d6-1d3|[Roll{expression='2d6-1d3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [5de0i0r0=1∈[1...3]]], elements=[2, 3, -1]}] +2d6-1d3=|[Roll{expression='2d6-1d3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]], [5de0i0r0=1∈[1...3]]], elements=[4]}] +2d6-2|[Roll{expression='2d6-2', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[3]}] +2d6-2=|[Roll{expression='2d6-2=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[3]}] +2d6-3|[Roll{expression='2d6-3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2]}] +2d6-3=|[Roll{expression='2d6-3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2]}] +2d6-4|[Roll{expression='2d6-4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, -4]}] +2d6-4=|[Roll{expression='2d6-4=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[1]}] +2d6-5|[Roll{expression='2d6-5', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[2, 3, -5]}] +2d6-5=|[Roll{expression='2d6-5=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[0]}] +2d6=|[Roll{expression='2d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[5]}] +2d6=,2d6=,2d6=,2d6=,2d6=,2d6=,2d6=|[Roll{expression='2d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[5]}, Roll{expression='2d6=', randomElementsInRoll=[[6de0i0r0=1∈[1...6], 6de0i1r0=4∈[1...6]]], elements=[5]}, Roll{expression='2d6=', randomElementsInRoll=[[11de0i0r0=1∈[1...6], 11de0i1r0=1∈[1...6]]], elements=[2]}, Roll{expression='2d6=', randomElementsInRoll=[[16de0i0r0=6∈[1...6], 16de0i1r0=3∈[1...6]]], elements=[9]}, Roll{expression='2d6=', randomElementsInRoll=[[21de0i0r0=2∈[1...6], 21de0i1r0=3∈[1...6]]], elements=[5]}, Roll{expression='2d6=', randomElementsInRoll=[[26de0i0r0=6∈[1...6], 26de0i1r0=3∈[1...6]]], elements=[9]}, Roll{expression='2d6=', randomElementsInRoll=[[31de0i0r0=3∈[1...6], 31de0i1r0=2∈[1...6]]], elements=[5]}] +2d6>4|[Roll{expression='2d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[]}] +2d6>=5|[Roll{expression='2d6>=5', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[]}] +2d6k2|[Roll{expression='2d6k2', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[3, 2]}] +2d6k7|[Roll{expression='2d6k7', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6]]], elements=[3, 2]}] +2d8|[Roll{expression='2d8', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8]]], elements=[8, 2]}] +2d8+1d20|[Roll{expression='2d8+1d20', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8]], [5de0i0r0=11∈[1...20]]], elements=[8, 2, 11]}] +2d8+4|[Roll{expression='2d8+4', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8]]], elements=[8, 2, 4]}] +2d8+5d10|[Roll{expression='2d8+5d10', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8]], [5de0i0r0=1∈[1...10], 5de0i1r0=10∈[1...10], 5de0i2r0=1∈[1...10], 5de0i3r0=5∈[1...10], 5de0i4r0=10∈[1...10]]], elements=[8, 2, 1, 10, 1, 5, 10]}] +2d8=|[Roll{expression='2d8=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8]]], elements=[10]}] +2d9|[Roll{expression='2d9', randomElementsInRoll=[[1de0i0r0=5∈[1...9], 1de0i1r0=9∈[1...9]]], elements=[5, 9]}] +2d[-1/0/1/1/2/3]=|[Roll{expression='2d[-1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[-1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 1, 2, 3]]], elements=[1]}] +2d[-1/0/1/2/3]|[Roll{expression='2d[-1/0/1/2/3]', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3]]], elements=[-1, 1]}] +2d[-1/0/1/2/3]=|[Roll{expression='2d[-1/0/1/2/3]=', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3]]], elements=[0]}] +2d[0/1/2/3/4/5/6/7/8/9]=|[Roll{expression='2d[0/1/2/3/4/5/6/7/8/9]=', randomElementsInRoll=[[1de0i0r0=5∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 1de0i1r0=2∈[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]], elements=[7]}] +2d[1/0/1/1/2/3]=|[Roll{expression='2d[1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[1, 0, 1, 1, 2, 3]]], elements=[1]}] +2d[1/2/3/0/0/-1]|[Roll{expression='2d[1/2/3/0/0/-1]', randomElementsInRoll=[[1de0i0r0=2∈[1, 2, 3, 0, 0, -1], 1de0i1r0=3∈[1, 2, 3, 0, 0, -1]]], elements=[2, 3]}] +2d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll{expression='2d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=', randomElementsInRoll=[[1de0i0r0=2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i1r0=1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]]], elements=[3]}] +3|[Roll{expression='3', randomElementsInRoll=[], elements=[3]}] +3+4|[Roll{expression='3+4', randomElementsInRoll=[], elements=[3, 4]}] +3D1|[Roll{expression='3D1', randomElementsInRoll=[[1De0i0r0=1∈[1...1], 1De0i1r0=1∈[1...1], 1De0i2r0=1∈[1...1]]], elements=[1, 1, 1]}] +3D12|[Roll{expression='3D12', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12], 1De0i2r0=7∈[1...12]]], elements=[8, 9, 7]}] +3D12, 3D6|[Roll{expression='3D12', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12], 1De0i2r0=7∈[1...12]]], elements=[8, 9, 7]}, Roll{expression='3D6', randomElementsInRoll=[[7De0i0r0=4∈[1...6], 7De0i1r0=1∈[1...6], 7De0i2r0=1∈[1...6]]], elements=[4, 1, 1]}] +3D4|[Roll{expression='3D4', randomElementsInRoll=[[1De0i0r0=4∈[1...4], 1De0i1r0=2∈[1...4], 1De0i2r0=2∈[1...4]]], elements=[4, 2, 2]}] +3D4=|[Roll{expression='3D4=', randomElementsInRoll=[[1De0i0r0=4∈[1...4], 1De0i1r0=2∈[1...4], 1De0i2r0=2∈[1...4]]], elements=[8]}] +3D6|[Roll{expression='3D6', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6], 1De0i2r0=1∈[1...6]]], elements=[2, 3, 1]}] +3D6=|[Roll{expression='3D6=', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6], 1De0i2r0=1∈[1...6]]], elements=[6]}] +3D8|[Roll{expression='3D8', randomElementsInRoll=[[1De0i0r0=8∈[1...8], 1De0i1r0=2∈[1...8], 1De0i2r0=6∈[1...8]]], elements=[8, 2, 6]}] +3D8=|[Roll{expression='3D8=', randomElementsInRoll=[[1De0i0r0=8∈[1...8], 1De0i1r0=2∈[1...8], 1De0i2r0=6∈[1...8]]], elements=[16]}] +3d10|[Roll{expression='3d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]]], elements=[6, 3, 1]}] +3d10 =|[Roll{expression='3d10=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]]], elements=[10]}] +3d10+1d2|[Roll{expression='3d10+1d2', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]], [6de0i0r0=2∈[1...2]]], elements=[6, 3, 1, 2]}] +3d10+1d4|[Roll{expression='3d10+1d4', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]], [6de0i0r0=4∈[1...4]]], elements=[6, 3, 1, 4]}] +3d10+1d5=|[Roll{expression='3d10+1d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]], [6de0i0r0=5∈[1...5]]], elements=[15]}] +3d10+1d6|[Roll{expression='3d10+1d6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]], [6de0i0r0=4∈[1...6]]], elements=[6, 3, 1, 4]}] +3d10+1d8|[Roll{expression='3d10+1d8', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]], [6de0i0r0=4∈[1...8]]], elements=[6, 3, 1, 4]}] +3d10+3d5 =|[Roll{expression='3d10+3d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]], [6de0i0r0=5∈[1...5], 6de0i1r0=1∈[1...5], 6de0i2r0=5∈[1...5]]], elements=[21]}] +3d10+3d5=|[Roll{expression='3d10+3d5=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]], [6de0i0r0=5∈[1...5], 6de0i1r0=1∈[1...5], 6de0i2r0=5∈[1...5]]], elements=[21]}] +3d100|[Roll{expression='3d100', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100], 1de0i2r0=51∈[1...100]]], elements=[96, 73, 51]}] +3d10=|[Roll{expression='3d10=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]]], elements=[10]}] +3d10>6|[Roll{expression='3d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]]], elements=[]}] +3d10>7|[Roll{expression='3d10>7', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]]], elements=[]}] +3d10L1|[Roll{expression='3d10L1', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10]]], elements=[1]}] +3d12|[Roll{expression='3d12', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12], 1de0i2r0=7∈[1...12]]], elements=[8, 9, 7]}] +3d12=|[Roll{expression='3d12=', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12], 1de0i2r0=7∈[1...12]]], elements=[24]}] +3d17|[Roll{expression='3d17', randomElementsInRoll=[[1de0i0r0=2∈[1...17], 1de0i1r0=5∈[1...17], 1de0i2r0=10∈[1...17]]], elements=[2, 5, 10]}] +3d2|[Roll{expression='3d2', randomElementsInRoll=[[1de0i0r0=2∈[1...2], 1de0i1r0=2∈[1...2], 1de0i2r0=2∈[1...2]]], elements=[2, 2, 2]}] +3d20|[Roll{expression='3d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20]]], elements=[16, 13, 11]}] +3d20=|[Roll{expression='3d20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20]]], elements=[40]}] +3d20k1|[Roll{expression='3d20k1', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20]]], elements=[16]}] +3d3|[Roll{expression='3d3', randomElementsInRoll=[[1de0i0r0=2∈[1...3], 1de0i1r0=3∈[1...3], 1de0i2r0=1∈[1...3]]], elements=[2, 3, 1]}] +3d3k1|[Roll{expression='3d3k1', randomElementsInRoll=[[1de0i0r0=2∈[1...3], 1de0i1r0=3∈[1...3], 1de0i2r0=1∈[1...3]]], elements=[3]}] +3d4|[Roll{expression='3d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4]]], elements=[4, 2, 2]}] +3d4=|[Roll{expression='3d4=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4]]], elements=[8]}] +3d6|[Roll{expression='3d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1]}] +3d6+1|[Roll{expression='3d6+1', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 1]}] +3d6+10|[Roll{expression='3d6+10', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 10]}] +3d6+10=|[Roll{expression='3d6+10=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[16]}] +3d6+18|[Roll{expression='3d6+18', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 18]}] +3d6+18=|[Roll{expression='3d6+18=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[24]}] +3d6+2|[Roll{expression='3d6+2', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 2]}] +3d6+24|[Roll{expression='3d6+24', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 24]}] +3d6+24=|[Roll{expression='3d6+24=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[30]}] +3d6+3|[Roll{expression='3d6+3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 3]}] +3d6+5|[Roll{expression='3d6+5', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 5]}] +3d6+5=|[Roll{expression='3d6+5=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[11]}] +3d6+6|[Roll{expression='3d6+6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 6]}] +3d6+6=|[Roll{expression='3d6+6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[12]}] +3d6+7|[Roll{expression='3d6+7', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 7]}] +3d6+7=|[Roll{expression='3d6+7=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[13]}] +3d6+8|[Roll{expression='3d6+8', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1, 8]}] +3d6+8=|[Roll{expression='3d6+8=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[14]}] +3d6,3d6,3d6,3d6,3d6,3d6|[Roll{expression='3d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[2, 3, 1]}, Roll{expression='3d6', randomElementsInRoll=[[5de0i0r0=4∈[1...6], 5de0i1r0=1∈[1...6], 5de0i2r0=1∈[1...6]]], elements=[4, 1, 1]}, Roll{expression='3d6', randomElementsInRoll=[[9de0i0r0=6∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=2∈[1...6]]], elements=[6, 3, 2]}, Roll{expression='3d6', randomElementsInRoll=[[13de0i0r0=3∈[1...6], 13de0i1r0=6∈[1...6], 13de0i2r0=3∈[1...6]]], elements=[3, 6, 3]}, Roll{expression='3d6', randomElementsInRoll=[[17de0i0r0=3∈[1...6], 17de0i1r0=2∈[1...6], 17de0i2r0=4∈[1...6]]], elements=[3, 2, 4]}, Roll{expression='3d6', randomElementsInRoll=[[21de0i0r0=4∈[1...6], 21de0i1r0=1∈[1...6], 21de0i2r0=6∈[1...6]]], elements=[4, 1, 6]}] +3d6=|[Roll{expression='3d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[6]}] +3d6=,3d6=,3d6=,3d6=,3d6=,3d6=|[Roll{expression='3d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[6]}, Roll{expression='3d6=', randomElementsInRoll=[[6de0i0r0=4∈[1...6], 6de0i1r0=1∈[1...6], 6de0i2r0=1∈[1...6]]], elements=[6]}, Roll{expression='3d6=', randomElementsInRoll=[[11de0i0r0=6∈[1...6], 11de0i1r0=3∈[1...6], 11de0i2r0=2∈[1...6]]], elements=[11]}, Roll{expression='3d6=', randomElementsInRoll=[[16de0i0r0=3∈[1...6], 16de0i1r0=6∈[1...6], 16de0i2r0=3∈[1...6]]], elements=[12]}, Roll{expression='3d6=', randomElementsInRoll=[[21de0i0r0=3∈[1...6], 21de0i1r0=2∈[1...6], 21de0i2r0=4∈[1...6]]], elements=[9]}, Roll{expression='3d6=', randomElementsInRoll=[[26de0i0r0=4∈[1...6], 26de0i1r0=1∈[1...6], 26de0i2r0=6∈[1...6]]], elements=[11]}] +3d6==3|[Roll{expression='3d6==3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[3]}] +3d6>4|[Roll{expression='3d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[]}] +3d6>=5|[Roll{expression='3d6>=5', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6]]], elements=[]}] +3d7|[Roll{expression='3d7', randomElementsInRoll=[[1de0i0r0=2∈[1...7], 1de0i1r0=2∈[1...7], 1de0i2r0=2∈[1...7]]], elements=[2, 2, 2]}] +3d8|[Roll{expression='3d8', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8]]], elements=[8, 2, 6]}] +3d8=|[Roll{expression='3d8=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8]]], elements=[16]}] +3d[-1/0/1/1/2/3]=|[Roll{expression='3d[-1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[-1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 1, 2, 3]]], elements=[0]}] +3d[-1/0/1/2/3]|[Roll{expression='3d[-1/0/1/2/3]', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 2, 3]]], elements=[-1, 1, -1]}] +3d[-1/0/1/2/3]=|[Roll{expression='3d[-1/0/1/2/3]=', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 2, 3]]], elements=[-1]}] +3d[1/0/1/1/2/3]=|[Roll{expression='3d[1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[1, 0, 1, 1, 2, 3], 1de0i2r0=1∈[1, 0, 1, 1, 2, 3]]], elements=[2]}] +3d[1/2/3/0/0/-1]|[Roll{expression='3d[1/2/3/0/0/-1]', randomElementsInRoll=[[1de0i0r0=2∈[1, 2, 3, 0, 0, -1], 1de0i1r0=3∈[1, 2, 3, 0, 0, -1], 1de0i2r0=1∈[1, 2, 3, 0, 0, -1]]], elements=[2, 3, 1]}] +3d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll{expression='3d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=', randomElementsInRoll=[[1de0i0r0=2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i1r0=1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i2r0=3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]]], elements=[6]}] +4|[Roll{expression='4', randomElementsInRoll=[], elements=[4]}] +40|[Roll{expression='40', randomElementsInRoll=[], elements=[40]}] +400|[Roll{expression='400', randomElementsInRoll=[], elements=[400]}] +4D12+10|[Roll{expression='4D12+10', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12], 1De0i2r0=7∈[1...12], 1De0i3r0=10∈[1...12]]], elements=[8, 9, 7, 10, 10]}] +4D12+10=|[Roll{expression='4D12+10=', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12], 1De0i2r0=7∈[1...12], 1De0i3r0=10∈[1...12]]], elements=[44]}] +4D12+50|[Roll{expression='4D12+50', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12], 1De0i2r0=7∈[1...12], 1De0i3r0=10∈[1...12]]], elements=[8, 9, 7, 10, 50]}] +4D12+50=|[Roll{expression='4D12+50=', randomElementsInRoll=[[1De0i0r0=8∈[1...12], 1De0i1r0=9∈[1...12], 1De0i2r0=7∈[1...12], 1De0i3r0=10∈[1...12]]], elements=[84]}] +4D4|[Roll{expression='4D4', randomElementsInRoll=[[1De0i0r0=4∈[1...4], 1De0i1r0=2∈[1...4], 1De0i2r0=2∈[1...4], 1De0i3r0=4∈[1...4]]], elements=[4, 2, 2, 4]}] +4D4=|[Roll{expression='4D4=', randomElementsInRoll=[[1De0i0r0=4∈[1...4], 1De0i1r0=2∈[1...4], 1De0i2r0=2∈[1...4], 1De0i3r0=4∈[1...4]]], elements=[12]}] +4D6|[Roll{expression='4D6', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6], 1De0i2r0=1∈[1...6], 1De0i3r0=4∈[1...6]]], elements=[2, 3, 1, 4]}] +4D6=|[Roll{expression='4D6=', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6], 1De0i2r0=1∈[1...6], 1De0i3r0=4∈[1...6]]], elements=[10]}] +4D8|[Roll{expression='4D8', randomElementsInRoll=[[1De0i0r0=8∈[1...8], 1De0i1r0=2∈[1...8], 1De0i2r0=6∈[1...8], 1De0i3r0=4∈[1...8]]], elements=[8, 2, 6, 4]}] +4D8=|[Roll{expression='4D8=', randomElementsInRoll=[[1De0i0r0=8∈[1...8], 1De0i1r0=2∈[1...8], 1De0i2r0=6∈[1...8], 1De0i3r0=4∈[1...8]]], elements=[20]}] +4d!!6|[Roll{expression='4d!!6', randomElementsInRoll=[[1d!!e0i0r0=2∈[1...6], 1d!!e0i1r0=3∈[1...6], 1d!!e0i2r0=1∈[1...6], 1d!!e0i3r0=4∈[1...6]]], elements=[2, 3, 1, 4]}] +4d!6|[Roll{expression='4d!6', randomElementsInRoll=[[1d!e0i0r0=2∈[1...6], 1d!e0i1r0=3∈[1...6], 1d!e0i2r0=1∈[1...6], 1d!e0i3r0=4∈[1...6]]], elements=[2, 3, 1, 4]}] +4d10|[Roll{expression='4d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]]], elements=[6, 3, 1, 10]}] +4d10+1d2|[Roll{expression='4d10+1d2', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]], [6de0i0r0=1∈[1...2]]], elements=[6, 3, 1, 10, 1]}] +4d10+1d4|[Roll{expression='4d10+1d4', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]], [6de0i0r0=1∈[1...4]]], elements=[6, 3, 1, 10, 1]}] +4d10+1d6|[Roll{expression='4d10+1d6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]], [6de0i0r0=1∈[1...6]]], elements=[6, 3, 1, 10, 1]}] +4d10+1d8|[Roll{expression='4d10+1d8', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]], [6de0i0r0=5∈[1...8]]], elements=[6, 3, 1, 10, 5]}] +4d10-2|[Roll{expression='4d10-2', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]]], elements=[6, 3, 1, 10, -2]}] +4d100|[Roll{expression='4d100', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100], 1de0i2r0=51∈[1...100], 1de0i3r0=30∈[1...100]]], elements=[96, 73, 51, 30]}] +4d10=|[Roll{expression='4d10=', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]]], elements=[20]}] +4d10>6|[Roll{expression='4d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10]]], elements=[10]}] +4d12|[Roll{expression='4d12', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12], 1de0i2r0=7∈[1...12], 1de0i3r0=10∈[1...12]]], elements=[8, 9, 7, 10]}] +4d12=|[Roll{expression='4d12=', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12], 1de0i2r0=7∈[1...12], 1de0i3r0=10∈[1...12]]], elements=[34]}] +4d20|[Roll{expression='4d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20]]], elements=[16, 13, 11, 10]}] +4d20=|[Roll{expression='4d20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20]]], elements=[50]}] +4d2=|[Roll{expression='4d2=', randomElementsInRoll=[[1de0i0r0=2∈[1...2], 1de0i1r0=2∈[1...2], 1de0i2r0=2∈[1...2], 1de0i3r0=2∈[1...2]]], elements=[8]}] +4d3|[Roll{expression='4d3', randomElementsInRoll=[[1de0i0r0=2∈[1...3], 1de0i1r0=3∈[1...3], 1de0i2r0=1∈[1...3], 1de0i3r0=1∈[1...3]]], elements=[2, 3, 1, 1]}] +4d3k1|[Roll{expression='4d3k1', randomElementsInRoll=[[1de0i0r0=2∈[1...3], 1de0i1r0=3∈[1...3], 1de0i2r0=1∈[1...3], 1de0i3r0=1∈[1...3]]], elements=[3]}] +4d4|[Roll{expression='4d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4]]], elements=[4, 2, 2, 4]}] +4d4=|[Roll{expression='4d4=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4]]], elements=[12]}] +4d5|[Roll{expression='4d5', randomElementsInRoll=[[1de0i0r0=1∈[1...5], 1de0i1r0=3∈[1...5], 1de0i2r0=1∈[1...5], 1de0i3r0=5∈[1...5]]], elements=[1, 3, 1, 5]}] +4d6|[Roll{expression='4d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[2, 3, 1, 4]}] +4d6 k3|[Roll{expression='4d6k3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[4, 3, 2]}] +4d6 k3=|[Roll{expression='4d6k3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[9]}] +4d6-1|[Roll{expression='4d6-1', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[2, 3, 4]}] +4d6=|[Roll{expression='4d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[10]}] +4d6>4|[Roll{expression='4d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[]}] +4d6L1|[Roll{expression='4d6L1', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[1]}] +4d6k3|[Roll{expression='4d6k3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[4, 3, 2]}] +4d6k3, 4d6k3, 4d6k3, 4d6k3, 4d6k3, 4d6k3|[Roll{expression='4d6k3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[4, 3, 2]}, Roll{expression='4d6k3', randomElementsInRoll=[[8de0i0r0=1∈[1...6], 8de0i1r0=1∈[1...6], 8de0i2r0=6∈[1...6], 8de0i3r0=3∈[1...6]]], elements=[6, 3, 1]}, Roll{expression='4d6k3', randomElementsInRoll=[[15de0i0r0=2∈[1...6], 15de0i1r0=3∈[1...6], 15de0i2r0=6∈[1...6], 15de0i3r0=3∈[1...6]]], elements=[6, 3, 3]}, Roll{expression='4d6k3', randomElementsInRoll=[[22de0i0r0=3∈[1...6], 22de0i1r0=2∈[1...6], 22de0i2r0=4∈[1...6], 22de0i3r0=4∈[1...6]]], elements=[4, 4, 3]}, Roll{expression='4d6k3', randomElementsInRoll=[[29de0i0r0=1∈[1...6], 29de0i1r0=6∈[1...6], 29de0i2r0=6∈[1...6], 29de0i3r0=1∈[1...6]]], elements=[6, 6, 1]}, Roll{expression='4d6k3', randomElementsInRoll=[[36de0i0r0=4∈[1...6], 36de0i1r0=3∈[1...6], 36de0i2r0=3∈[1...6], 36de0i3r0=6∈[1...6]]], elements=[6, 4, 3]}] +4d6k3,4d6k3,4d6k3,4d6k3,4d6k3,4d6k3|[Roll{expression='4d6k3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[4, 3, 2]}, Roll{expression='4d6k3', randomElementsInRoll=[[7de0i0r0=1∈[1...6], 7de0i1r0=1∈[1...6], 7de0i2r0=6∈[1...6], 7de0i3r0=3∈[1...6]]], elements=[6, 3, 1]}, Roll{expression='4d6k3', randomElementsInRoll=[[13de0i0r0=2∈[1...6], 13de0i1r0=3∈[1...6], 13de0i2r0=6∈[1...6], 13de0i3r0=3∈[1...6]]], elements=[6, 3, 3]}, Roll{expression='4d6k3', randomElementsInRoll=[[19de0i0r0=3∈[1...6], 19de0i1r0=2∈[1...6], 19de0i2r0=4∈[1...6], 19de0i3r0=4∈[1...6]]], elements=[4, 4, 3]}, Roll{expression='4d6k3', randomElementsInRoll=[[25de0i0r0=1∈[1...6], 25de0i1r0=6∈[1...6], 25de0i2r0=6∈[1...6], 25de0i3r0=1∈[1...6]]], elements=[6, 6, 1]}, Roll{expression='4d6k3', randomElementsInRoll=[[31de0i0r0=4∈[1...6], 31de0i1r0=3∈[1...6], 31de0i2r0=3∈[1...6], 31de0i3r0=6∈[1...6]]], elements=[6, 4, 3]}] +4d6k3=|[Roll{expression='4d6k3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[9]}] +4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=|[Roll{expression='4d6k3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[9]}, Roll{expression='4d6k3=', randomElementsInRoll=[[8de0i0r0=1∈[1...6], 8de0i1r0=1∈[1...6], 8de0i2r0=6∈[1...6], 8de0i3r0=3∈[1...6]]], elements=[10]}, Roll{expression='4d6k3=', randomElementsInRoll=[[15de0i0r0=2∈[1...6], 15de0i1r0=3∈[1...6], 15de0i2r0=6∈[1...6], 15de0i3r0=3∈[1...6]]], elements=[12]}, Roll{expression='4d6k3=', randomElementsInRoll=[[22de0i0r0=3∈[1...6], 22de0i1r0=2∈[1...6], 22de0i2r0=4∈[1...6], 22de0i3r0=4∈[1...6]]], elements=[11]}, Roll{expression='4d6k3=', randomElementsInRoll=[[29de0i0r0=1∈[1...6], 29de0i1r0=6∈[1...6], 29de0i2r0=6∈[1...6], 29de0i3r0=1∈[1...6]]], elements=[13]}, Roll{expression='4d6k3=', randomElementsInRoll=[[36de0i0r0=4∈[1...6], 36de0i1r0=3∈[1...6], 36de0i2r0=3∈[1...6], 36de0i3r0=6∈[1...6]]], elements=[13]}] +4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=|[Roll{expression='4d6k3=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6]]], elements=[9]}, Roll{expression='4d6k3=', randomElementsInRoll=[[8de0i0r0=1∈[1...6], 8de0i1r0=1∈[1...6], 8de0i2r0=6∈[1...6], 8de0i3r0=3∈[1...6]]], elements=[10]}, Roll{expression='4d6k3=', randomElementsInRoll=[[15de0i0r0=2∈[1...6], 15de0i1r0=3∈[1...6], 15de0i2r0=6∈[1...6], 15de0i3r0=3∈[1...6]]], elements=[12]}, Roll{expression='4d6k3=', randomElementsInRoll=[[22de0i0r0=3∈[1...6], 22de0i1r0=2∈[1...6], 22de0i2r0=4∈[1...6], 22de0i3r0=4∈[1...6]]], elements=[11]}, Roll{expression='4d6k3=', randomElementsInRoll=[[29de0i0r0=1∈[1...6], 29de0i1r0=6∈[1...6], 29de0i2r0=6∈[1...6], 29de0i3r0=1∈[1...6]]], elements=[13]}, Roll{expression='4d6k3=', randomElementsInRoll=[[36de0i0r0=4∈[1...6], 36de0i1r0=3∈[1...6], 36de0i2r0=3∈[1...6], 36de0i3r0=6∈[1...6]]], elements=[13]}, Roll{expression='4d6k3=', randomElementsInRoll=[[43de0i0r0=3∈[1...6], 43de0i1r0=2∈[1...6], 43de0i2r0=2∈[1...6], 43de0i3r0=4∈[1...6]]], elements=[9]}] +4d8|[Roll{expression='4d8', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8]]], elements=[8, 2, 6, 4]}] +4d8+4d10=|[Roll{expression='4d8+4d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8]], [5de0i0r0=1∈[1...10], 5de0i1r0=5∈[1...10], 5de0i2r0=10∈[1...10], 5de0i3r0=9∈[1...10]]], elements=[45]}] +4d8=|[Roll{expression='4d8=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8]]], elements=[20]}] +4d[-1/0/1/1/2/3]=|[Roll{expression='4d[-1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[-1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 1, 2, 3], 1de0i3r0=1∈[-1, 0, 1, 1, 2, 3]]], elements=[1]}] +4d[-1/0/1/2/3]|[Roll{expression='4d[-1/0/1/2/3]', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 2, 3], 1de0i3r0=3∈[-1, 0, 1, 2, 3]]], elements=[-1, 1, -1, 3]}] +4d[-1/0/1/2/3]=|[Roll{expression='4d[-1/0/1/2/3]=', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 2, 3], 1de0i3r0=3∈[-1, 0, 1, 2, 3]]], elements=[2]}] +4d[1/0/1/1/2/3]=|[Roll{expression='4d[1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[1, 0, 1, 1, 2, 3], 1de0i2r0=1∈[1, 0, 1, 1, 2, 3], 1de0i3r0=1∈[1, 0, 1, 1, 2, 3]]], elements=[3]}] +4d[1/2/3/0/0/-1]|[Roll{expression='4d[1/2/3/0/0/-1]', randomElementsInRoll=[[1de0i0r0=2∈[1, 2, 3, 0, 0, -1], 1de0i1r0=3∈[1, 2, 3, 0, 0, -1], 1de0i2r0=1∈[1, 2, 3, 0, 0, -1], 1de0i3r0=0∈[1, 2, 3, 0, 0, -1]]], elements=[2, 3, 1, 0]}] +4d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll{expression='4d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=', randomElementsInRoll=[[1de0i0r0=2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i1r0=1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i2r0=3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i3r0=0∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]]], elements=[6]}] +5|[Roll{expression='5', randomElementsInRoll=[], elements=[5]}] +5*(2d6+6=)|[Roll{expression='5*(2d6+6=)', randomElementsInRoll=[[4de0i0r0=2∈[1...6], 4de0i1r0=3∈[1...6]]], elements=[55]}] +5*(2d6+6=),|[Roll{expression='5*(2d6+6=)', randomElementsInRoll=[[4de0i0r0=2∈[1...6], 4de0i1r0=3∈[1...6]]], elements=[55]}] +5*(3d6=),|[Roll{expression='5*(3d6=)', randomElementsInRoll=[[4de0i0r0=2∈[1...6], 4de0i1r0=3∈[1...6], 4de0i2r0=1∈[1...6]]], elements=[30]}] +5d10|[Roll{expression='5d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10]]], elements=[6, 3, 1, 10, 1]}] +5d100|[Roll{expression='5d100', randomElementsInRoll=[[1de0i0r0=96∈[1...100], 1de0i1r0=73∈[1...100], 1de0i2r0=51∈[1...100], 1de0i3r0=30∈[1...100], 1de0i4r0=51∈[1...100]]], elements=[96, 73, 51, 30, 51]}] +5d10<1>7|[Roll{expression='5d10<1>7', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10]]], elements=[]}] +5d10>6|[Roll{expression='5d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10]]], elements=[10]}] +5d10>7|[Roll{expression='5d10>7', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10]]], elements=[10]}] +5d12|[Roll{expression='5d12', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12], 1de0i2r0=7∈[1...12], 1de0i3r0=10∈[1...12], 1de0i4r0=7∈[1...12]]], elements=[8, 9, 7, 10, 7]}] +5d20|[Roll{expression='5d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20], 1de0i4r0=11∈[1...20]]], elements=[16, 13, 11, 10, 11]}] +5d20=|[Roll{expression='5d20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20], 1de0i4r0=11∈[1...20]]], elements=[61]}] +5d4|[Roll{expression='5d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4]]], elements=[4, 2, 2, 4, 1]}] +5d4=|[Roll{expression='5d4=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4]]], elements=[13]}] +5d6|[Roll{expression='5d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6]]], elements=[2, 3, 1, 4, 1]}] +5d6=|[Roll{expression='5d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6]]], elements=[11]}] +5d6>4|[Roll{expression='5d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6]]], elements=[]}] +5d6k3|[Roll{expression='5d6k3', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6]]], elements=[4, 3, 2]}] +5d8|[Roll{expression='5d8', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8]]], elements=[8, 2, 6, 4, 5]}] +5d[-1/0/1/1/2/3]=|[Roll{expression='5d[-1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[-1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 1, 2, 3], 1de0i3r0=1∈[-1, 0, 1, 1, 2, 3], 1de0i4r0=-1∈[-1, 0, 1, 1, 2, 3]]], elements=[0]}] +5d[-1/0/1/2/3]|[Roll{expression='5d[-1/0/1/2/3]', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 2, 3], 1de0i3r0=3∈[-1, 0, 1, 2, 3], 1de0i4r0=-1∈[-1, 0, 1, 2, 3]]], elements=[-1, 1, -1, 3, -1]}] +5d[-1/0/1/2/3]=|[Roll{expression='5d[-1/0/1/2/3]=', randomElementsInRoll=[[1de0i0r0=-1∈[-1, 0, 1, 2, 3], 1de0i1r0=1∈[-1, 0, 1, 2, 3], 1de0i2r0=-1∈[-1, 0, 1, 2, 3], 1de0i3r0=3∈[-1, 0, 1, 2, 3], 1de0i4r0=-1∈[-1, 0, 1, 2, 3]]], elements=[1]}] +5d[1/0/1/1/2/3]=|[Roll{expression='5d[1/0/1/1/2/3]=', randomElementsInRoll=[[1de0i0r0=0∈[1, 0, 1, 1, 2, 3], 1de0i1r0=1∈[1, 0, 1, 1, 2, 3], 1de0i2r0=1∈[1, 0, 1, 1, 2, 3], 1de0i3r0=1∈[1, 0, 1, 1, 2, 3], 1de0i4r0=1∈[1, 0, 1, 1, 2, 3]]], elements=[4]}] +5d[1/2/3/0/0/-1]|[Roll{expression='5d[1/2/3/0/0/-1]', randomElementsInRoll=[[1de0i0r0=2∈[1, 2, 3, 0, 0, -1], 1de0i1r0=3∈[1, 2, 3, 0, 0, -1], 1de0i2r0=1∈[1, 2, 3, 0, 0, -1], 1de0i3r0=0∈[1, 2, 3, 0, 0, -1], 1de0i4r0=1∈[1, 2, 3, 0, 0, -1]]], elements=[2, 3, 1, 0, 1]}] +5d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll{expression='5d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=', randomElementsInRoll=[[1de0i0r0=2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i1r0=1∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i2r0=3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i3r0=0∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0], 1de0i4r0=3∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]]], elements=[9]}] +6|[Roll{expression='6', randomElementsInRoll=[], elements=[6]}] +69|[Roll{expression='69', randomElementsInRoll=[], elements=[69]}] +6d10|[Roll{expression='6d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10]]], elements=[6, 3, 1, 10, 1, 5]}] +6d10>6|[Roll{expression='6d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10]]], elements=[10]}] +6d20|[Roll{expression='6d20', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20], 1de0i4r0=11∈[1...20], 1de0i5r0=15∈[1...20]]], elements=[16, 13, 11, 10, 11, 15]}] +6d20+0=|[Roll{expression='6d20+0=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20], 1de0i4r0=11∈[1...20], 1de0i5r0=15∈[1...20]]], elements=[76]}] +6d2=|[Roll{expression='6d2=', randomElementsInRoll=[[1de0i0r0=2∈[1...2], 1de0i1r0=2∈[1...2], 1de0i2r0=2∈[1...2], 1de0i3r0=2∈[1...2], 1de0i4r0=1∈[1...2], 1de0i5r0=1∈[1...2]]], elements=[10]}] +6d4|[Roll{expression='6d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4], 1de0i5r0=1∈[1...4]]], elements=[4, 2, 2, 4, 1, 1]}] +6d4=|[Roll{expression='6d4=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4], 1de0i5r0=1∈[1...4]]], elements=[14]}] +6d6|[Roll{expression='6d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6]]], elements=[2, 3, 1, 4, 1, 1]}] +6d6=|[Roll{expression='6d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6]]], elements=[12]}] +6d6>4|[Roll{expression='6d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6]]], elements=[]}] +6d8|[Roll{expression='6d8', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8]]], elements=[8, 2, 6, 4, 5, 5]}] +6d8+10d10=|[Roll{expression='6d8+10d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8]], [6de0i0r0=10∈[1...10], 6de0i1r0=9∈[1...10], 6de0i2r0=10∈[1...10], 6de0i3r0=1∈[1...10], 6de0i4r0=6∈[1...10], 6de0i5r0=3∈[1...10], 6de0i6r0=5∈[1...10], 6de0i7r0=10∈[1...10], 6de0i8r0=8∈[1...10], 6de0i9r0=6∈[1...10]]], elements=[98]}] +6d8+6d10=|[Roll{expression='6d8+6d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8]], [5de0i0r0=10∈[1...10], 5de0i1r0=9∈[1...10], 5de0i2r0=10∈[1...10], 5de0i3r0=1∈[1...10], 5de0i4r0=6∈[1...10], 5de0i5r0=3∈[1...10]]], elements=[69]}] +6d8+7d10=|[Roll{expression='6d8+7d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8]], [5de0i0r0=10∈[1...10], 5de0i1r0=9∈[1...10], 5de0i2r0=10∈[1...10], 5de0i3r0=1∈[1...10], 5de0i4r0=6∈[1...10], 5de0i5r0=3∈[1...10], 5de0i6r0=5∈[1...10]]], elements=[74]}] +6d8+8d10=|[Roll{expression='6d8+8d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8]], [5de0i0r0=10∈[1...10], 5de0i1r0=9∈[1...10], 5de0i2r0=10∈[1...10], 5de0i3r0=1∈[1...10], 5de0i4r0=6∈[1...10], 5de0i5r0=3∈[1...10], 5de0i6r0=5∈[1...10], 5de0i7r0=10∈[1...10]]], elements=[84]}] +6x(d6rr1+d6rr1+d6rr1+d6rr1)k3|[Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3', randomElementsInRoll=[[3de0i0r0=2∈[1...6]], [9de0i0r0=3∈[1...6]], [15de0i0r0=1∈[1...6]], [15de1i0r0=4∈[1...6]], [21de0i0r0=1∈[1...6]], [21de1i0r0=1∈[1...6]]], elements=[4, 3, 2]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3', randomElementsInRoll=[[3de1i0r0=6∈[1...6]], [9de1i0r0=3∈[1...6]], [15de2i0r0=2∈[1...6]], [21de2i0r0=3∈[1...6]]], elements=[6, 3, 3]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3', randomElementsInRoll=[[3de2i0r0=6∈[1...6]], [9de2i0r0=3∈[1...6]], [15de3i0r0=3∈[1...6]], [21de3i0r0=2∈[1...6]]], elements=[6, 3, 3]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3', randomElementsInRoll=[[3de3i0r0=4∈[1...6]], [9de3i0r0=4∈[1...6]], [15de4i0r0=1∈[1...6]], [15de5i0r0=6∈[1...6]], [21de4i0r0=6∈[1...6]]], elements=[6, 6, 4]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3', randomElementsInRoll=[[3de4i0r0=1∈[1...6]], [3de5i0r0=4∈[1...6]], [9de4i0r0=3∈[1...6]], [15de6i0r0=3∈[1...6]], [21de5i0r0=6∈[1...6]]], elements=[6, 4, 3]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3', randomElementsInRoll=[[3de6i0r0=3∈[1...6]], [9de5i0r0=2∈[1...6]], [15de7i0r0=2∈[1...6]], [21de6i0r0=4∈[1...6]]], elements=[4, 3, 2]}] +6x(d6rr1+d6rr1+d6rr1+d6rr1)k3=|[Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3=', randomElementsInRoll=[[3de0i0r0=2∈[1...6]], [9de0i0r0=3∈[1...6]], [15de0i0r0=1∈[1...6]], [15de1i0r0=4∈[1...6]], [21de0i0r0=1∈[1...6]], [21de1i0r0=1∈[1...6]]], elements=[9]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3=', randomElementsInRoll=[[3de1i0r0=6∈[1...6]], [9de1i0r0=3∈[1...6]], [15de2i0r0=2∈[1...6]], [21de2i0r0=3∈[1...6]]], elements=[12]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3=', randomElementsInRoll=[[3de2i0r0=6∈[1...6]], [9de2i0r0=3∈[1...6]], [15de3i0r0=3∈[1...6]], [21de3i0r0=2∈[1...6]]], elements=[12]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3=', randomElementsInRoll=[[3de3i0r0=4∈[1...6]], [9de3i0r0=4∈[1...6]], [15de4i0r0=1∈[1...6]], [15de5i0r0=6∈[1...6]], [21de4i0r0=6∈[1...6]]], elements=[16]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3=', randomElementsInRoll=[[3de4i0r0=1∈[1...6]], [3de5i0r0=4∈[1...6]], [9de4i0r0=3∈[1...6]], [15de6i0r0=3∈[1...6]], [21de5i0r0=6∈[1...6]]], elements=[13]}, Roll{expression='(d6rr1+d6rr1+d6rr1+d6rr1)k3=', randomElementsInRoll=[[3de6i0r0=3∈[1...6]], [9de5i0r0=2∈[1...6]], [15de7i0r0=2∈[1...6]], [21de6i0r0=4∈[1...6]]], elements=[9]}] +6x3d6=|[Roll{expression='3d6=', randomElementsInRoll=[[3de0i0r0=2∈[1...6], 3de0i1r0=3∈[1...6], 3de0i2r0=1∈[1...6]]], elements=[6]}, Roll{expression='3d6=', randomElementsInRoll=[[3de1i0r0=4∈[1...6], 3de1i1r0=1∈[1...6], 3de1i2r0=1∈[1...6]]], elements=[6]}, Roll{expression='3d6=', randomElementsInRoll=[[3de2i0r0=6∈[1...6], 3de2i1r0=3∈[1...6], 3de2i2r0=2∈[1...6]]], elements=[11]}, Roll{expression='3d6=', randomElementsInRoll=[[3de3i0r0=3∈[1...6], 3de3i1r0=6∈[1...6], 3de3i2r0=3∈[1...6]]], elements=[12]}, Roll{expression='3d6=', randomElementsInRoll=[[3de4i0r0=3∈[1...6], 3de4i1r0=2∈[1...6], 3de4i2r0=4∈[1...6]]], elements=[9]}, Roll{expression='3d6=', randomElementsInRoll=[[3de5i0r0=4∈[1...6], 3de5i1r0=1∈[1...6], 3de5i2r0=6∈[1...6]]], elements=[11]}] +6x4d6k3=|[Roll{expression='4d6k3=', randomElementsInRoll=[[3de0i0r0=2∈[1...6], 3de0i1r0=3∈[1...6], 3de0i2r0=1∈[1...6], 3de0i3r0=4∈[1...6]]], elements=[9]}, Roll{expression='4d6k3=', randomElementsInRoll=[[3de1i0r0=1∈[1...6], 3de1i1r0=1∈[1...6], 3de1i2r0=6∈[1...6], 3de1i3r0=3∈[1...6]]], elements=[10]}, Roll{expression='4d6k3=', randomElementsInRoll=[[3de2i0r0=2∈[1...6], 3de2i1r0=3∈[1...6], 3de2i2r0=6∈[1...6], 3de2i3r0=3∈[1...6]]], elements=[12]}, Roll{expression='4d6k3=', randomElementsInRoll=[[3de3i0r0=3∈[1...6], 3de3i1r0=2∈[1...6], 3de3i2r0=4∈[1...6], 3de3i3r0=4∈[1...6]]], elements=[11]}, Roll{expression='4d6k3=', randomElementsInRoll=[[3de4i0r0=1∈[1...6], 3de4i1r0=6∈[1...6], 3de4i2r0=6∈[1...6], 3de4i3r0=1∈[1...6]]], elements=[13]}, Roll{expression='4d6k3=', randomElementsInRoll=[[3de5i0r0=4∈[1...6], 3de5i1r0=3∈[1...6], 3de5i2r0=3∈[1...6], 3de5i3r0=6∈[1...6]]], elements=[13]}] +7|[Roll{expression='7', randomElementsInRoll=[], elements=[7]}] +79|[Roll{expression='79', randomElementsInRoll=[], elements=[79]}] +7D6|[Roll{expression='7D6', randomElementsInRoll=[[1De0i0r0=2∈[1...6], 1De0i1r0=3∈[1...6], 1De0i2r0=1∈[1...6], 1De0i3r0=4∈[1...6], 1De0i4r0=1∈[1...6], 1De0i5r0=1∈[1...6], 1De0i6r0=6∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6]}] +7d10|[Roll{expression='7d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10], 1de0i6r0=10∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10]}] +7d10>6|[Roll{expression='7d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10], 1de0i6r0=10∈[1...10]]], elements=[10, 10]}] +7d12|[Roll{expression='7d12', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12], 1de0i2r0=7∈[1...12], 1de0i3r0=10∈[1...12], 1de0i4r0=7∈[1...12], 1de0i5r0=7∈[1...12], 1de0i6r0=12∈[1...12]]], elements=[8, 9, 7, 10, 7, 7, 12]}] +7d20=|[Roll{expression='7d20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20], 1de0i4r0=11∈[1...20], 1de0i5r0=15∈[1...20], 1de0i6r0=20∈[1...20]]], elements=[96]}] +7d4|[Roll{expression='7d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4], 1de0i5r0=1∈[1...4], 1de0i6r0=3∈[1...4]]], elements=[4, 2, 2, 4, 1, 1, 3]}] +7d6|[Roll{expression='7d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6]}] +7d6=|[Roll{expression='7d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6]]], elements=[18]}] +7d6>4|[Roll{expression='7d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6]]], elements=[6]}] +8d10|[Roll{expression='8d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10], 1de0i6r0=10∈[1...10], 1de0i7r0=9∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10, 9]}] +8d10>6|[Roll{expression='8d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10], 1de0i6r0=10∈[1...10], 1de0i7r0=9∈[1...10]]], elements=[10, 10, 9]}] +8d12=|[Roll{expression='8d12=', randomElementsInRoll=[[1de0i0r0=8∈[1...12], 1de0i1r0=9∈[1...12], 1de0i2r0=7∈[1...12], 1de0i3r0=10∈[1...12], 1de0i4r0=7∈[1...12], 1de0i5r0=7∈[1...12], 1de0i6r0=12∈[1...12], 1de0i7r0=9∈[1...12]]], elements=[69]}] +8d20+0=|[Roll{expression='8d20+0=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20], 1de0i4r0=11∈[1...20], 1de0i5r0=15∈[1...20], 1de0i6r0=20∈[1...20], 1de0i7r0=9∈[1...20]]], elements=[105]}] +8d20=|[Roll{expression='8d20=', randomElementsInRoll=[[1de0i0r0=16∈[1...20], 1de0i1r0=13∈[1...20], 1de0i2r0=11∈[1...20], 1de0i3r0=10∈[1...20], 1de0i4r0=11∈[1...20], 1de0i5r0=15∈[1...20], 1de0i6r0=20∈[1...20], 1de0i7r0=9∈[1...20]]], elements=[105]}] +8d2=|[Roll{expression='8d2=', randomElementsInRoll=[[1de0i0r0=2∈[1...2], 1de0i1r0=2∈[1...2], 1de0i2r0=2∈[1...2], 1de0i3r0=2∈[1...2], 1de0i4r0=1∈[1...2], 1de0i5r0=1∈[1...2], 1de0i6r0=1∈[1...2], 1de0i7r0=2∈[1...2]]], elements=[13]}] +8d4|[Roll{expression='8d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4], 1de0i5r0=1∈[1...4], 1de0i6r0=3∈[1...4], 1de0i7r0=2∈[1...4]]], elements=[4, 2, 2, 4, 1, 1, 3, 2]}] +8d4+7d10=|[Roll{expression='8d4+7d10=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4], 1de0i5r0=1∈[1...4], 1de0i6r0=3∈[1...4], 1de0i7r0=2∈[1...4]], [5de0i0r0=10∈[1...10], 5de0i1r0=1∈[1...10], 5de0i2r0=6∈[1...10], 5de0i3r0=3∈[1...10], 5de0i4r0=5∈[1...10], 5de0i5r0=10∈[1...10], 5de0i6r0=8∈[1...10]]], elements=[62]}] +8d4=|[Roll{expression='8d4=', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4], 1de0i5r0=1∈[1...4], 1de0i6r0=3∈[1...4], 1de0i7r0=2∈[1...4]]], elements=[19]}] +8d6|[Roll{expression='8d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6], 1de0i7r0=3∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3]}] +8d6+7d10=|[Roll{expression='8d6+7d10=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6], 1de0i7r0=3∈[1...6]], [5de0i0r0=10∈[1...10], 5de0i1r0=1∈[1...10], 5de0i2r0=6∈[1...10], 5de0i3r0=3∈[1...10], 5de0i4r0=5∈[1...10], 5de0i5r0=10∈[1...10], 5de0i6r0=8∈[1...10]]], elements=[64]}] +8d6=|[Roll{expression='8d6=', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6], 1de0i7r0=3∈[1...6]]], elements=[21]}] +8d6>4|[Roll{expression='8d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6], 1de0i7r0=3∈[1...6]]], elements=[6]}] +8d8|[Roll{expression='8d8', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8], 1de0i6r0=7∈[1...8], 1de0i7r0=2∈[1...8]]], elements=[8, 2, 6, 4, 5, 5, 7, 2]}] +8d8+10d10=|[Roll{expression='8d8+10d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8], 1de0i6r0=7∈[1...8], 1de0i7r0=2∈[1...8]], [6de0i0r0=10∈[1...10], 6de0i1r0=1∈[1...10], 6de0i2r0=6∈[1...10], 6de0i3r0=3∈[1...10], 6de0i4r0=5∈[1...10], 6de0i5r0=10∈[1...10], 6de0i6r0=8∈[1...10], 6de0i7r0=6∈[1...10], 6de0i8r0=9∈[1...10], 6de0i9r0=4∈[1...10]]], elements=[101]}] +8d8+8d10=|[Roll{expression='8d8+8d10=', randomElementsInRoll=[[1de0i0r0=8∈[1...8], 1de0i1r0=2∈[1...8], 1de0i2r0=6∈[1...8], 1de0i3r0=4∈[1...8], 1de0i4r0=5∈[1...8], 1de0i5r0=5∈[1...8], 1de0i6r0=7∈[1...8], 1de0i7r0=2∈[1...8]], [5de0i0r0=10∈[1...10], 5de0i1r0=1∈[1...10], 5de0i2r0=6∈[1...10], 5de0i3r0=3∈[1...10], 5de0i4r0=5∈[1...10], 5de0i5r0=10∈[1...10], 5de0i6r0=8∈[1...10], 5de0i7r0=6∈[1...10]]], elements=[88]}] +9|[Roll{expression='9', randomElementsInRoll=[], elements=[9]}] +99|[Roll{expression='99', randomElementsInRoll=[], elements=[99]}] +999|[Roll{expression='999', randomElementsInRoll=[], elements=[999]}] +9d10|[Roll{expression='9d10', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10], 1de0i6r0=10∈[1...10], 1de0i7r0=9∈[1...10], 1de0i8r0=10∈[1...10]]], elements=[6, 3, 1, 10, 1, 5, 10, 9, 10]}] +9d10>6|[Roll{expression='9d10>6', randomElementsInRoll=[[1de0i0r0=6∈[1...10], 1de0i1r0=3∈[1...10], 1de0i2r0=1∈[1...10], 1de0i3r0=10∈[1...10], 1de0i4r0=1∈[1...10], 1de0i5r0=5∈[1...10], 1de0i6r0=10∈[1...10], 1de0i7r0=9∈[1...10], 1de0i8r0=10∈[1...10]]], elements=[10, 10, 9, 10]}] +9d4|[Roll{expression='9d4', randomElementsInRoll=[[1de0i0r0=4∈[1...4], 1de0i1r0=2∈[1...4], 1de0i2r0=2∈[1...4], 1de0i3r0=4∈[1...4], 1de0i4r0=1∈[1...4], 1de0i5r0=1∈[1...4], 1de0i6r0=3∈[1...4], 1de0i7r0=2∈[1...4], 1de0i8r0=4∈[1...4]]], elements=[4, 2, 2, 4, 1, 1, 3, 2, 4]}] +9d6|[Roll{expression='9d6', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6], 1de0i7r0=3∈[1...6], 1de0i8r0=2∈[1...6]]], elements=[2, 3, 1, 4, 1, 1, 6, 3, 2]}] +9d6>4|[Roll{expression='9d6>4', randomElementsInRoll=[[1de0i0r0=2∈[1...6], 1de0i1r0=3∈[1...6], 1de0i2r0=1∈[1...6], 1de0i3r0=4∈[1...6], 1de0i4r0=1∈[1...6], 1de0i5r0=1∈[1...6], 1de0i6r0=6∈[1...6], 1de0i7r0=3∈[1...6], 1de0i8r0=2∈[1...6]]], elements=[6]}] +D!!10+10|[Roll{expression='D!!10+10', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 10]}] +D!!10+11|[Roll{expression='D!!10+11', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 11]}] +D!!10+12|[Roll{expression='D!!10+12', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 12]}] +D!!10+13|[Roll{expression='D!!10+13', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 13]}] +D!!10+14|[Roll{expression='D!!10+14', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 14]}] +D!!10+15|[Roll{expression='D!!10+15', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 15]}] +D!!10+16|[Roll{expression='D!!10+16', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 16]}] +D!!10+17|[Roll{expression='D!!10+17', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 17]}] +D!!10+18|[Roll{expression='D!!10+18', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 18]}] +D!!10+19|[Roll{expression='D!!10+19', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 19]}] +D!!10+20|[Roll{expression='D!!10+20', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 20]}] +D!!10+6|[Roll{expression='D!!10+6', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 6]}] +D!!10+7|[Roll{expression='D!!10+7', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 7]}] +D!!10+8|[Roll{expression='D!!10+8', randomElementsInRoll=[[0D!!e0i0r0=6∈[1...10]]], elements=[6, 8]}] +D10|[Roll{expression='D10', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6]}] +D10+10|[Roll{expression='D10+10', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 10]}] +D10+11|[Roll{expression='D10+11', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 11]}] +D10+12|[Roll{expression='D10+12', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 12]}] +D10+13|[Roll{expression='D10+13', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 13]}] +D10+14|[Roll{expression='D10+14', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 14]}] +D10+15|[Roll{expression='D10+15', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 15]}] +D10+16|[Roll{expression='D10+16', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 16]}] +D10+17|[Roll{expression='D10+17', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 17]}] +D10+18|[Roll{expression='D10+18', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 18]}] +D10+19|[Roll{expression='D10+19', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 19]}] +D10+20|[Roll{expression='D10+20', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 20]}] +D10+6|[Roll{expression='D10+6', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 6]}] +D10+7|[Roll{expression='D10+7', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 7]}] +D10+8|[Roll{expression='D10+8', randomElementsInRoll=[[0De0i0r0=6∈[1...10]]], elements=[6, 8]}] +D100|[Roll{expression='D100', randomElementsInRoll=[[0De0i0r0=96∈[1...100]]], elements=[96]}] +D100k2|[Roll{expression='D100k2', randomElementsInRoll=[[0De0i0r0=96∈[1...100]]], elements=[96]}] +D100l2|[Roll{expression='D100l2', randomElementsInRoll=[[0De0i0r0=96∈[1...100]]], elements=[96]}] +D12|[Roll{expression='D12', randomElementsInRoll=[[0De0i0r0=8∈[1...12]]], elements=[8]}] +D20|[Roll{expression='D20', randomElementsInRoll=[[0De0i0r0=16∈[1...20]]], elements=[16]}] +D20+3|[Roll{expression='D20+3', randomElementsInRoll=[[0De0i0r0=16∈[1...20]]], elements=[16, 3]}] +D20+5|[Roll{expression='D20+5', randomElementsInRoll=[[0De0i0r0=16∈[1...20]]], elements=[16, 5]}] +D3|[Roll{expression='D3', randomElementsInRoll=[[0De0i0r0=2∈[1...3]]], elements=[2]}] +D4|[Roll{expression='D4', randomElementsInRoll=[[0De0i0r0=4∈[1...4]]], elements=[4]}] +D4+D4|[Roll{expression='D4+D4', randomElementsInRoll=[[0De0i0r0=4∈[1...4]], [3De0i0r0=2∈[1...4]]], elements=[4, 2]}] +D6|[Roll{expression='D6', randomElementsInRoll=[[0De0i0r0=2∈[1...6]]], elements=[2]}] +D8|[Roll{expression='D8', randomElementsInRoll=[[0De0i0r0=8∈[1...8]]], elements=[8]}] +D8=|[Roll{expression='D8=', randomElementsInRoll=[[0De0i0r0=8∈[1...8]]], elements=[8]}] +[1D6]|[Roll{expression='[1D6]', randomElementsInRoll=[], elements=[1D6]}] +[1_button:1D6]|[Roll{expression='[1_button:1D6]', randomElementsInRoll=[], elements=[1_button:1D6]}] +[1d10+1d10]|[Roll{expression='[1d10+1d10]', randomElementsInRoll=[], elements=[1d10+1d10]}] +[4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=]k6|[Roll{expression='[4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=,4d6k3=]k6', randomElementsInRoll=[], elements=[4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=, 4d6k3=]}] +asc(2d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='asc(2d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[5de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 5de0i1r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Failure, Failure]}] +asc(d6)|[Roll{expression='asc(d6)', randomElementsInRoll=[[4de0i0r0=2∈[1...6]]], elements=[2]}] +asc(d6c)|[Roll{expression='asc(d6c)', randomElementsInRoll=[[4de0i0r0=2∈[1...6]]], elements=[1]}] +color(10d6,'red')|[Roll{expression='color(10d6,'red')', randomElementsInRoll=[[8de0i0r0=2∈[1...6], 8de0i1r0=3∈[1...6], 8de0i2r0=1∈[1...6], 8de0i3r0=4∈[1...6], 8de0i4r0=1∈[1...6], 8de0i5r0=1∈[1...6], 8de0i6r0=6∈[1...6], 8de0i7r0=3∈[1...6], 8de0i8r0=2∈[1...6], 8de0i9r0=3∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2, red:3]}] +color(11d6,'red')|[Roll{expression='color(11d6,'red')', randomElementsInRoll=[[8de0i0r0=2∈[1...6], 8de0i1r0=3∈[1...6], 8de0i2r0=1∈[1...6], 8de0i3r0=4∈[1...6], 8de0i4r0=1∈[1...6], 8de0i5r0=1∈[1...6], 8de0i6r0=6∈[1...6], 8de0i7r0=3∈[1...6], 8de0i8r0=2∈[1...6], 8de0i9r0=3∈[1...6], 8de0i10r0=6∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2, red:3, red:6]}] +color(12d6,'red')|[Roll{expression='color(12d6,'red')', randomElementsInRoll=[[8de0i0r0=2∈[1...6], 8de0i1r0=3∈[1...6], 8de0i2r0=1∈[1...6], 8de0i3r0=4∈[1...6], 8de0i4r0=1∈[1...6], 8de0i5r0=1∈[1...6], 8de0i6r0=6∈[1...6], 8de0i7r0=3∈[1...6], 8de0i8r0=2∈[1...6], 8de0i9r0=3∈[1...6], 8de0i10r0=6∈[1...6], 8de0i11r0=3∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2, red:3, red:6, red:3]}] +color(1D20+5=,'green')|[Roll{expression='color(1D20+5=,'green')', randomElementsInRoll=[[7De0i0r0=16∈[1...20]]], elements=[green:21]}] +color(1d6,'red')|[Roll{expression='color(1d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6]]], elements=[red:2]}] +color(1d6-1, 'red')|[Roll{expression='color(1d6-1,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6]]], elements=[red:2, red:-1]}] +color(2d6,'red')|[Roll{expression='color(2d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6]]], elements=[red:2, red:3]}] +color(3d6,'red')|[Roll{expression='color(3d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6], 7de0i2r0=1∈[1...6]]], elements=[red:2, red:3, red:1]}] +color(4d6,'red')|[Roll{expression='color(4d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6], 7de0i2r0=1∈[1...6], 7de0i3r0=4∈[1...6]]], elements=[red:2, red:3, red:1, red:4]}] +color(5d6,'red')|[Roll{expression='color(5d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6], 7de0i2r0=1∈[1...6], 7de0i3r0=4∈[1...6], 7de0i4r0=1∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1]}] +color(69, 'cyan')|[Roll{expression='color(69,'cyan')', randomElementsInRoll=[], elements=[cyan:69]}] +color(6d6,'red')|[Roll{expression='color(6d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6], 7de0i2r0=1∈[1...6], 7de0i3r0=4∈[1...6], 7de0i4r0=1∈[1...6], 7de0i5r0=1∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1, red:1]}] +color(7d6,'red')|[Roll{expression='color(7d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6], 7de0i2r0=1∈[1...6], 7de0i3r0=4∈[1...6], 7de0i4r0=1∈[1...6], 7de0i5r0=1∈[1...6], 7de0i6r0=6∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6]}] +color(8d6,'red')|[Roll{expression='color(8d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6], 7de0i2r0=1∈[1...6], 7de0i3r0=4∈[1...6], 7de0i4r0=1∈[1...6], 7de0i5r0=1∈[1...6], 7de0i6r0=6∈[1...6], 7de0i7r0=3∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3]}] +color(9d6,'red')|[Roll{expression='color(9d6,'red')', randomElementsInRoll=[[7de0i0r0=2∈[1...6], 7de0i1r0=3∈[1...6], 7de0i2r0=1∈[1...6], 7de0i3r0=4∈[1...6], 7de0i4r0=1∈[1...6], 7de0i5r0=1∈[1...6], 7de0i6r0=6∈[1...6], 7de0i7r0=3∈[1...6], 7de0i8r0=2∈[1...6]]], elements=[red:2, red:3, red:1, red:4, red:1, red:1, red:6, red:3, red:2]}] +color(D4, 'red')|[Roll{expression='color(D4,'red')', randomElementsInRoll=[[6De0i0r0=4∈[1...4]]], elements=[red:4]}] +color(d100, 'purple')|[Roll{expression='color(d100,'purple')', randomElementsInRoll=[[6de0i0r0=96∈[1...100]]], elements=[purple:96]}] +color(d20, 'red')|[Roll{expression='color(d20,'red')', randomElementsInRoll=[[6de0i0r0=16∈[1...20]]], elements=[red:16]}] +concat(2d6=,-2d3k1)|[Roll{expression='concat(2d6=,-2d3k1)', randomElementsInRoll=[[8de0i0r0=2∈[1...6], 8de0i1r0=3∈[1...6]], [14de0i0r0=1∈[1...3], 14de0i1r0=1∈[1...3]]], elements=[5-1]}] +concat(2d6=,-2d3k1=)|[Roll{expression='concat(2d6=,-2d3k1=)', randomElementsInRoll=[[8de0i0r0=2∈[1...6], 8de0i1r0=3∈[1...6]], [14de0i0r0=1∈[1...3], 14de0i1r0=1∈[1...3]]], elements=[5-1]}] +concat(2d6=,-2d3l1)|[Roll{expression='concat(2d6=,-2d3l1)', randomElementsInRoll=[[8de0i0r0=2∈[1...6], 8de0i1r0=3∈[1...6]], [14de0i0r0=1∈[1...3], 14de0i1r0=1∈[1...3]]], elements=[5-1]}] +d!!10|[Roll{expression='d!!10', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6]}] +d!!10+10|[Roll{expression='d!!10+10', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 10]}] +d!!10+11|[Roll{expression='d!!10+11', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 11]}] +d!!10+12|[Roll{expression='d!!10+12', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 12]}] +d!!10+13|[Roll{expression='d!!10+13', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 13]}] +d!!10+14|[Roll{expression='d!!10+14', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 14]}] +d!!10+15|[Roll{expression='d!!10+15', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 15]}] +d!!10+16|[Roll{expression='d!!10+16', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 16]}] +d!!10+17|[Roll{expression='d!!10+17', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 17]}] +d!!10+18|[Roll{expression='d!!10+18', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 18]}] +d!!10+19|[Roll{expression='d!!10+19', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 19]}] +d!!10+20|[Roll{expression='d!!10+20', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 20]}] +d!!10+6|[Roll{expression='d!!10+6', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 6]}] +d!!10+7|[Roll{expression='d!!10+7', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 7]}] +d!!10+8|[Roll{expression='d!!10+8', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 8]}] +d!!10+9|[Roll{expression='d!!10+9', randomElementsInRoll=[[0d!!e0i0r0=6∈[1...10]]], elements=[6, 9]}] +d!!2|[Roll{expression='d!!2', randomElementsInRoll=[[0d!!e0i0r0=2∈[1...2], 0d!!e0i0r1=2∈[1...2], 0d!!e0i0r2=2∈[1...2], 0d!!e0i0r3=2∈[1...2], 0d!!e0i0r4=1∈[1...2]]], elements=[9]}] +d10|[Roll{expression='d10', randomElementsInRoll=[[0de0i0r0=6∈[1...10]]], elements=[6]}] +d10+7|[Roll{expression='d10+7', randomElementsInRoll=[[0de0i0r0=6∈[1...10]]], elements=[6, 7]}] +d10+9|[Roll{expression='d10+9', randomElementsInRoll=[[0de0i0r0=6∈[1...10]]], elements=[6, 9]}] +d100|[Roll{expression='d100', randomElementsInRoll=[[0de0i0r0=96∈[1...100]]], elements=[96]}] +d10d12|[Roll{expression='d10d12', randomElementsInRoll=[[0de0i0r0=6∈[1...10]], [3de0i0r0=9∈[1...12], 3de0i1r0=7∈[1...12], 3de0i2r0=10∈[1...12], 3de0i3r0=7∈[1...12], 3de0i4r0=7∈[1...12], 3de0i5r0=12∈[1...12]]], elements=[9, 7, 10, 7, 7, 12]}] +d11|[Roll{expression='d11', randomElementsInRoll=[[0de0i0r0=4∈[1...11]]], elements=[4]}] +d12|[Roll{expression='d12', randomElementsInRoll=[[0de0i0r0=8∈[1...12]]], elements=[8]}] +d13|[Roll{expression='d13', randomElementsInRoll=[[0de0i0r0=6∈[1...13]]], elements=[6]}] +d14|[Roll{expression='d14', randomElementsInRoll=[[0de0i0r0=2∈[1...14]]], elements=[2]}] +d15|[Roll{expression='d15', randomElementsInRoll=[[0de0i0r0=11∈[1...15]]], elements=[11]}] +d16|[Roll{expression='d16', randomElementsInRoll=[[0de0i0r0=16∈[1...16]]], elements=[16]}] +d17|[Roll{expression='d17', randomElementsInRoll=[[0de0i0r0=2∈[1...17]]], elements=[2]}] +d18|[Roll{expression='d18', randomElementsInRoll=[[0de0i0r0=14∈[1...18]]], elements=[14]}] +d19|[Roll{expression='d19', randomElementsInRoll=[[0de0i0r0=18∈[1...19]]], elements=[18]}] +d2|[Roll{expression='d2', randomElementsInRoll=[[0de0i0r0=2∈[1...2]]], elements=[2]}] +d20|[Roll{expression='d20', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16]}] +d20 d100|[Roll{expression='d20d100', randomElementsInRoll=[[0de0i0r0=16∈[1...20]], [5de0i0r0=73∈[1...100], 5de0i1r0=51∈[1...100], 5de0i2r0=30∈[1...100], 5de0i3r0=51∈[1...100], 5de0i4r0=55∈[1...100], 5de0i5r0=60∈[1...100], 5de0i6r0=29∈[1...100], 5de0i7r0=100∈[1...100], 5de0i8r0=41∈[1...100], 5de0i9r0=66∈[1...100], 5de0i10r0=13∈[1...100], 5de0i11r0=55∈[1...100], 5de0i12r0=80∈[1...100], 5de0i13r0=28∈[1...100], 5de0i14r0=36∈[1...100], 5de0i15r0=19∈[1...100]]], elements=[73, 51, 30, 51, 55, 60, 29, 100, 41, 66, 13, 55, 80, 28, 36, 19]}] +d20 + 8|[Roll{expression='d20+8', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16, 8]}] +d20+1=|[Roll{expression='d20+1=', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[17]}] +d20+2|[Roll{expression='d20+2', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16, 2]}] +d20+2=|[Roll{expression='d20+2=', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[18]}] +d20+3=|[Roll{expression='d20+3=', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[19]}] +d20+4|[Roll{expression='d20+4', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16, 4]}] +d20+4=|[Roll{expression='d20+4=', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[20]}] +d20+5|[Roll{expression='d20+5', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16, 5]}] +d20+5=|[Roll{expression='d20+5=', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[21]}] +d20, 3d20|[Roll{expression='d20', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16]}, Roll{expression='3d20', randomElementsInRoll=[[6de0i0r0=13∈[1...20], 6de0i1r0=11∈[1...20], 6de0i2r0=10∈[1...20]]], elements=[13, 11, 10]}] +d20, d100|[Roll{expression='d20', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16]}, Roll{expression='d100', randomElementsInRoll=[[5de0i0r0=73∈[1...100]]], elements=[73]}] +d20,4d20,5d10,2d6|[Roll{expression='d20', randomElementsInRoll=[[0de0i0r0=16∈[1...20]]], elements=[16]}, Roll{expression='4d20', randomElementsInRoll=[[5de0i0r0=13∈[1...20], 5de0i1r0=11∈[1...20], 5de0i2r0=10∈[1...20], 5de0i3r0=11∈[1...20]]], elements=[13, 11, 10, 11]}, Roll{expression='5d10', randomElementsInRoll=[[10de0i0r0=5∈[1...10], 10de0i1r0=10∈[1...10], 10de0i2r0=9∈[1...10], 10de0i3r0=10∈[1...10], 10de0i4r0=1∈[1...10]]], elements=[5, 10, 9, 10, 1]}, Roll{expression='2d6', randomElementsInRoll=[[15de0i0r0=6∈[1...6], 15de0i1r0=3∈[1...6]]], elements=[6, 3]}] +d24|[Roll{expression='d24', randomElementsInRoll=[[0de0i0r0=8∈[1...24]]], elements=[8]}] +d3|[Roll{expression='d3', randomElementsInRoll=[[0de0i0r0=2∈[1...3]]], elements=[2]}] +d30|[Roll{expression='d30', randomElementsInRoll=[[0de0i0r0=26∈[1...30]]], elements=[26]}] +d4|[Roll{expression='d4', randomElementsInRoll=[[0de0i0r0=4∈[1...4]]], elements=[4]}] +d4+1=|[Roll{expression='d4+1=', randomElementsInRoll=[[0de0i0r0=4∈[1...4]]], elements=[5]}] +d4+3=|[Roll{expression='d4+3=', randomElementsInRoll=[[0de0i0r0=4∈[1...4]]], elements=[7]}] +d420|[Roll{expression='d420', randomElementsInRoll=[[0de0i0r0=296∈[1...420]]], elements=[296]}] +d47|[Roll{expression='d47', randomElementsInRoll=[[0de0i0r0=45∈[1...47]]], elements=[45]}] +d5|[Roll{expression='d5', randomElementsInRoll=[[0de0i0r0=1∈[1...5]]], elements=[1]}] +d6|[Roll{expression='d6', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2]}] +d6 x2|[Roll{expression='2', randomElementsInRoll=[], elements=[2]}, Roll{expression='2', randomElementsInRoll=[], elements=[2]}] +d6+1=|[Roll{expression='d6+1=', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[3]}] +d6, 2d6|[Roll{expression='d6', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='2d6', randomElementsInRoll=[[5de0i0r0=3∈[1...6], 5de0i1r0=1∈[1...6]]], elements=[3, 1]}] +d6, d6|[Roll{expression='d6', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='d6', randomElementsInRoll=[[4de0i0r0=3∈[1...6]]], elements=[3]}] +d6,2d6|[Roll{expression='d6', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='2d6', randomElementsInRoll=[[4de0i0r0=3∈[1...6], 4de0i1r0=1∈[1...6]]], elements=[3, 1]}] +d6,2d6=|[Roll{expression='d6', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='2d6=', randomElementsInRoll=[[4de0i0r0=3∈[1...6], 4de0i1r0=1∈[1...6]]], elements=[4]}] +d6,3d6|[Roll{expression='d6', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2]}, Roll{expression='3d6', randomElementsInRoll=[[4de0i0r0=3∈[1...6], 4de0i1r0=1∈[1...6], 4de0i2r0=4∈[1...6]]], elements=[3, 1, 4]}] +d6-1|[Roll{expression='d6-1', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2, -1]}] +d6-1, d6, d6+1|[Roll{expression='d6-1', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[2, -1]}, Roll{expression='d6', randomElementsInRoll=[[6de0i0r0=3∈[1...6]]], elements=[3]}, Roll{expression='d6+1', randomElementsInRoll=[[10de0i0r0=1∈[1...6]]], elements=[1, 1]}] +d6-1=|[Roll{expression='d6-1=', randomElementsInRoll=[[0de0i0r0=2∈[1...6]]], elements=[1]}] +d69|[Roll{expression='d69', randomElementsInRoll=[[0de0i0r0=68∈[1...69]]], elements=[68]}] +d7|[Roll{expression='d7', randomElementsInRoll=[[0de0i0r0=2∈[1...7]]], elements=[2]}] +d8|[Roll{expression='d8', randomElementsInRoll=[[0de0i0r0=8∈[1...8]]], elements=[8]}] +d8 + 10 + d4 +d4|[Roll{expression='d8+10+d4+d4', randomElementsInRoll=[[0de0i0r0=8∈[1...8]], [10de0i0r0=2∈[1...4]], [14de0i0r0=2∈[1...4]]], elements=[8, 10, 2, 2]}] +d8+1=|[Roll{expression='d8+1=', randomElementsInRoll=[[0de0i0r0=8∈[1...8]]], elements=[9]}] +d8+3=|[Roll{expression='d8+3=', randomElementsInRoll=[[0de0i0r0=8∈[1...8]]], elements=[11]}] +d8+5=|[Roll{expression='d8+5=', randomElementsInRoll=[[0de0i0r0=8∈[1...8]]], elements=[13]}] +d9|[Roll{expression='d9', randomElementsInRoll=[[0de0i0r0=5∈[1...9]]], elements=[5]}] +d[-1/0/1/1/2/3]=|[Roll{expression='d[-1/0/1/1/2/3]=', randomElementsInRoll=[[0de0i0r0=0∈[-1, 0, 1, 1, 2, 3]]], elements=[0]}] +d[-1/0/1/2/3]|[Roll{expression='d[-1/0/1/2/3]', randomElementsInRoll=[[0de0i0r0=-1∈[-1, 0, 1, 2, 3]]], elements=[-1]}] +d[-1/0/1/2/3]=|[Roll{expression='d[-1/0/1/2/3]=', randomElementsInRoll=[[0de0i0r0=-1∈[-1, 0, 1, 2, 3]]], elements=[-1]}] +d[-9/-8/-7/-6/-5/-4/-3/-2/-1/0/2/2/2/2/2/2/2/2/2/2/3/3/3/3/3/3/3/3/3/3/4/4/4/4/4/4/4/4/4/4/5/5/5/5/5/5/5/5/5/5/6/6/6/6/6/6/6/6/6/6/7/7/7/7/7/7/7/7/7/7/8/8/8/8/8/8/8/8/8/8/9/9/9/9/9/9/9/9/9/9/11/12/13/14/15/16/17/18/19/20]|[Roll{expression='d[-9/-8/-7/-6/-5/-4/-3/-2/-1/0/2/2/2/2/2/2/2/2/2/2/3/3/3/3/3/3/3/3/3/3/4/4/4/4/4/4/4/4/4/4/5/5/5/5/5/5/5/5/5/5/6/6/6/6/6/6/6/6/6/6/7/7/7/7/7/7/7/7/7/7/8/8/8/8/8/8/8/8/8/8/9/9/9/9/9/9/9/9/9/9/11/12/13/14/15/16/17/18/19/20]', randomElementsInRoll=[[0de0i0r0=16∈[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]]], elements=[16]}] +d[1,2,3,0,0,-1]|[Roll{expression='d[1,2,3,0,0,-1]', randomElementsInRoll=[[0de0i0r0=2∈[1, 2, 3, 0, 0, -1]]], elements=[2]}] +d[1/0/1/1/2/3]=|[Roll{expression='d[1/0/1/1/2/3]=', randomElementsInRoll=[[0de0i0r0=0∈[1, 0, 1, 1, 2, 3]]], elements=[0]}] +d[1/2/3/0/0/-1]|[Roll{expression='d[1/2/3/0/0/-1]', randomElementsInRoll=[[0de0i0r0=2∈[1, 2, 3, 0, 0, -1]]], elements=[2]}] +d[11/12/13/14/15/16/21/22/23/24/25/26/31/32/33/34/35/36/41/42/43/44/45/46/51/52/53/54/55/56/61/62/63/64/65/66]|[Roll{expression='d[11/12/13/14/15/16/21/22/23/24/25/26/31/32/33/34/35/36/41/42/43/44/45/46/51/52/53/54/55/56/61/62/63/64/65/66]', randomElementsInRoll=[[0de0i0r0=62∈[11, 12, 13, 14, 15, 16, 21, 22, 23, 24, 25, 26, 31, 32, 33, 34, 35, 36, 41, 42, 43, 44, 45, 46, 51, 52, 53, 54, 55, 56, 61, 62, 63, 64, 65, 66]]], elements=[62]}] +d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=|[Roll{expression='d[3/3/2/2/2/2/1/1/1/1/1/1/1/1/1/0/0/0/0/0/0/0]=', randomElementsInRoll=[[0de0i0r0=2∈[3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]]], elements=[2]}] +d[destreza/fuerza/inteligencia/sabiduria/Doom]+1d8|[Roll{expression='d[destreza/fuerza/inteligencia/sabiduria/Doom]+1d8', randomElementsInRoll=[[0de0i0r0=destreza∈[destreza, fuerza, inteligencia, sabiduria, Doom]], [48de0i0r0=2∈[1...8]]], elements=[destreza, 2]}] +d[destreza/fuerza/inteligencia/sabiduria]+1d8|[Roll{expression='d[destreza/fuerza/inteligencia/sabiduria]+1d8', randomElementsInRoll=[[0de0i0r0=sabiduria∈[destreza, fuerza, inteligencia, sabiduria]], [43de0i0r0=2∈[1...8]]], elements=[sabiduria, 2]}] +d[fuerza/destreza/sabiduria/inteligencia]|[Roll{expression='d[fuerza/destreza/sabiduria/inteligencia]', randomElementsInRoll=[[0de0i0r0=inteligencia∈[fuerza, destreza, sabiduria, inteligencia]]], elements=[inteligencia]}] +desc(1d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='desc(1d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[6de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Failure]}] +desc(2d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='desc(2d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[6de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i1r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Failure, Failure]}] +desc(3d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='desc(3d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[6de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i1r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i2r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Failure, Failure, Failure]}] +desc(4d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='desc(4d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[6de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i1r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i2r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i3r0=Partial∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Partial, Failure, Failure, Failure]}] +desc(5d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='desc(5d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[6de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i1r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i2r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i3r0=Partial∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i4r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Partial, Failure, Failure, Failure, Failure]}] +desc(6d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='desc(6d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[6de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i1r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i2r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i3r0=Partial∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i4r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i5r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Partial, Failure, Failure, Failure, Failure, Failure]}] +desc(7d[Failure/Failure/Failure/Partial/Partial/Success])|[Roll{expression='desc(7d[Failure/Failure/Failure/Partial/Partial/Success])', randomElementsInRoll=[[6de0i0r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i1r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i2r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i3r0=Partial∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i4r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i5r0=Failure∈[Failure, Failure, Failure, Partial, Partial, Success], 6de0i6r0=Success∈[Failure, Failure, Failure, Partial, Partial, Success]]], elements=[Success, Partial, Failure, Failure, Failure, Failure, Failure]}] +groupC (10d6)|[Roll{expression='groupC(10d6)', randomElementsInRoll=[[10de0i0r0=2∈[1...6], 10de0i1r0=3∈[1...6], 10de0i2r0=1∈[1...6], 10de0i3r0=4∈[1...6], 10de0i4r0=1∈[1...6], 10de0i5r0=1∈[1...6], 10de0i6r0=6∈[1...6], 10de0i7r0=3∈[1...6], 10de0i8r0=2∈[1...6], 10de0i9r0=3∈[1...6]]], elements=[3x1, 3x3, 2x2, 1x4, 1x6]}] +groupC (2d6)|[Roll{expression='groupC(2d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6]]], elements=[1x3, 1x2]}] +groupC (3d6)|[Roll{expression='groupC(3d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=1∈[1...6]]], elements=[1x1, 1x3, 1x2]}] +groupC (4d6)|[Roll{expression='groupC(4d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=1∈[1...6], 9de0i3r0=4∈[1...6]]], elements=[1x1, 1x4, 1x3, 1x2]}] +groupC (5d6)|[Roll{expression='groupC(5d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=1∈[1...6], 9de0i3r0=4∈[1...6], 9de0i4r0=1∈[1...6]]], elements=[2x1, 1x4, 1x3, 1x2]}] +groupC (6d6)|[Roll{expression='groupC(6d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=1∈[1...6], 9de0i3r0=4∈[1...6], 9de0i4r0=1∈[1...6], 9de0i5r0=1∈[1...6]]], elements=[3x1, 1x4, 1x3, 1x2]}] +groupC (7d6)|[Roll{expression='groupC(7d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=1∈[1...6], 9de0i3r0=4∈[1...6], 9de0i4r0=1∈[1...6], 9de0i5r0=1∈[1...6], 9de0i6r0=6∈[1...6]]], elements=[3x1, 1x4, 1x3, 1x6, 1x2]}] +groupC (8d6)|[Roll{expression='groupC(8d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=1∈[1...6], 9de0i3r0=4∈[1...6], 9de0i4r0=1∈[1...6], 9de0i5r0=1∈[1...6], 9de0i6r0=6∈[1...6], 9de0i7r0=3∈[1...6]]], elements=[3x1, 2x3, 1x4, 1x6, 1x2]}] +groupC (9d6)|[Roll{expression='groupC(9d6)', randomElementsInRoll=[[9de0i0r0=2∈[1...6], 9de0i1r0=3∈[1...6], 9de0i2r0=1∈[1...6], 9de0i3r0=4∈[1...6], 9de0i4r0=1∈[1...6], 9de0i5r0=1∈[1...6], 9de0i6r0=6∈[1...6], 9de0i7r0=3∈[1...6], 9de0i8r0=2∈[1...6]]], elements=[3x1, 2x3, 2x2, 1x4, 1x6]}] +ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Fail')|[Roll{expression='ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Fail')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Fail]}] +ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Failure')|[Roll{expression='ifE(1d[0/0/0/1/1/3],3,'Success',1,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Failure]}] +ifE(2d[0/0/0/1/1/3]l1,3,'Success',1,'Partial','Failure')|[Roll{expression='ifE(2d[0/0/0/1/1/3]l1,3,'Success',1,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Failure]}] +ifG((1-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((1-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Fail]}] +ifG((10-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((10-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[9de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((11-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((11-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[9de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((12-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((12-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[9de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((13-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((13-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[9de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((14-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((14-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[9de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((15-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((15-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[9de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((2-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((2-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Fail]}] +ifG((3-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((3-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Fail]}] +ifG((4-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((4-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Fail]}] +ifG((5-1d10)=,-1,'Success','Fail' )|[Roll{expression='ifG((5-1d10)=,-1,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Fail]}] +ifG((5-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((5-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Fail]}] +ifG((6-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((6-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Fail]}] +ifG((7-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((7-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((8-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((8-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG((9-1d10)=,0,'Success','Fail' )|[Roll{expression='ifG((9-1d10)=,0,'Success','Fail')', randomElementsInRoll=[[8de0i0r0=6∈[1...10]]], elements=[Success]}] +ifG(2d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll{expression='ifG(2d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Fail]}] +ifG(2d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll{expression='ifG(2d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Failure]}] +ifG(3d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll{expression='ifG(3d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Fail]}] +ifG(3d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll{expression='ifG(3d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Failure]}] +ifG(4d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll{expression='ifG(4d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3]]], elements=[Partial]}] +ifG(4d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll{expression='ifG(4d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3]]], elements=[Partial]}] +ifG(5d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll{expression='ifG(5d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3], 5de0i4r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Partial]}] +ifG(5d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll{expression='ifG(5d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3], 5de0i4r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Partial]}] +ifG(6d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll{expression='ifG(6d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3], 5de0i4r0=0∈[0, 0, 0, 1, 1, 3], 5de0i5r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Partial]}] +ifG(6d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll{expression='ifG(6d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3], 5de0i4r0=0∈[0, 0, 0, 1, 1, 3], 5de0i5r0=0∈[0, 0, 0, 1, 1, 3]]], elements=[Partial]}] +ifG(7d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')|[Roll{expression='ifG(7d[0/0/0/1/1/3]k2=,5,'Crit',2,'Success',0,'Partial','Fail')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3], 5de0i4r0=0∈[0, 0, 0, 1, 1, 3], 5de0i5r0=0∈[0, 0, 0, 1, 1, 3], 5de0i6r0=3∈[0, 0, 0, 1, 1, 3]]], elements=[Success]}] +ifG(7d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')|[Roll{expression='ifG(7d[0/0/0/1/1/3]k2=,5,'Critical',2,'Success',0,'Partial','Failure')', randomElementsInRoll=[[5de0i0r0=0∈[0, 0, 0, 1, 1, 3], 5de0i1r0=0∈[0, 0, 0, 1, 1, 3], 5de0i2r0=0∈[0, 0, 0, 1, 1, 3], 5de0i3r0=1∈[0, 0, 0, 1, 1, 3], 5de0i4r0=0∈[0, 0, 0, 1, 1, 3], 5de0i5r0=0∈[0, 0, 0, 1, 1, 3], 5de0i6r0=3∈[0, 0, 0, 1, 1, 3]]], elements=[Success]}] +ifL(1d100,10,'Réussi','Raté')|[Roll{expression='ifL(1d100,10,'Réussi','Raté')', randomElementsInRoll=[[5de0i0r0=96∈[1...100]]], elements=[Raté]}] +ifL(1d20,1, '💩 ',10,'😱 ' ,17, '😵‍💫 ' , '🤐 ')|[Roll{expression='ifL(1d20,1,'💩 ',10,'😱 ',17,'😵‍💫 ','🤐 ')', randomElementsInRoll=[[5de0i0r0=16∈[1...20]]], elements=[😵‍💫 ]}] +ifL(1d20,2, '💩 ',10,'😱 ' ,17, '😵‍💫 ' , '🤐 ')|[Roll{expression='ifL(1d20,2,'💩 ',10,'😱 ',17,'😵‍💫 ','🤐 ')', randomElementsInRoll=[[5de0i0r0=16∈[1...20]]], elements=[😵‍💫 ]}] +ifL(1d20,2,'💥',20, '💯 ')ifE(1d20,1,'test')|[Roll{expression='ifL(1d20,2,'💥',20,'💯 ')', randomElementsInRoll=[[5de0i0r0=16∈[1...20]]], elements=[💯 ]}, Roll{expression='ifE(1d20,1,'test')', randomElementsInRoll=[[31de0i0r0=13∈[1...20]]], elements=[13]}] +ifL(1d6,3,'low','high')|[Roll{expression='ifL(1d6,3,'low','high')', randomElementsInRoll=[[5de0i0r0=2∈[1...6]]], elements=[low]}] +max(1d!!10)-min(1d!!10)=|[Roll{expression='max(1d!!10)-min(1d!!10)=', randomElementsInRoll=[[5d!!e0i0r0=6∈[1...10]], [17d!!e0i0r0=3∈[1...10]]], elements=[3]}] +max(1d!!10)-min(1d10)=|[Roll{expression='max(1d!!10)-min(1d10)=', randomElementsInRoll=[[5d!!e0i0r0=6∈[1...10]], [17de0i0r0=3∈[1...10]]], elements=[3]}] +max(1d!!10-1d10)=|[Roll{expression='max(1d!!10-1d10)=', randomElementsInRoll=[[5d!!e0i0r0=6∈[1...10]], [12de0i0r0=3∈[1...10]]], elements=[6]}] +max(1d10)-min(1d10)|[Roll{expression='max(1d10)-min(1d10)', randomElementsInRoll=[[5de0i0r0=6∈[1...10]], [15de0i0r0=3∈[1...10]]], elements=[6, -3]}] +max(1d10)-min(1d10)=|[Roll{expression='max(1d10)-min(1d10)=', randomElementsInRoll=[[5de0i0r0=6∈[1...10]], [15de0i0r0=3∈[1...10]]], elements=[3]}] +max(1d20,1d20)|[Roll{expression='max(1d20,1d20)', randomElementsInRoll=[[5de0i0r0=16∈[1...20]], [10de0i0r0=13∈[1...20]]], elements=[16]}] +max(1d20,1d20)+4|[Roll{expression='max(1d20,1d20)+4', randomElementsInRoll=[[5de0i0r0=16∈[1...20]], [10de0i0r0=13∈[1...20]]], elements=[16, 4]}] +max(1d20,1d20)+7|[Roll{expression='max(1d20,1d20)+7', randomElementsInRoll=[[5de0i0r0=16∈[1...20]], [10de0i0r0=13∈[1...20]]], elements=[16, 7]}] +max(2d20)|[Roll{expression='max(2d20)', randomElementsInRoll=[[5de0i0r0=16∈[1...20], 5de0i1r0=13∈[1...20]]], elements=[16]}] +max(2d20)+4|[Roll{expression='max(2d20)+4', randomElementsInRoll=[[5de0i0r0=16∈[1...20], 5de0i1r0=13∈[1...20]]], elements=[16, 4]}] +max(2d20)+4=|[Roll{expression='max(2d20)+4=', randomElementsInRoll=[[5de0i0r0=16∈[1...20], 5de0i1r0=13∈[1...20]]], elements=[20]}] +max(2d20)+7|[Roll{expression='max(2d20)+7', randomElementsInRoll=[[5de0i0r0=16∈[1...20], 5de0i1r0=13∈[1...20]]], elements=[16, 7]}] +max(2d20)+7=|[Roll{expression='max(2d20)+7=', randomElementsInRoll=[[5de0i0r0=16∈[1...20], 5de0i1r0=13∈[1...20]]], elements=[23]}] +max(2d20)=|[Roll{expression='max(2d20)=', randomElementsInRoll=[[5de0i0r0=16∈[1...20], 5de0i1r0=13∈[1...20]]], elements=[16]}] \ No newline at end of file