{"header":{"message":"significant gains in algebra library","description":null,"timestamp":"2023-08-20T01:12:33.656476556Z","authors":[{}]},"hash":"BJNMXUGSKSQWBHVMRW47WAQ7ZKJ7VKM3WQ3ITYKFU3COU6ILLFOQC","authors":[{"key":"GPeTJGuaAryfKVDHpJLoiRAiv9jDq5aAapfNcWjYu16v"}],"deps":{"hashes":[["BJNMXUGSKSQWBHVMRW47WAQ7ZKJ7VKM3WQ3ITYKFU3COU6ILLFOQC","significant gains in algebra library"],["AA",null],["KP5ZHGFKZZV35ZEH2AZW2HAFF6XXTK4XVLUI3D62ZTBPNOTQJONAC","adding solver code and other bits of changes, need to record more often"],["I2I3WERCRM7KAHR477JRZSN5XNXUIAWMDFQK25LV6L7VDZJTTANQC","new configure"],["Q7P6NO6DTAU3Z7JQ6HNQIQPGWPQHW37RRI5A5HDJYNC7IJCQ4XSQC","initial with alias and tabula"]],"deps":["KP5ZHGFKZZV35ZEH2AZW2HAFF6XXTK4XVLUI3D62ZTBPNOTQJONAC"],"known":["Q7P6NO6DTAU3Z7JQ6HNQIQPGWPQHW37RRI5A5HDJYNC7IJCQ4XSQC","I2I3WERCRM7KAHR477JRZSN5XNXUIAWMDFQK25LV6L7VDZJTTANQC"]},"hunks":[{"FileAdd":{"meta":{"basename":"src","metadata":576},"context":[{"change":3,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"tabula.c","metadata":0},"context":[{"change":0,"pos":15}],"contents":[{"Add":"#define TABULA_IMPLEMENTATION 1"},{"Add":"#include "}]}},{"Edit":{"inode":{"change":2,"pos":1755},"path":"solver/test/algebra.c","line":4,"atom":{"NewVertex":{"up_context":[{"change":2,"pos":1823}],"down_context":[{"change":2,"pos":1823}],"flag":"BLOCK","start":104,"end":350,"inode":{"change":2,"pos":1755}}},"contents":[{"Add":""},{"Add":"static void echo_test(const char * input) {"},{"Add":" struct solver_Algebra a;"},{"Add":" solver_Algebra_init(&a);"},{"Add":""},{"Add":" uint64_t value = solver_Algebra_parse(&a, input);"},{"Add":" printf(\"'%s' =? \", input);"},{"Add":" solver_Algebra_show(&a, value);"},{"Add":""},{"Add":" solver_Algebra_free(&a); "},{"Add":"}"}]}},{"Edit":{"inode":{"change":2,"pos":1755},"path":"solver/test/algebra.c","line":16,"atom":{"NewVertex":{"up_context":[{"change":2,"pos":1824}],"down_context":[{"change":2,"pos":1824}],"flag":"BLOCK","start":351,"end":447,"inode":{"change":2,"pos":1755}}},"contents":[{"Add":"static void test_parse(void) {"},{"Add":" echo_test(\"2\");"},{"Add":" echo_test(\"2 + 2\");"},{"Add":" echo_test(\"2 + x\");"},{"Add":"}"},{"Add":""}]}},{"Edit":{"inode":{"change":2,"pos":1755},"path":"solver/test/algebra.c","line":45,"atom":{"NewVertex":{"up_context":[{"change":2,"pos":2437}],"down_context":[{"change":2,"pos":2437}],"flag":"BLOCK","start":448,"end":464,"inode":{"change":2,"pos":1755}}},"contents":[{"Add":" test_parse();"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":7,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":2590},"to":{"change":2,"start":2590,"end":14101},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"\n// 0x7 f f 8 | 7 \n// <01111111 1111 12-bit nan header> <1-bit silent flag, 0 on most cpus> <3-bit tag> <48-bit payload>\n// 000 - variable - pointer to variable name\n// 001 - atom\n// 010 - integer - 32-bit integer\n// 011 - integer - pointer to big integer implementation\n// 100 - pair - <3-bit type> <21-bit unused> <24-bit index to first>\n// 000 - fraction\n// 001 - power\n// 010 - unused\n// 011 - unused\n// 100 - equals\n// 101 - not equals\n// 110 - less than\n// 111 - greater than\n// 101 - list - <1-bit type> <23-bit count> <24-bit index to first>\n// 0 - sum\n// 1 - product\n// 110 - unused\n// 111 - unused\n\n#define NAN_MASK 0xFFF0000000000000ull\n#define NAN_BITS 0x7FF0000000000000ull\n#define QUEIT_BITS 0x7FF0000000000000ull\n#define SIGNALING_BITS 0x7FF8000000000000ull\n#define TAG_MASK 0xFFF7000000000000ull\n#define TAG_VARIABLE_BITS 0x7FF0000000000000ull\n#define TAG_ATOM_BITS 0x7FF1000000000000ull\n#define TAG_INTEGER_BITS 0x7FF2000000000000ull\n#define TAG_BIGINT_BITS 0x7FF3000000000000ull\n#define TAG_PAIR_BITS 0x7FF4000000000000ull\n#define TAG_LIST_BITS 0x7FF5000000000000ull\n#define TAG_UNUSED1_BITS 0x7FF6000000000000ull\n#define TAG_UNUSED2_BITS 0x7FF7000000000000ull\n#define PAIR_MASK 0xFFF7e00000000000ull\n#define PAIR_FRACTION_BITS 0x7FF4000000000000ull\n#define PAIR_POWER_BITS 0x7FF4200000000000ull\n#define PAIR_UNUSED1_BITS 0x7FF4400000000000ull\n#define PAIR_UNUSED2_BITS 0x7FF4600000000000ull\n#define PAIR_EQUAL_BITS 0x7FF4800000000000ull\n#define PAIR_NOT_EQUAL_BITS 0x7FF4a00000000000ull\n#define PAIR_LESS_THAN_BITS 0x7FF4c00000000000ull\n#define PAIR_GREATER_THAN_BITS 0x7FF4e00000000000ull\n#define LIST_MASK 0xFFF7800000000000ull\n#define LIST_SUM_BITS 0x7FF5000000000000ull\n#define LIST_PRODUCT_BITS 0x7FF5800000000000ull\n#define PAYLOAD_MASK 0x0000FFFFFFFFFFFFull\n#define PAIR_INDEX_MASK 0x0000000000FFFFFFull\n#define LIST_COUNT_MASK 0x00007FFFFF000000ull\n#define LIST_INDEX_MASK 0x0000000000FFFFFFull\n\nstruct Unpacked {\n enum {\n Unpacked_Real,\n Unpacked_Variable,\n Unpacked_Boolean, // atom 0 and 1\n Unpacked_Undefined, // atom 2\n Unpacked_Integer,\n Unpacked_BigInteger,\n Unpacked_Fraction,\n Unpacked_Power,\n Unpacked_Sum,\n Unpacked_Product,\n Unpacked_Equals,\n Unpacked_NotEquals,\n Unpacked_LessThan,\n Unpacked_GreaterThan,\n Unpacked_Invalid\n } tag;\n union {\n double real;\n const char *variable;\n bool boolean;\n int64_t integer;\n void * big_integer;\n struct {\n uint32_t index;\n } pair, fraction, power, equals, not_equals, less_than, greater_than;\n struct {\n uint32_t count;\n uint32_t index;\n } list, sum, product;\n };\n};\n\nstatic inline uint64_t pack_real(double real) {\n union {\n uint64_t u;\n double d;\n } _;\n _.d = real;\n return _.u;\n}\n\nstatic inline uint64_t pack_variable(const char *name) {\n return TAG_VARIABLE_BITS | ((uint64_t)name & PAYLOAD_MASK);\n}\n\nstatic inline uint64_t pack_boolean(bool value) {\n return TAG_ATOM_BITS | !!value; // assumes ! returns either 0 or 1\n}\n\nstatic inline uint64_t pack_undefined(void) {\n return TAG_ATOM_BITS | 2;\n}\n\nstatic inline uint64_t pack_integer(int32_t integer) {\n union {\n uint64_t u;\n int32_t i[2];\n } _;\n _.i[1] = integer;\n return TAG_INTEGER_BITS | (_.u & PAYLOAD_MASK);\n}\n\nstatic inline uint64_t pack_big_integer(void * ptr) {\n return TAG_BIGINT_BITS | ((uint64_t)ptr & PAYLOAD_MASK);\n}\n\nstatic inline uint64_t pack_fraction(uint32_t index) {\n return PAIR_FRACTION_BITS | index;\n}\n\nstatic inline uint64_t pack_power(uint32_t index) {\n return PAIR_POWER_BITS | index;\n}\n\nstatic inline uint64_t pack_sum(uint32_t count, uint32_t index) {\n return LIST_SUM_BITS | ((uint64_t)count << 24) | index;\n}\n\nstatic inline uint64_t pack_product(uint32_t count, uint32_t index) {\n return LIST_PRODUCT_BITS | ((uint64_t)count << 24) | index;\n}\n\nstatic inline uint64_t pack_equals(uint32_t index) {\n return PAIR_EQUAL_BITS | index;\n}\n\nstatic inline uint64_t pack_not_equals(uint32_t index) {\n return PAIR_NOT_EQUAL_BITS | index;\n}\n\nstatic inline uint64_t pack_less_than(uint32_t index) {\n return PAIR_LESS_THAN_BITS | index;\n}\n\nstatic inline uint64_t pack_greater_than(uint32_t index) {\n return PAIR_GREATER_THAN_BITS | index;\n}\n\nstatic inline uint64_t pack(struct Unpacked unpacked) {\n switch(unpacked.tag) {\n case Unpacked_Real:\n return pack_real(unpacked.real);\n case Unpacked_Variable:\n return pack_variable(unpacked.variable);\n case Unpacked_Boolean:\n return pack_boolean(unpacked.boolean);\n case Unpacked_Undefined:\n return pack_undefined();\n case Unpacked_Integer:\n return pack_integer(unpacked.integer);\n case Unpacked_BigInteger:\n return pack_big_integer(unpacked.big_integer);\n case Unpacked_Fraction:\n return pack_fraction(unpacked.fraction.index);\n case Unpacked_Power:\n return pack_power(unpacked.power.index);\n case Unpacked_Sum:\n return pack_sum(unpacked.sum.count, unpacked.sum.index);\n case Unpacked_Product:\n return pack_product(unpacked.product.count, unpacked.product.index);\n case Unpacked_Equals:\n return pack_equals(unpacked.equals.index);\n case Unpacked_NotEquals:\n return pack_not_equals(unpacked.not_equals.index);\n case Unpacked_LessThan:\n return pack_not_equals(unpacked.less_than.index);\n case Unpacked_GreaterThan:\n return pack_not_equals(unpacked.greater_than.index);\n case Unpacked_Invalid:\n return SIGNALING_BITS;\n }\n}\n\nstatic inline bool is_real(uint64_t bits) {\n return (bits & NAN_MASK) != NAN_BITS;\n}\n\nstatic inline bool is_variable(uint64_t bits) {\n return (bits & TAG_MASK) == TAG_VARIABLE_BITS;\n}\n\nstatic inline bool is_boolean(uint64_t bits) {\n return (bits & TAG_MASK) == TAG_ATOM_BITS && (bits & (PAYLOAD_MASK ^ 1)) == 0;\n}\n\nstatic inline bool is_undefined(uint64_t bits) {\n return bits == TAG_ATOM_BITS | 2;\n}\n\nstatic inline bool is_integer(uint64_t bits) {\n return (bits & TAG_MASK) == TAG_INTEGER_BITS;\n}\n\nstatic inline bool is_big_integer(uint64_t bits) {\n return (bits & TAG_MASK) == TAG_BIGINT_BITS;\n}\n\nstatic inline bool is_fraction(uint64_t bits) {\n return (bits & PAIR_MASK) == PAIR_FRACTION_BITS;\n}\n\nstatic inline bool is_power(uint64_t bits) {\n return (bits & PAIR_MASK) == PAIR_POWER_BITS;\n}\n\nstatic inline bool is_sum(uint64_t bits) {\n return (bits & LIST_MASK) == LIST_SUM_BITS;\n}\n\nstatic inline bool is_product(uint64_t bits) {\n return (bits & LIST_MASK) == LIST_PRODUCT_BITS;\n}\n\nstatic inline bool is_equals(uint64_t bits) {\n return (bits & PAIR_MASK) == PAIR_EQUAL_BITS;\n}\n\nstatic inline bool is_not_equals(uint64_t bits) {\n return (bits & PAIR_MASK) == PAIR_NOT_EQUAL_BITS;\n}\n\nstatic inline bool is_less_than(uint64_t bits) {\n return (bits & PAIR_MASK) == PAIR_LESS_THAN_BITS;\n}\n\nstatic inline bool is_greater_than(uint64_t bits) {\n return (bits & PAIR_MASK) == PAIR_GREATER_THAN_BITS;\n}\n\nstatic inline double unpack_real(uint64_t bits) {\n union {\n uint64_t u;\n double d;\n } _;\n assert(is_real(bits));\n _.u = bits;\n return _.d;\n}\n\nstatic inline const char * unpack_variable(uint64_t bits) {\n assert(is_variable(bits));\n return (const char *)(bits & PAYLOAD_MASK);\n}\n\nstatic inline bool unpack_boolean(uint64_t bits) {\n assert(is_boolean(bits));\n return !!(bits & 1);\n}\n\nstatic inline void unpack_undefined(uint64_t bits) {\n assert(is_undefined(bits));\n}\n\nstatic inline int32_t unpack_integer(uint64_t bits) {\n union {\n uint64_t u;\n int32_t i[2];\n } _;\n assert(is_integer(bits));\n _.u = bits & PAYLOAD_MASK;\n return _.i[1];\n}\n\nstatic inline void * unpack_big_integer(uint64_t bits) {\n assert(is_big_integer(bits));\n return (void *)(bits & PAYLOAD_MASK);\n}\n\nstatic inline uint32_t unpack_fraction(uint64_t bits) {\n assert(is_fraction(bits));\n return bits & PAIR_INDEX_MASK;\n}\n\nstatic inline uint32_t unpack_power(uint64_t bits) {\n assert(is_power(bits));\n return bits & PAIR_INDEX_MASK;\n}\n\nstatic inline void unpack_sum(uint64_t bits, uint32_t *count, uint32_t *index) {\n assert(is_sum(bits));\n *count = (bits & LIST_COUNT_MASK) >> 24;\n *index = bits & LIST_INDEX_MASK;\n}\n\nstatic inline void unpack_product(uint64_t bits, uint32_t *count, uint32_t *index) {\n assert(is_product(bits));\n *count = (bits & LIST_COUNT_MASK) >> 24;\n *index = bits & LIST_INDEX_MASK;\n}\n\nstatic inline uint32_t unpack_equals(uint64_t bits) {\n assert(is_equals(bits));\n return bits & PAIR_INDEX_MASK;\n}\n\nstatic inline uint32_t unpack_not_equals(uint64_t bits) {\n assert(is_not_equals(bits));\n return bits & PAIR_INDEX_MASK;\n}\n\nstatic inline uint32_t unpack_less_than(uint64_t bits) {\n assert(is_less_than(bits));\n return bits & PAIR_INDEX_MASK;\n}\n\nstatic inline uint32_t unpack_greater_than(uint64_t bits) {\n assert(is_greater_than(bits));\n return bits & PAIR_INDEX_MASK;\n}\n\n\nstatic int unpack_tag(uint64_t bits) {\n if(is_real(bits)) {\n return Unpacked_Real;\n } else if(is_variable(bits)) {\n return Unpacked_Variable;\n } else if(is_boolean(bits)) {\n return Unpacked_Boolean;\n } else if(is_undefined(bits)) {\n return Unpacked_Undefined;\n } else if(is_integer(bits)) {\n return Unpacked_Integer;\n } else if(is_big_integer(bits)) {\n return Unpacked_BigInteger;\n } else if(is_fraction(bits)) {\n return Unpacked_Fraction;\n } else if(is_power(bits)) {\n return Unpacked_Power;\n } else if(is_equals(bits)) {\n return Unpacked_Equals;\n } else if(is_not_equals(bits)) {\n return Unpacked_NotEquals;\n } else if(is_less_than(bits)) {\n return Unpacked_LessThan;\n } else if(is_greater_than(bits)) {\n return Unpacked_GreaterThan;\n } else if(is_sum(bits)) {\n return Unpacked_Sum;\n } else if(is_product(bits)) {\n return Unpacked_Product;\n } else {\n return Unpacked_Invalid;\n }\n}\n\nstatic inline struct Unpacked unpack(uint64_t bits) {\n struct Unpacked result;\n switch(result.tag = unpack_tag(bits)) {\n case Unpacked_Real:\n result.real = unpack_real(bits);\n break;\n case Unpacked_Variable:\n result.variable = unpack_variable(bits);\n break;\n case Unpacked_Boolean:\n result.boolean = unpack_boolean(bits);\n break;\n case Unpacked_Undefined:\n unpack_undefined(bits);\n break;\n case Unpacked_Integer:\n result.integer = unpack_integer(bits);\n break;\n case Unpacked_BigInteger:\n result.big_integer = unpack_big_integer(bits);\n break;\n case Unpacked_Fraction:\n result.fraction.index = (bits & PAIR_INDEX_MASK);\n break;\n case Unpacked_Power:\n result.power.index = (bits & PAIR_INDEX_MASK);\n break;\n case Unpacked_Sum:\n unpack_sum(bits, &result.sum.count, &result.sum.index);\n break;\n case Unpacked_Product:\n unpack_product(bits, &result.product.count, &result.product.index);\n break;\n case Unpacked_Equals:\n result.equals.index = unpack_equals(bits);\n break;\n case Unpacked_NotEquals:\n result.not_equals.index = unpack_not_equals(bits);\n break;\n case Unpacked_LessThan:\n result.less_than.index = unpack_less_than(bits);\n break;\n case Unpacked_GreaterThan:\n result.greater_than.index = unpack_greater_than(bits);\n break;\n case Unpacked_Invalid:\n break;\n }\n return result;\n}\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":8,"ins":{"up_context":[{"change":2,"pos":14102}],"down_context":[{"change":2,"pos":14371}],"flag":"BLOCK","start":465,"end":497,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":14102},"to":{"change":2,"start":14102,"end":14371},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"#include \"algebra-encoding.inc\""}],"del_contents":[{"Del":"// --------------------------------------------------------------------------------------------------------------------\n// numerics\nstatic inline bool is_number(uint64_t bits) {\n return is_real(bits) || is_integer(bits) || is_big_integer(bits) || is_fraction(bits);\n}\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":10,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":14372},"to":{"change":2,"start":14372,"end":14698},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"static inline bool is_exact(uint64_t bits) {\n return is_integer(bits) || is_big_integer(bits) || is_fraction(bits);\n}\n\nstatic inline bool is_inexact(uint64_t bits) {\n return is_real(bits);\n}\n\n// --------------------------------------------------------------------------------------------------------------------\n// lifetime\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":18,"ins":{"up_context":[{"change":2,"pos":14882}],"down_context":[{"change":2,"pos":15740}],"flag":"BLOCK","start":498,"end":587,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":14882},"to":{"change":2,"start":14882,"end":15740},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"uint64_t solver_Algebra_undefined(struct solver_Algebra *a) {"},{"Add":" return pack_undefined();"}],"del_contents":[{"Del":"// --------------------------------------------------------------------------------------------------------------------\n// creation entry points , most go through simplification before being committed to memory\nstatic uint64_t simplify_real(struct solver_Algebra *a, double real);\nstatic uint64_t simplify_fraction(struct solver_Algebra *a, uint64_t numerator, uint64_t denominator);\n\nuint64_t solver_Algebra_boolean(struct solver_Algebra *a, bool value) {\n return pack_boolean(value);\n}\n\nuint64_t solver_Algebra_integer(struct solver_Algebra *a, int64_t value) {\n return pack_integer(value);\n}\n\nuint64_t solver_Algebra_fraction(struct solver_Algebra *a, int64_t numerator, int64_t denominator) {\n return simplify_fraction(numerator, denominator);\n}\n\nuint64_t solver_Algebra_real(struct solver_Algebra *a, double value) {\n return simplify_real(a, real);\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":24,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":15853},"to":{"change":2,"start":15853,"end":25411},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"}\n\nuint64_t solver_Algebra_sum(struct solver_Algebra *a, uint32_t num_operands, const uint64_t *operands) {\n uint32_t index = embed(a, num_operands, operands);\n return pack_sum(num_operands, index);\n}\n\nuint64_t solver_Algebra_product(struct solver_Algebra *a, uint32_t num_operands, const uint64_t *operands) {\n uint32_t index = embed(a, num_operands, operands);\n return pack_product(num_operands, index);\n}\n\nuint64_t solver_Algebra_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n uint64_t operands[2] = {lhs, rhs};\n return solver_Algebra_sum(a, 2, operands);\n}\n\nuint64_t solver_Algebra_multiply(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n uint64_t operands[2] = {lhs, rhs};\n return solver_Algebra_product(a, 2, operands);\n}\n\nuint64_t solver_Algebra_negate(struct solver_Algebra *a, uint64_t expr) {\n if(is_number(expr)) {\n return number_negate(a, expr);\n }\n\n return solver_Algebra_multiply(a, solver_Algebra_integer(a, -1), expr);\n}\n\nuint64_t solver_Algebra_subtract(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n return solver_Algebra_add(a, lhs, solver_Algebra_negate(a, rhs));\n}\n\nuint64_t solver_Algebra_divide(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n return solver_Algebra_multiply(a, lhs, solver_Algebra_power(a, rhs, solver_Algebra_integer(a, -1)));\n}\n\nuint64_t solver_Algebra_power(struct solver_Algebra *a, uint64_t base, uint64_t exponent) {\n uint64_t values[2];\n values[0] = base;\n values[1] = exponent;\n uint32_t index = embed(a, 2, values);\n return pack_power(index);\n}\n\nuint64_t solver_Algebra_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n uint64_t values[2];\n values[0] = lhs;\n values[1] = rhs;\n uint32_t index = embed(a, 2, values);\n return pack_equals(index);\n}\n\nuint64_t solver_Algebra_not_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n uint64_t values[2];\n values[0] = lhs;\n values[1] = rhs;\n uint32_t index = embed(a, 2, values);\n return pack_not_equals(index);\n}\n\nuint64_t solver_Algebra_less_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n uint64_t values[2];\n values[0] = lhs;\n values[1] = rhs;\n uint32_t index = embed(a, 2, values);\n return pack_less_than(index);\n}\n\nuint64_t solver_Algebra_greater_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n uint64_t values[2];\n values[0] = lhs;\n values[1] = rhs;\n uint32_t index = embed(a, 2, values);\n return pack_greater_than(index);\n}\n\n// --------------------------------------------------------------------------------------------------------------------\n// solver_Algebra_show\n#define PRECEDENCE_NUMBER 1000\n#define PRECEDENCE_SUM 110\n#define PRECEDENCE_PRODUCT 120\n#define PRECEDENCE_POWER 130\n\nstatic int precedence(uint64_t bits) {\n struct Unpacked unpacked = unpack(bits);\n switch(unpacked.tag) {\n case Unpacked_Real:\n case Unpacked_Variable:\n case Unpacked_Integer:\n case Unpacked_BigInteger:\n case Unpacked_Fraction:\n return PRECEDENCE_NUMBER;\n case Unpacked_Power:\n return PRECEDENCE_POWER;\n case Unpacked_Sum:\n return PRECEDENCE_SUM;\n case Unpacked_Product:\n return PRECEDENCE_PRODUCT;\n default:\n return 0;\n }\n}\n\nstatic void show(struct solver_Algebra *a, uint64_t bits, bool parens);\n\nstatic void show_real(struct solver_Algebra *a, uint64_t bits) {\n printf(\"%f\", unpack_real(bits));\n}\n\nstatic void show_variable(struct solver_Algebra *a, uint64_t bits) {\n printf(\"%s\", unpack_variable(bits));\n}\n\nstatic void show_boolean(struct solver_Algebra *a, uint64_t bits) {\n bool v = unpack_boolean(bits);\n printf(\"%s\", v ? \"true\" : \"false\");\n}\n\nstatic void show_undefined(struct solver_Algebra *a, uint64_t bits) {\n unpack_undefined(bits);\n printf(\"undefined\");\n}\n\nstatic void show_integer(struct solver_Algebra *a, uint64_t bits) {\n printf(\"%lu\", unpack_integer(bits));\n}\n\nstatic void show_big_integer(struct solver_Algebra *a, uint64_t bits) {\n printf(\"%p\", unpack_big_integer(bits));\n}\n\nstatic void show_fraction(struct solver_Algebra *a, uint64_t bits) {\n uint32_t index = unpack_fraction(bits);\n uint64_t car = a->values.data[index + 0];\n uint64_t cdr = a->values.data[index + 1];\n show(a, car, false);\n printf(\"/\");\n show(a, cdr, false);\n}\n\nstatic void show_power(struct solver_Algebra *a, uint64_t bits) {\n uint32_t index = unpack_power(bits);\n uint64_t car = a->values.data[index + 0];\n uint64_t cdr = a->values.data[index + 1];\n show(a, car, precedence(car) < PRECEDENCE_POWER);\n printf(\"/\");\n show(a, cdr, precedence(cdr) < PRECEDENCE_POWER);\n}\n\nstatic void show_sum(struct solver_Algebra *a, uint64_t bits) {\n uint32_t count;\n uint32_t index;\n unpack_sum(bits, &count, &index);\n for(uint32_t i = 0; i < count; i++) {\n uint64_t operand = a->values.data[index + i];\n if(i > 0) {\n printf(\" + \");\n }\n show(a, operand, precedence(operand) < PRECEDENCE_SUM);\n }\n}\n\nstatic void show_product(struct solver_Algebra *a, uint64_t bits) {\n uint32_t count;\n uint32_t index;\n unpack_sum(bits, &count, &index);\n for(uint32_t i = 0; i < count; i++) {\n uint64_t operand = a->values.data[index + i];\n show(a, operand, precedence(operand) < PRECEDENCE_PRODUCT);\n if(i > 0) {\n printf(\" * \");\n }\n }\n}\n\nstatic void show_equals(struct solver_Algebra *a, uint64_t bits) {\n uint32_t index = unpack_equals(bits);\n uint64_t car = a->values.data[index + 0];\n uint64_t cdr = a->values.data[index + 1];\n show(a, car, false);\n printf(\" == \");\n show(a, cdr, false);\n}\n\nstatic void show_not_equals(struct solver_Algebra *a, uint64_t bits) {\n uint32_t index = unpack_not_equals(bits);\n uint64_t car = a->values.data[index + 0];\n uint64_t cdr = a->values.data[index + 1];\n show(a, car, false);\n printf(\" != \");\n show(a, cdr, false);\n}\n\nstatic void show_less_than(struct solver_Algebra *a, uint64_t bits) {\n uint32_t index = unpack_less_than(bits);\n uint64_t car = a->values.data[index + 0];\n uint64_t cdr = a->values.data[index + 1];\n show(a, car, false);\n printf(\" < \");\n show(a, cdr, false);\n}\n\nstatic void show_greater_than(struct solver_Algebra *a, uint64_t bits) {\n uint32_t index = unpack_greater_than(bits);\n uint64_t car = a->values.data[index + 0];\n uint64_t cdr = a->values.data[index + 1];\n show(a, car, false);\n printf(\" > \");\n show(a, cdr, false);\n}\n\nstatic void show(struct solver_Algebra *a, uint64_t bits, bool parens) {\n if(parens) printf(\"(\");\n switch(unpack_tag(bits)) {\n case Unpacked_Real:\n show_real(a, bits);\n break;\n case Unpacked_Variable:\n show_variable(a, bits);\n break;\n case Unpacked_Boolean:\n show_boolean(a, bits);\n break;\n case Unpacked_Undefined:\n show_undefined(a, bits);\n break;\n case Unpacked_Integer:\n show_integer(a, bits);\n break;\n case Unpacked_BigInteger:\n show_big_integer(a, bits);\n break;\n case Unpacked_Fraction:\n show_fraction(a, bits);\n break;\n case Unpacked_Power:\n show_power(a, bits);\n break;\n case Unpacked_Sum:\n show_sum(a, bits);\n break;\n case Unpacked_Product:\n show_product(a, bits);\n break;\n case Unpacked_Equals:\n show_equals(a, bits);\n break;\n case Unpacked_NotEquals:\n show_not_equals(a, bits);\n break;\n case Unpacked_LessThan:\n show_less_than(a, bits);\n break;\n case Unpacked_GreaterThan:\n show_greater_than(a, bits);\n break;\n case Unpacked_Invalid:\n break;\n }\n if(parens) printf(\")\");\n}\n\nvoid solver_Algebra_show(struct solver_Algebra *a, uint64_t bits) {\n show(a, bits, false);\n printf(\"\\n\");\n}\n\n// --------------------------------------------------------------------------------------------------------------------\n// boolean_not\nstatic uint64_t boolean_not(struct solver_Algebra *a, uint64_t expr_) {\n if(expr_ == TAG_ATOM_BITS | 0) return TAG_ATOM_BITS | 1;\n if(expr_ == TAG_ATOM_BITS | 1) return TAG_ATOM_BITS | 0;\n return TAG_ATOM_BITS | 2;\n}\n\n// --------------------------------------------------------------------------------------------------------------------\n// == !=\nstatic uint64_t equals(struct solver_Algebra *a, uint64_t lhs_, uint64_t rhs_);\n\nstatic uint64_t integer_integer_equals(struct solver_Algebra *a, uint64_t lhs_, uint64_t rhs_) {\n int64_t lhs = unpack_integer(lhs_);\n int64_t rhs = unpack_integer(rhs_);\n return pack_boolean(lhs == rhs);\n}\n\n// TODO\n\nstatic uint64_t equals(struct solver_Algebra *a, uint64_t lhs_, uint64_t rhs_) {\n int lhs_tag = unpack_tag(lhs_);\n int rhs_tag = unpack_tag(rhs_);\n\n if(lhs_tag == Unpacked_Integer && rhs_tag == Unpacked_Integer) {\n return integer_integer_equals(a, lhs_, rhs_);\n }\n\n if(lhs_tag != rhs_tag) {\n return pack_boolean(false);\n }\n\n return pack_undefined();\n}\n\nstatic uint64_t not_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n return boolean_not(a, equals(lhs, rhs));\n}\n\n// --------------------------------------------------------------------------------------------------------------------\n// < >\nstatic uint64_t integer_integer_less_than(struct solver_Algebra *a, uint64_t lhs_, uint64_t rhs_) {\n int64_t lhs = unpack_integer(lhs_);\n int64_t rhs = unpack_integer(rhs_);\n return pack_boolean(lhs < rhs);\n}\n\n// TODO\n\nstatic uint64_t less_than(struct solver_Algebra *a, uint64_t lhs_, uint64_t rhs_) {\n int lhs_tag = unpack_tag(lhs_);\n int rhs_tag = unpack_tag(rhs_);\n\n if(lhs_tag == Unpacked_Integer && rhs_tag == Unpacked_Integer) {\n return integer_integer_less_than(a, lhs_, rhs_);\n }\n\n return pack_undefined();\n}\n\nstatic uint64_t greater_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n return boolean_not(a, less_than(lhs, rhs));\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":26,"ins":{"up_context":[{"change":2,"pos":25414}],"down_context":[{"change":2,"pos":26768}],"flag":"BLOCK","start":588,"end":685,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":25414},"to":{"change":2,"start":25414,"end":26768},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"static uint32_t embed_values(struct solver_Algebra *a, uint32_t count, const uint64_t *values) {"}],"del_contents":[{"Del":"// --------------------------------------------------------------------------------------------------------------------\n// solver_Algebra_to_boolean\nuint64_t solver_Algebra_to_boolean(struct solver_Algebra *a, uint64_t expr_) {\n struct Unpacked expr = unpack(expr_);\n if(expr.tag == Unpacked_Boolean) {\n return expr_;\n }\n if(expr.tag == Unpacked_Equals || expr.tag == Unpacked_NotEquals || expr.tag == Unpacked_LessThan || expr.tag == Unpacked_GreaterThan) {\n uint64_t car, cdr;\n car = a->values.data[expr.pair.index + 0];\n cdr = a->values.data[expr.pair.index + 1];\n return expr.tag == Unpacked_Equals ? equals(a, car, cdr) :\n expr.tag == Unpacked_NotEquals ? not_equals(a, car, cdr) :\n expr.tag == Unpacked_LessThan ? less_than(a, car, cdr) :\n expr.tag == Unpacked_GreaterThan ? greater_than(a, car, cdr) :\n pack_undefined() ;\n } else {\n return pack_undefined();\n }\n}\n\n// --------------------------------------------------------------------------------------------------------------------\n// solver_Algebra_simplify\n// these actually create values into the algebra\nstatic uint64_t simplify(struct solver_Algebra *a, uint64_t expr);\n\nstatic uint32_t embed(struct solver_Algebra *a, uint32_t count, const uint64_t *values) {\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":32,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":27035},"to":{"change":2,"start":27035,"end":32942},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"}\n\nstatic uint64_t simplify_real(struct solver_Algebra *a, double real) {\n if(real == floor(real)) return pack_integer((int64_t)real);\n return pack_real(real);\n}\n\nstatic uint64_t simplify_big_integer(struct solver_Algebra *a, void * big_integer) {\n return pack_big_integer(big_integer);\n}\n\nstatic uint64_t simplify_fraction(struct solver_Algebra *a, uint64_t numerator, uint64_t denominator) {\n uint64_t values[2];\n values[0] = numberator;\n values[1] = denominator;\n uint32_t index = embed(a, 2, values);\n return pack_fraction(index);\n}\n\nstatic uint64_t simplify_power(struct solver_Algebra *a, uint64_t base, uint64_t exponent) {\n uint64_t values[2];\n values[0] = simplify(a, base);\n values[1] = simplify(a, exponent);\n if(is_number(values[0]) && is_number(values[1])) {\n return number_pow(values[0], values[1]);\n }\n uint32_t index = embed(a, 2, values);\n return pack_fraction(index);\n}\n\nstatic uint64_t simplify_sum(struct solver_Algebra *a, uint32_t num_operands, const uint64_t * operands) {\n struct {\n uint32_t num_operands;\n const uint64_t * operands;\n } stack[3], *top = stack + 3;\n\n if(num_operands == 0) {\n return pack_integer(a, 0);\n }\n\n if(num_operands == 1) {\n return operands[0];\n }\n\n if(num_operands == 2) {\n if(is_number(operands[0]) && is_number(operands[1])) {\n return number_add(a, operands[0], operands[1]);\n }\n\n if(is_sum(operands[0])) || is_sum(operands[1])) {\n --top;\n if(is_sum(operands[0])) {\n uint32_t index;\n unpack_sum(operands[0], &top->num_operands, &index);\n top->operands = a->values.data + index;\n } else {\n top->num_operands = 1;\n top->operands = &operands[0];\n }\n\n --top;\n if(is_sum(operands[1])) {\n uint32_t index;\n unpack_sum(operands[1], &top->num_operands, &index);\n top->operands = a->values.data + index;\n } else {\n top->num_operands = 1;\n top->operands = &operands[1];\n }\n }\n }\n}\n\nstatic uint64_t simplify(struct solver_Algebra *a, uint64_t expr) {\n struct Unpacked unpacked = unpack(expr);\n switch(unpacked.tag) {\n case Unpacked_Real:\n return simplify_real(a, unpacked.real);\n case Unpacked_Variable:\n return expr;\n case Unpacked_Boolean:\n return expr;\n case Unpacked_Undefined:\n return expr;\n case Unpacked_Integer:\n return expr;\n case Unpacked_BigInteger:\n return simplify_big_integer(a, unpacked.big_integer);\n case Unpacked_Fraction:\n return simplify_fraction(a, a->values.data[unpacked.fraction.index + 0], a->values.data[unpacked.fraction.index + 1]);\n case Unpacked_Power:\n return simplify_power(a, a->values.data[unpacked.power.index + 0], a->values.data[unpacked.power.index + 1]);\n case Unpacked_Sum:\n return simplify_sum(a, unpacked.sum.count, a->values.data + unpacked.sum.index);\n case Unpacked_Product:\n return simplify_product(a, unpacked.sum.count, a->values.data + unpacked.sum.index);\n case Unpacked_Equals:\n return simplify_equals(a, a->values.data[unpacked.power.index + 0], a->values.data[unpacked.power.index + 1]);\n case Unpacked_NotEquals:\n return simplify_not_equals(a, a->values.data[unpacked.power.index + 0], a->values.data[unpacked.power.index + 1]);\n case Unpacked_LessThan:\n return simplify_less_than(a, a->values.data[unpacked.power.index + 0], a->values.data[unpacked.power.index + 1]);\n case Unpacked_GreaterThan:\n return simplify_greater_than(a, a->values.data[unpacked.power.index + 0], a->values.data[unpacked.power.index + 1]);\n case Unpacked_Invalid:\n break;\n }\n}\n\nuint64_t solver_Algebra_simplify(struct solver_Algebra *a, uint64_t expr) {\n return simplify(a, expr);\n}\n\n#if 0\n\n// -- numerator\n\ndouble solver_Algebra_numerator(struct solver_Algebra *a, double expr) {\n uint64_t payload;\n switch(_decode(expr, &payload)) {\n case FRACTION:\n return first(a, expr);\n default:\n return expr;\n }\n}\n\n// -- denominator\n\ndouble solver_Algebra_denominator(struct solver_Algebra *a, double expr) {\n uint64_t payload;\n switch(_decode(expr, &payload)) {\n case FRACTION:\n return second(a, expr);\n default:\n return one(a);\n }\n}\n\n// -- simplify\n\nstatic double _simplify_power(struct solver_Algebra *a, double base, double exponent) {\n base = solver_Algebra_simplify(base);\n exponent = solver_Algebra_simplify(exponent);\n\n if(is_integer(base, 0)) return integer(0);\n if(is_integer(base, 1)) return integer(1);\n\n if(is_integer(exponent, 0)) return integer(1);\n if(is_integer(exponent, 1)) return base;\n\n uint64_t base_payload;\n uint64_t exponent_payload;\n\n int base_tag = _decode(base, &base_payload);\n int exponent_tag = _decode(exponent, &exponent_payload);\n\n if(base_tag == INTEGER) {\n if(exponent_tag == INTEGER) {\n } else if(exponent_tag == BIG_INTEGER) {\n } else if(exponent_tag == FRACTION) {\n } else if(exponent_tag == REAL) {\n }\n } else if(base_tag == BIG_INTEGER) {\n if(exponent_tag == INTEGER) {\n } else if(exponent_tag == BIG_INTEGER) {\n } else if(exponent_tag == FRACTION) {\n } else if(exponent_tag == REAL) {\n }\n } else if(base_tag == FRACTION) {\n if(exponent_tag == INTEGER) {\n } else if(exponent_tag == BIG_INTEGER) {\n } else if(exponent_tag == FRACTION) {\n } else if(exponent_tag == REAL) {\n }\n } else if(base_tag == REAL) {\n if(exponent_tag == INTEGER) {\n } else if(exponent_tag == BIG_INTEGER) {\n } else if(exponent_tag == FRACTION) {\n } else if(exponent_tag == REAL) {\n return pow(base, exponent);\n }\n }\n\n return solver_Algebra_power(a, base, exponent);\n}\n\n// numbers\nstatic double _number_gcd(struct solver_Algebra *a, double lhs, double rhs);\nstatic double _number_add(struct solver_Algebra *a, double lhs, double rhs);\nstatic double _number_multiply(struct solver_Algebra *a, double lhs, double rhs);\n\nstatic double _integer_integer_add(struct solver_Algebra *a, double lhs, double rhs) {\n\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":33,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":32944},"to":{"change":2,"start":32944,"end":34612},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"\nstatic double _number_add(struct solver_Algebra *a, double lhs, double rhs) {\n uint64_t lhs_payload;\n int lhs_tag = _decode(lhs, &lhs_payload);\n\n uint64_t rhs_payload;\n int rhs_tag = _decode(rhs, &rhs_payload);\n\n if(lhs_tag == INTEGER) {\n int64_t lhs_value = _decode_integer(lhs);\n if(rhs_tag == INTEGER) {\n int64_t rhs_value = _decode_integer(rhs);\n return solver_Algebra_integer(a, lhs + rhs);\n } else if(rhs_tag == BIG_INTEGER) {\n // TODO\n } else if(rhs_tag == FRACTION) {\n double numerator = first(a, rhs);\n double denominator = second(a, rhs);\n lhs = _number_multiply(a, lhs, denominator);\n numerator = _number_add(a, lhs, numerator);\n return solver_Algebra_fraction(a, numerator, denominator);\n } else if(rhs_tag == REAL) {\n return lhs_value * rhs;\n }\n } else if(lhs_tag == BIG_INTEGER) {\n // TODO\n if(rhs_tag == INTEGER) {\n } else if(rhs_tag == BIG_INTEGER) {\n } else if(rhs_tag == FRACTION) {\n } else if(rhs_tag == REAL) {\n }\n } else if(lhs_tag == FRACTION) {\n double lhs_numerator = first(a, lhs);\n double lhs_denominator = second(a, lhs);\n\n if(rhs_tag == INTEGER) {\n int64_t rhs_value = _decode_integer(rhs);\n rhs = _number_multiply(a, rhs, lhs_denominator);\n lhs_numerator = _number_add(a, rhs, lhs_numerator);\n return solver_Algebra_fraction(a, lhs_numerator, lhs_denominator);\n } else if(rhs_tag == BIG_INTEGER) {\n // TODO\n } else if(rhs_tag == FRACTION) {\n double rhs_numerator = first(a, rhs);\n double rhs_denominator = second(a, rhs); \n double denominator = _number_gcd(a, lhs_denominator, rhs_denominator);\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":34,"ins":{"up_context":[{"change":2,"pos":34613}],"down_context":[{"change":2,"pos":34877}],"flag":"BLOCK","start":686,"end":804,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":34613},"to":{"change":2,"start":34613,"end":34877},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"static uint64_t get_car(struct solver_Algebra *a, uint64_t expr) {"},{"Add":" return a->values.data[get_pair_index(expr) + 0];"}],"del_contents":[{"Del":" \n } else if(rhs_tag == REAL) {\n }\n } else if(lhs_tag == REAL) {\n if(rhs_tag == INTEGER) {\n } else if(rhs_tag == BIG_INTEGER) {\n // TODO\n } else if(rhs_tag == FRACTION) {\n } else if(rhs_tag == REAL) {\n return rhs + lhs;\n }\n }\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":37,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":34879},"to":{"change":2,"start":34879,"end":35100},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"\nstatic double _number_multiply(struct solver_Algebra *a, double lhs, double rhs) {\n uint64_t lhs_payload;\n int lhs_tag = _decode(lhs, &lhs_payload);\n\n uint64_t rhs_payload;\n int rhs_tag = _decode(rhs, &rhs_payload);\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":38,"ins":{"up_context":[{"change":2,"pos":35101}],"down_context":[{"change":2,"pos":35840}],"flag":"BLOCK","start":805,"end":923,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":35101},"to":{"change":2,"start":35101,"end":35840},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"static uint64_t get_cdr(struct solver_Algebra *a, uint64_t expr) {"},{"Add":" return a->values.data[get_pair_index(expr) + 1];"}],"del_contents":[{"Del":" if(lhs_tag == INTEGER) {\n if(rhs_tag == INTEGER) {\n } else if(rhs_tag == BIG_INTEGER) {\n } else if(rhs_tag == FRACTION) {\n } else if(rhs_tag == REAL) {\n }\n } else if(lhs_tag == BIG_INTEGER) {\n if(rhs_tag == INTEGER) {\n } else if(rhs_tag == BIG_INTEGER) {\n } else if(rhs_tag == FRACTION) {\n } else if(rhs_tag == REAL) {\n }\n } else if(lhs_tag == FRACTION) {\n if(rhs_tag == INTEGER) {\n } else if(rhs_tag == BIG_INTEGER) {\n } else if(rhs_tag == FRACTION) {\n } else if(rhs_tag == REAL) {\n }\n } else if(lhs_tag == REAL) {\n if(rhs_tag == INTEGER) {\n } else if(rhs_tag == BIG_INTEGER) {\n } else if(rhs_tag == FRACTION) {\n } else if(rhs_tag == REAL) {\n return lhs * rhs;\n }\n }\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":41,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":35842},"to":{"change":2,"start":35842,"end":36511},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"\nstatic void _simplify_sum_recursive(struct solver_Algebra *a, uint32_t num_operands, const double *operands, uint32_t *result_num_operands, double ** result_operands) {\n if(num_operands == 2) {\n uint64_t lhs_payload, rhs_payload;\n \n int lhs_tag = _decode(operands[0], &lhs_payload);\n int rhs_tag = _decode(operands[1], &rhs_payload);\n \n if(lhs_tag == SUM && rhs_tag == SUM) {\n _simplify_sum_merge(a,\n (lhs_payload >> 24) & 0x07FFull, a->values.data + (lhs_payload & 0x0FFFull),\n (rhs_payload >> 24) & 0x07FFull, a->values.data + (rhs_payload & 0x0FFFull),\n result_num_operands, result_operands\n );\n return;\n }\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":42,"ins":{"up_context":[{"change":2,"pos":36512}],"down_context":[{"change":2,"pos":37107}],"flag":"BLOCK","start":924,"end":1104,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":36512},"to":{"change":2,"start":36512,"end":37107},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"static uint64_t get_index(struct solver_Algebra *a, uint64_t expr, uint32_t index) {"},{"Add":" assert(index < get_list_count(expr));"},{"Add":" return a->values.data[get_list_index(expr) + index];"}],"del_contents":[{"Del":" if(lhs_tag == SUM) {\n _simplify_sum_merge(a,\n (lhs_payload >> 24) & 0x07FFull, a->values.data + (lhs_payload & 0x0FFFull),\n 1, &operands[1],\n result_num_operands, result_operands\n );\n return;\n }\n\n if(rhs_tag == SUM) {\n _simplify_sum_merge(a,\n 1, &operands[0],\n (rhs_payload >> 24) & 0x07FFull, a->values.data + (rhs_payload & 0x0FFFull),\n result_num_operands, result_operands\n );\n return;\n }\n\n if(_precedence(operands[0]) == PRECEDENCE_NUMBER && _precedence(operands[1]) == PRECEDENCE_NUMBER) {\n }\n\n\n }\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":46,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":37109},"to":{"change":2,"start":37109,"end":37440},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":"\nstatic double _simplify_sum(struct solver_Algebra *a, uint32_t num_operands, const double *operands) {\n if(num_operands == 1) {\n return operands[0];\n }\n\n uint32_t result_num_operands;\n double * result_operands;\n double result;\n\n _simplify_sum_recursive(a, num_operands, operands, &result_num_operands, &result_operands);\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":47,"ins":{"up_context":[{"change":2,"pos":37441}],"down_context":[{"change":2,"pos":37501}],"flag":"BLOCK","start":1105,"end":1253,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":37441},"to":{"change":2,"start":37441,"end":37501},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"#include \"algebra-boolean.inc\""},{"Add":"#include \"algebra-number.inc\""},{"Add":"#include \"algebra-sum.inc\""},{"Add":"#include \"algebra-product.inc\""},{"Add":"#include \"algebra-power.inc\""}],"del_contents":[{"Del":" if(result_num_operands == 0) {\n return integer(0);\n }\n"}]}},{"Replacement":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":53,"ins":{"up_context":[{"change":2,"pos":37502}],"down_context":[{"change":2,"pos":37657}],"flag":"BLOCK","start":1254,"end":1348,"inode":{"change":2,"pos":2508}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":37502},"to":{"change":2,"start":37502,"end":37657},"introduced_by":2}],"inode":{"change":2,"pos":2508}},"ins_contents":[{"Add":"#include \"algebra-show.inc\""},{"Add":"#include \"algebra-to_boolean.inc\""},{"Add":"#include \"algebra-simplify.inc\""}],"del_contents":[{"Del":" if(result_num_operands == 1) {\n result = result_operands[1];\n } else {\n result = solver_Algebra_sum(a, result_num_operands, result_operands);\n }\n"}]}},{"Edit":{"inode":{"change":2,"pos":2508},"path":"solver/src/algebra.c","line":57,"atom":{"EdgeMap":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":37658},"to":{"change":2,"start":37658,"end":38442},"introduced_by":2}],"inode":{"change":2,"pos":2508}}},"contents":[{"Del":" free(result_operands);\n return result;\n}\n\ndouble solver_Algebra_simplify(struct solver_Algebra *a, double expr) {\n uint64_t payload;\n switch(_decode(expr, &payload)) {\n case REAL: return expr;\n case VARIABLE: return expr;\n case UNDEFINED: return expr;\n case INTEGER: return expr;\n case BIG_INTEGER: return expr;\n case FRACTION: return expr; \n case POWER: return _simplify_power(a, a->values.data[(payload & 0x0FFFull) + 0], a->values.data[(payload & 0x0FFFull) + 1]);\n case SUM: return _simplify_sum(a, (payload >> 24) & 0x07FFull, a->values.data + (payload & 0x0FFFull));\n case PRODUCT: return _simplify_product(a, (payload >> 24) & 0x07FFull, a->values.data + (payload & 0x0FFFull));\n case INVALID: return expr;\n }\n}\n\n#endif\n"}]}},{"FileAdd":{"meta":{"basename":"algebra-to_boolean.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"uint64_t solver_Algebra_to_boolean(struct solver_Algebra *a, uint64_t expr) {"},{"Add":" switch(get_tag(expr)) {"},{"Add":" case Tag_Boolean:"},{"Add":" return expr;"},{"Add":" case Tag_Equals:"},{"Add":" return pack_boolean(equals(a, get_car(a, expr), get_cdr(a, expr)));"},{"Add":" default:"},{"Add":" return pack_undefined();"},{"Add":" }"},{"Add":"}"},{"Add":""}]}},{"FileAdd":{"meta":{"basename":"algebra-sum.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"static uint64_t embed_product(struct solver_Algebra *a, uint32_t count, const uint64_t *values);"},{"Add":""},{"Add":"static uint64_t embed_sum(struct solver_Algebra *a, uint32_t count, const uint64_t *values) {"},{"Add":" if(count == 0) return pack_integer(0);"},{"Add":" if(count == 1) return values[0];"},{"Add":" if(count == 2) {"},{"Add":" if(is_number(values[0]) && is_number(values[1])) {"},{"Add":" return number_add(a, values[0], values[1]);"},{"Add":" }"},{"Add":""},{"Add":" // x + x -> 2x"},{"Add":" if(is_variable(values[0]) && values[0] == values[1]) {"},{"Add":" uint64_t product_values[2] = { pack_integer(2), values[0] };"},{"Add":" return embed_product(a, 2, product_values);"},{"Add":" }"},{"Add":""},{"Add":" // 2x + x -> 3x"},{"Add":" // if(is_product(values[0]) && get_count(a, values[0]) == 2 && is_number(get_index(a, values[0], 0)) && is_equal(get_index(a, values[0]"},{"Add":" }"},{"Add":" "},{"Add":" struct EncodedList sum;"},{"Add":" sum.count = count;"},{"Add":" sum.index = embed_values(a, count, values);"},{"Add":" return pack_sum(sum);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_sum(struct solver_Algebra *a, uint32_t count, const uint64_t *values) {"},{"Add":" return embed_sum(a, count, values);"},{"Add":""},{"Add":"}"},{"Add":""}]}},{"FileAdd":{"meta":{"basename":"algebra-simplify.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"#include "},{"Add":""},{"Add":"static uint64_t simplify(struct solver_Algebra *a, uint64_t bits);"},{"Add":""},{"Add":"#define SIMPLIFY(TYPE, FN) static uint64_t TYPE##_simplify(struct solver_Algebra *a, uint64_t bits) FN"},{"Add":"#define SIMPLE(TYPE) SIMPLIFY(TYPE, { return bits; })"},{"Add":"#define SIMPLE_PAIR(TYPE) \\"},{"Add":" SIMPLIFY(TYPE, { \\"},{"Add":" uint64_t values[2]; \\"},{"Add":" values[0] = simplify(a, get_car(a, bits)); \\"},{"Add":" values[1] = simplify(a, get_car(a, bits)); \\"},{"Add":" if(values[0] == get_car(a, bits) && values[1] == get_cdr(a, bits)) { \\"},{"Add":" return bits; \\"},{"Add":" } \\"},{"Add":" uint32_t index = embed_values(a, 2, values); \\"},{"Add":" return pack_##TYPE(index); \\"},{"Add":" })"},{"Add":"#define SIMPLIFY_EMBEDED_LIST(TYPE) \\"},{"Add":" SIMPLIFY(TYPE, { \\"},{"Add":" uint32_t count = get_list_count(bits); \\"},{"Add":" uint32_t index = get_list_index(bits); \\"},{"Add":" uint64_t * values = alias_malloc(NULL, sizeof(*values) * count, alignof(*values)); \\"},{"Add":" bool change = false; \\"},{"Add":" for(uint32_t i = 0; i < count; i++) { \\"},{"Add":" values[i] = simplify(a, a->values.data[index + i]); \\"},{"Add":" if(values[i] != a->values.data[index + i]) { \\"},{"Add":" change = true; \\"},{"Add":" } \\"},{"Add":" } \\"},{"Add":" uint64_t result = change ? embed_##TYPE(a, count, values) : bits; \\"},{"Add":" alias_free(NULL, values, sizeof(*values) * count, alignof(*values)); \\"},{"Add":" return result; \\"},{"Add":" })"},{"Add":""},{"Add":"SIMPLE(real)"},{"Add":"SIMPLE(variable)"},{"Add":"SIMPLE(boolean)"},{"Add":"SIMPLE(undefined)"},{"Add":"SIMPLE(integer)"},{"Add":"SIMPLE(big_integer)"},{"Add":""},{"Add":"SIMPLIFY(fraction, {"},{"Add":" // TODO"},{"Add":" return bits;"},{"Add":"})"},{"Add":""},{"Add":"SIMPLIFY(power, {"},{"Add":" // return embed_power(a, get_car(a, bits), get_cdr(a, bits));"},{"Add":" return bits;"},{"Add":"})"},{"Add":""},{"Add":"SIMPLIFY_EMBEDED_LIST(sum)"},{"Add":"SIMPLIFY_EMBEDED_LIST(product)"},{"Add":""},{"Add":"SIMPLE_PAIR(equals)"},{"Add":"SIMPLE_PAIR(not_equals)"},{"Add":"SIMPLE_PAIR(less_than)"},{"Add":"SIMPLE_PAIR(greater_than)"},{"Add":""},{"Add":"#undef SIMPLIFY_EMBEDED_LIST"},{"Add":"#undef SIMPLE_PAIR"},{"Add":"#undef SIMPLE"},{"Add":"#undef SIMPLIFY"},{"Add":""},{"Add":"static uint64_t simplify(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" switch(get_tag(bits)) {"},{"Add":" case Tag_Real:"},{"Add":" return real_simplify(a, bits);"},{"Add":" case Tag_Variable:"},{"Add":" return variable_simplify(a, bits);"},{"Add":" case Tag_Boolean:"},{"Add":" return boolean_simplify(a, bits);"},{"Add":" case Tag_Undefined:"},{"Add":" return undefined_simplify(a, bits);"},{"Add":" case Tag_Integer:"},{"Add":" return integer_simplify(a, bits);"},{"Add":" case Tag_BigInteger:"},{"Add":" return big_integer_simplify(a, bits);"},{"Add":" case Tag_Fraction:"},{"Add":" return fraction_simplify(a, bits);"},{"Add":" case Tag_Power:"},{"Add":" return power_simplify(a, bits);"},{"Add":" case Tag_Sum:"},{"Add":" return sum_simplify(a, bits);"},{"Add":" case Tag_Product:"},{"Add":" return product_simplify(a, bits);"},{"Add":" case Tag_Equals:"},{"Add":" return equals_simplify(a, bits);"},{"Add":" case Tag_NotEquals:"},{"Add":" return not_equals_simplify(a, bits);"},{"Add":" case Tag_LessThan:"},{"Add":" return less_than_simplify(a, bits);"},{"Add":" case Tag_GreaterThan:"},{"Add":" return greater_than_simplify(a, bits);"},{"Add":" default:"},{"Add":" return pack_undefined();"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_simplify(struct solver_Algebra *a, uint64_t expr) {"},{"Add":" return simplify(a, expr);"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"algebra-show.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"#define PRECEDENCE_NUMBER 1000"},{"Add":"#define PRECEDENCE_SUM 110"},{"Add":"#define PRECEDENCE_PRODUCT 120"},{"Add":"#define PRECEDENCE_POWER 130"},{"Add":""},{"Add":"static int precedence(uint64_t bits) {"},{"Add":" switch(get_tag(bits)) {"},{"Add":" case Tag_Real:"},{"Add":" case Tag_Variable:"},{"Add":" case Tag_Integer:"},{"Add":" case Tag_BigInteger:"},{"Add":" case Tag_Fraction:"},{"Add":" return PRECEDENCE_NUMBER;"},{"Add":" case Tag_Power:"},{"Add":" return PRECEDENCE_POWER;"},{"Add":" case Tag_Sum:"},{"Add":" return PRECEDENCE_SUM;"},{"Add":" case Tag_Product:"},{"Add":" return PRECEDENCE_PRODUCT;"},{"Add":" default:"},{"Add":" return 0;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static void show(struct solver_Algebra *a, uint64_t bits);"},{"Add":""},{"Add":"static void show_real(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" printf(\"%f\", unpack_real(bits));"},{"Add":"}"},{"Add":""},{"Add":"static void show_variable(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" printf(\"%s\", unpack_variable(bits));"},{"Add":"}"},{"Add":""},{"Add":"static void show_boolean(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" bool v = unpack_boolean(bits);"},{"Add":" printf(\"%s\", v ? \"true\" : \"false\");"},{"Add":"}"},{"Add":""},{"Add":"static void show_undefined(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" unpack_undefined(bits);"},{"Add":" printf(\"undefined\");"},{"Add":"}"},{"Add":""},{"Add":"static void show_integer(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" printf(\"%i\", unpack_integer(bits));"},{"Add":"}"},{"Add":""},{"Add":"static void show_big_integer(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" printf(\"%p\", unpack_big_integer(bits));"},{"Add":"}"},{"Add":""},{"Add":"static void show_fraction(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" uint32_t index = unpack_fraction(bits);"},{"Add":" uint64_t numerator = a->values.data[index + 0];"},{"Add":" uint64_t denominator = a->values.data[index + 1];"},{"Add":" show(a, numerator);"},{"Add":" printf(\"/\");"},{"Add":" show(a, denominator);"},{"Add":"}"},{"Add":""},{"Add":"#define SURROUND(C, STMT) \\"},{"Add":" do { \\"},{"Add":" if(C) { \\"},{"Add":" printf(\"(\"); \\"},{"Add":" } \\"},{"Add":" STMT; \\"},{"Add":" if(C) { \\"},{"Add":" printf(\")\"); \\"},{"Add":" } \\"},{"Add":" } while(0)"},{"Add":""},{"Add":"static void show_power(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" uint32_t index = unpack_power(bits);"},{"Add":" uint64_t base = a->values.data[index + 0];"},{"Add":" uint64_t exponent = a->values.data[index + 1];"},{"Add":" bool lhp = precedence(base) < PRECEDENCE_POWER;"},{"Add":" bool rhp = precedence(exponent) < PRECEDENCE_POWER;"},{"Add":""},{"Add":" SURROUND(lhp, show(a, base));"},{"Add":""},{"Add":" printf(\"/\");"},{"Add":""},{"Add":" SURROUND(rhp, show(a, exponent));"},{"Add":"}"},{"Add":""},{"Add":"static void show_sum(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" struct EncodedList sum = unpack_sum(bits);"},{"Add":" for(uint32_t i = 0; i < sum.count; i++) {"},{"Add":" uint64_t operand = a->values.data[sum.index + i];"},{"Add":" if(i > 0) {"},{"Add":" printf(\" + \");"},{"Add":" }"},{"Add":" bool p = precedence(operand) < PRECEDENCE_SUM;"},{"Add":" SURROUND(p, show(a, operand));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static void show_product(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" struct EncodedList product = unpack_product(bits);"},{"Add":" bool scale = product.count == 2 && is_number(a->values.data[product.index + 0]);"},{"Add":" for(uint32_t i = 0; i < product.count; i++) {"},{"Add":" uint64_t operand = a->values.data[product.index + i];"},{"Add":" bool p = precedence(operand) < PRECEDENCE_PRODUCT;"},{"Add":" if(!scale && i > 0) {"},{"Add":" printf(\" * \");"},{"Add":" }"},{"Add":" SURROUND(p, show(a, operand));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"#undef SURROUND"},{"Add":""},{"Add":"static void show_equals(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" uint32_t index = unpack_equals(bits);"},{"Add":" uint64_t lhs = a->values.data[index + 0];"},{"Add":" uint64_t rhs = a->values.data[index + 1];"},{"Add":" show(a, lhs);"},{"Add":" printf(\" == \");"},{"Add":" show(a, rhs);"},{"Add":"}"},{"Add":""},{"Add":"static void show_not_equals(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" uint32_t index = unpack_not_equals(bits);"},{"Add":" uint64_t lhs = a->values.data[index + 0];"},{"Add":" uint64_t rhs = a->values.data[index + 1];"},{"Add":" show(a, lhs);"},{"Add":" printf(\" != \");"},{"Add":" show(a, rhs);"},{"Add":"}"},{"Add":""},{"Add":"static void show_less_than(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" uint32_t index = unpack_less_than(bits);"},{"Add":" uint64_t lhs = a->values.data[index + 0];"},{"Add":" uint64_t rhs = a->values.data[index + 1];"},{"Add":" show(a, lhs);"},{"Add":" printf(\" < \");"},{"Add":" show(a, rhs);"},{"Add":"}"},{"Add":""},{"Add":"static void show_greater_than(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" uint32_t index = unpack_greater_than(bits);"},{"Add":" uint64_t lhs = a->values.data[index + 0];"},{"Add":" uint64_t rhs = a->values.data[index + 1];"},{"Add":" show(a, lhs);"},{"Add":" printf(\" > \");"},{"Add":" show(a, rhs);"},{"Add":"}"},{"Add":""},{"Add":"static void show(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" switch(get_tag(bits)) {"},{"Add":" case Tag_Real:"},{"Add":" show_real(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Variable:"},{"Add":" show_variable(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Boolean:"},{"Add":" show_boolean(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Undefined:"},{"Add":" show_undefined(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Integer:"},{"Add":" show_integer(a, bits);"},{"Add":" break;"},{"Add":" case Tag_BigInteger:"},{"Add":" show_big_integer(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Fraction:"},{"Add":" show_fraction(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Power:"},{"Add":" show_power(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Sum:"},{"Add":" show_sum(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Product:"},{"Add":" show_product(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Equals:"},{"Add":" show_equals(a, bits);"},{"Add":" break;"},{"Add":" case Tag_NotEquals:"},{"Add":" show_not_equals(a, bits);"},{"Add":" break;"},{"Add":" case Tag_LessThan:"},{"Add":" show_less_than(a, bits);"},{"Add":" break;"},{"Add":" case Tag_GreaterThan:"},{"Add":" show_greater_than(a, bits);"},{"Add":" break;"},{"Add":" case Tag_Invalid:"},{"Add":" break;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"void solver_Algebra_show(struct solver_Algebra *a, uint64_t bits) {"},{"Add":" show(a, bits);"},{"Add":" printf(\"\\n\");"},{"Add":"}"},{"Add":""}]}},{"FileAdd":{"meta":{"basename":"algebra-product.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":""},{"Add":"static uint64_t embed_product(struct solver_Algebra *a, uint32_t count, const uint64_t *values) {"},{"Add":" if(count == 0) return pack_integer(0);"},{"Add":" if(count == 1) return values[0];"},{"Add":" if(count == 2) {"},{"Add":" if(is_number(values[0]) && is_number(values[1])) {"},{"Add":" return number_multiply(a, values[0], values[1]);"},{"Add":" }"},{"Add":" }"},{"Add":" "},{"Add":" struct EncodedList product;"},{"Add":" product.count = count;"},{"Add":" product.index = embed_values(a, count, values);"},{"Add":" return pack_product(product);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_product(struct solver_Algebra *a, uint32_t count, const uint64_t *values) {"},{"Add":" return embed_product(a, count, values);"},{"Add":""},{"Add":"}"},{"Add":""}]}},{"FileAdd":{"meta":{"basename":"algebra-power.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"uint64_t solver_Algebra_power(struct solver_Algebra *a, uint64_t base, uint64_t exponent) {"},{"Add":" uint64_t values[2] = {base, exponent};"},{"Add":" uint32_t index = embed_values(a, 2, values);"},{"Add":" return pack_power(index);"},{"Add":"}"},{"Add":""}]}},{"FileAdd":{"meta":{"basename":"algebra-parse.re.y","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"%include{"},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"struct String {"},{"Add":" const char * start;"},{"Add":" const char * end;"},{"Add":"};"},{"Add":""},{"Add":"struct Token {"},{"Add":" int kind;"},{"Add":" int location;"},{"Add":" struct String string;"},{"Add":"};"},{"Add":""},{"Add":"struct Location {"},{"Add":" int file;"},{"Add":" int offset;"},{"Add":" int line;"},{"Add":" int column;"},{"Add":"};"},{"Add":""},{"Add":"struct File {"},{"Add":" const char * name;"},{"Add":" const char * data;"},{"Add":" int data_length;"},{"Add":" int location;"},{"Add":" int num_newlines;"},{"Add":" int * newlines;"},{"Add":" int max_newline_added;"},{"Add":"};"},{"Add":""},{"Add":"struct {"},{"Add":" int last_location;"},{"Add":" int num_files;"},{"Add":" struct File ** files;"},{"Add":"} _ = {"},{"Add":" .last_location = 1,"},{"Add":" .num_files = 0,"},{"Add":" .files = NULL"},{"Add":"};"},{"Add":""},{"Add":"static void File_register_newline(struct File *file, int location) {"},{"Add":" if(location >= file->max_newline_added) {"},{"Add":" file->newlines = realloc(file->newlines, sizeof(*file->newlines) + (file->num_newlines + 1));"},{"Add":" file->newlines[file->num_newlines] + location;"},{"Add":" file->num_newlines++;"},{"Add":" file->max_newline_added = location + 1;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static struct File * File_from_string(const char * name, const char * data) {"},{"Add":" int name_size = strlen(name) + 1;"},{"Add":" int data_size = strlen(data) + 1;"},{"Add":" struct File * file = calloc(1, sizeof(*file) + name_size + data_size);"},{"Add":" file->name = memcpy((char *)(file + 1), name, name_size);"},{"Add":" file->data = memcpy((char *)(file + 1) + name_size, data, data_size);"},{"Add":" file->data_length = data_size;"},{"Add":" file->location = _.last_location;"},{"Add":" _.last_location = file->location + data_size;"},{"Add":" _.files = realloc(_.files, sizeof(*_.files) * (_.num_files + 1));"},{"Add":" _.files[_.num_files] = file;"},{"Add":" _.num_files++;"},{"Add":" File_register_newline(file, 0);"},{"Add":" return file;"},{"Add":"}"},{"Add":""},{"Add":"static struct Location File_get_location(int location) {"},{"Add":" struct Location result;"},{"Add":" for(int f = 0; f < _.num_files; f++) {"},{"Add":" if(location >= _.files[f]->location && location < _.files[f]->location + _.files[f]->data_length) {"},{"Add":" result.file = f;"},{"Add":" result.offset = location - _.files[f]->location;"},{"Add":" int low = 0;"},{"Add":" int high = _.files[f]->num_newlines - 1;"},{"Add":" while(high >= low) {"},{"Add":" result.line = (low + high) >> 1;"},{"Add":" result.column = result.offset - _.files[f]->newlines[result.line];"},{"Add":" if(result.column == 0) {"},{"Add":" break;"},{"Add":" } else if(result.column > 0) {"},{"Add":" low = result.line + 1;"},{"Add":" } else {"},{"Add":" high = result.line - 1;"},{"Add":" }"},{"Add":" }"},{"Add":" result.line++;"},{"Add":" result.column++;"},{"Add":" return result;"},{"Add":" }"},{"Add":" }"},{"Add":" result.file = -1;"},{"Add":" result.offset = -1;"},{"Add":" result.line = -1;"},{"Add":" result.column = -1;"},{"Add":" return result;"},{"Add":"}"},{"Add":""},{"Add":"static int Location_show_file_line_column(FILE * output, struct Location l) {"},{"Add":" if(l.file < 0) {"},{"Add":" return fprintf(output, \"\");"},{"Add":" }"},{"Add":" return fprintf(output, \"%s:%i:%i: \", _.files[l.file]->name, l.line, l.column);"},{"Add":"}"},{"Add":""},{"Add":"static int Location_highlight_at(FILE *output, struct Location l) {"},{"Add":" const char spaces[33] = \" \\00\";"},{"Add":" int count = Location_show_file_line_column(output, l);"},{"Add":" if(l.file < 0) {"},{"Add":" return count;"},{"Add":" }"},{"Add":" int num_spaces = l.column + count - 1;"},{"Add":" const char * start = _.files[l.file]->data + _.files[l.file]->newlines[l.line - 1];"},{"Add":" const char * end = strchr(start, '\\n');"},{"Add":" count += fprintf(output, \"%.*s\", (int)(end == NULL ? strlen(start) : end - start + 1), start);"},{"Add":" while(num_spaces > 32) {"},{"Add":" fprintf(output, spaces);"},{"Add":" num_spaces -= 32;"},{"Add":" count += 32;"},{"Add":" }"},{"Add":" count += fprintf(output, \"%.*s^\", num_spaces, spaces);"},{"Add":" return count;"},{"Add":"}"},{"Add":""},{"Add":"struct Values {"},{"Add":" uint64_t tiny[4];"},{"Add":" alias_Vector(uint64_t) vector;"},{"Add":"};"},{"Add":""},{"Add":"#define VALUES_INIT ((struct Values){ .vector = ALIAS_VECTOR_INIT })"},{"Add":""},{"Add":"void Values_add(struct Values *vs, uint64_t v) {"},{"Add":" if(vs->vector.length > 4) {"},{"Add":" alias_Vector_space_for(&vs->vector, NULL, 1);"},{"Add":" *alias_Vector_push(&vs->vector) = v;"},{"Add":" } else if(vs->vector.length == 4) {"},{"Add":" vs->vector.length = 0;"},{"Add":" alias_Vector_space_for(&vs->vector, NULL, 5);"},{"Add":" *alias_Vector_push(&vs->vector) = vs->tiny[0];"},{"Add":" *alias_Vector_push(&vs->vector) = vs->tiny[1];"},{"Add":" *alias_Vector_push(&vs->vector) = vs->tiny[2];"},{"Add":" *alias_Vector_push(&vs->vector) = vs->tiny[3];"},{"Add":" *alias_Vector_push(&vs->vector) = v;"},{"Add":" } else {"},{"Add":" vs->tiny[vs->vector.length++] = v;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"uint32_t Values_count(struct Values *vs) {"},{"Add":" return vs->vector.length;"},{"Add":"}"},{"Add":""},{"Add":"uint64_t * Values_values(struct Values *vs) {"},{"Add":" if(vs->vector.length > 4) {"},{"Add":" return vs->vector.data;"},{"Add":" } else {"},{"Add":" return vs->tiny;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"void Values_free(struct Values *vs) {"},{"Add":" alias_Vector_free(&vs->vector, NULL);"},{"Add":"}"},{"Add":""},{"Add":"struct ExtraState {"},{"Add":" struct File * file;"},{"Add":" int offset;"},{"Add":" struct solver_Algebra *a;"},{"Add":" struct Values *expressions;"},{"Add":"};"},{"Add":"}"},{"Add":""},{"Add":"%extra_context {struct ExtraState extra}"},{"Add":""},{"Add":"%token INVALID."},{"Add":"%token END."},{"Add":"%token WHITESPACE."},{"Add":"%token_type {struct Token}"},{"Add":""},{"Add":"document ::= expressions(L) nl. { *extra.expressions = L; alias_Vector_clear(&L.vector); }"},{"Add":""},{"Add":"// INSERTED_TERMINATOR is done by lex before (, {, [, ], }, and )"},{"Add":""},{"Add":"// required"},{"Add":"end_of_line_token ::= NEWLINE."},{"Add":"end_of_line_token ::= SEMICOLON."},{"Add":"end_of_line_token ::= INSERTED_TERMINATOR."},{"Add":""},{"Add":"end_of_line ::= end_of_line end_of_line_token."},{"Add":"end_of_line ::= end_of_line_token."},{"Add":""},{"Add":"// optional"},{"Add":"nl ::= end_of_line."},{"Add":"nl ::= ."},{"Add":""},{"Add":"left_parens ::= INSERTED_TERMINATOR LEFT_PARENTHESIS."},{"Add":"right_parens ::= INSERTED_TERMINATOR RIGHT_PARENTHESIS."},{"Add":""},{"Add":"%type expressions { struct Values }"},{"Add":"%destructor expressions { (void)extra; Values_free(&$$); }"},{"Add":"expressions(O) ::= expressions(L) end_of_line expression(E). { O = L; Values_add(&O, E); }"},{"Add":"expressions(O) ::= expression(S). { O = VALUES_INIT; Values_add(&O, S); }"},{"Add":""},{"Add":"%type real { uint64_t }"},{"Add":"real(O) ::= REAL(R). { O = solver_Algebra_real(extra.a, atof(R.string.start)); }"},{"Add":""},{"Add":"%type variable { uint64_t }"},{"Add":"variable(O) ::= IDENTIFIER(I). { O = solver_Algebra_variable(extra.a, alias_str_format(NULL, \"%.*s\", I.string.end - I.string.start, I.string.start)); }"},{"Add":""},{"Add":"%type boolean { uint64_t }"},{"Add":"boolean(O) ::= KEYWORD_FALSE. { O = solver_Algebra_boolean(extra.a, false); }"},{"Add":"boolean(O) ::= KEYWORD_TRUE. { O = solver_Algebra_boolean(extra.a, true); }"},{"Add":""},{"Add":"%type undefined { uint64_t }"},{"Add":"undefined(O) ::= KEYWORD_UNDEFINED. { O = solver_Algebra_undefined(extra.a); }"},{"Add":""},{"Add":"%type integer { uint64_t }"},{"Add":"integer(O) ::= INTEGER(I). { O = solver_Algebra_integer(extra.a, atoi(I.string.start)); }"},{"Add":"//integer(O) ::= big_integer"},{"Add":""},{"Add":"%type fraction { uint64_t }"},{"Add":"fraction(O) ::= integer(N) SOLIDUS integer(D). { O = solver_Algebra_fraction(extra.a, N, D); }"},{"Add":""},{"Add":"%type primary { uint64_t }"},{"Add":"primary(O) ::= left_parens expression(E) right_parens. { O = E; }"},{"Add":"primary(O) ::= real(R). { O = R; }"},{"Add":"primary(O) ::= variable(V). { O = V; }"},{"Add":"primary(O) ::= boolean(B). { O = B; }"},{"Add":"primary(O) ::= undefined(U). { O = U; }"},{"Add":"primary(O) ::= integer(I). { O = I; }"},{"Add":"primary(O) ::= fraction(F). { O = F; }"},{"Add":""},{"Add":"%type power { uint64_t }"},{"Add":"power(O) ::= primary(E). { O = E; }"},{"Add":"power(O) ::= power(B) CIRCUMFLEX_ACCENT primary(E). { O = solver_Algebra_power(extra.a, B, E); }"},{"Add":""},{"Add":"%type sum { uint64_t }"},{"Add":"sum(O) ::= sum_list(L). { O = solver_Algebra_sum(extra.a, Values_count(&L), Values_values(&L)); }"},{"Add":""},{"Add":"%type sum_list { struct Values }"},{"Add":"%destructor sum_list { Values_free(&$$); }"},{"Add":"sum_list(O) ::= product(P). { O = VALUES_INIT; Values_add(&O, P); }"},{"Add":"sum_list(O) ::= sum_list(L) PLUS_SIGN product(R). { O = L; Values_add(&O, R); }"},{"Add":"sum_list(O) ::= sum_list(A) HYPHEN_MINUS product(B). { O = A; Values_add(&O, solver_Algebra_negate(extra.a, B)); }"},{"Add":""},{"Add":"%type product { uint64_t }"},{"Add":"product(O) ::= product_list(L). { O = solver_Algebra_product(extra.a, Values_count(&L), Values_values(&L)); }"},{"Add":""},{"Add":"%type product_list { struct Values }"},{"Add":"%destructor product_list { Values_free(&$$); }"},{"Add":"product_list(O) ::= power(P). { O = VALUES_INIT; Values_add(&O, P); }"},{"Add":"product_list(O) ::= product_list(L) ASTERISK power(R). { O = L; Values_add(&O, R); }"},{"Add":""},{"Add":"%type equals { uint64_t }"},{"Add":"equals(O) ::= sum(L) EQUALS_SIGN sum(R). { O = solver_Algebra_equals(extra.a, L, R); }"},{"Add":""},{"Add":"%type not_equals { uint64_t }"},{"Add":"not_equals(O) ::= sum(L) NOT_EQUAL_TO sum(R). { O = solver_Algebra_not_equals(extra.a, L, R); }"},{"Add":""},{"Add":"%type less_than { uint64_t }"},{"Add":"less_than(O) ::= sum(L) LESS_THAN_SIGN sum(R). { O = solver_Algebra_less_than(extra.a, L, R); }"},{"Add":""},{"Add":"%type greater_than { uint64_t }"},{"Add":"greater_than(O) ::= sum(L) GREATER_THAN_SIGN sum(R). { O = solver_Algebra_greater_than(extra.a, L, R); }"},{"Add":""},{"Add":"%type expression { uint64_t }"},{"Add":"expression(O) ::= sum(S). { O = S; }"},{"Add":"expression(O) ::= equals(E). { O = E; }"},{"Add":"expression(O) ::= not_equals(N). { O = N; }"},{"Add":"expression(O) ::= less_than(L). { O = L; }"},{"Add":"expression(O) ::= greater_than(G). { O = G; }"},{"Add":""},{"Add":"%syntax_error {"},{"Add":"// struct Location l = File_get_location(TOKEN.location);"},{"Add":"// "},{"Add":"// Location_show_file_line_column(stderr, l);"},{"Add":"// fprintf(stderr, \"syntax error\\n\");"},{"Add":"//"},{"Add":"// Location_highlight_at(stderr, l);"},{"Add":"// fprintf(stderr, \"\\n\");"},{"Add":"}"},{"Add":""},{"Add":"%parse_accept {"},{"Add":"// printf(\"parsing accepted!\\n\");"},{"Add":"}"},{"Add":""},{"Add":"%parse_failure {"},{"Add":"// fprintf(stderr, \"parsing failure!\\n\");"},{"Add":"}"},{"Add":""},{"Add":"%code{"},{"Add":"static void Parser_init(struct yyParser * parser, struct File * file, struct Values * values) {"},{"Add":" struct ExtraState extra;"},{"Add":" alias_memory_clear(&extra, sizeof(extra));"},{"Add":" extra.file = file;"},{"Add":" extra.expressions = values;"},{"Add":" ParseInit(parser, extra);"},{"Add":"}"},{"Add":""},{"Add":"static struct Token Parser_next_token(struct yyParser * parser) {"},{"Add":" struct ExtraState * extra = &parser->extra;"},{"Add":""},{"Add":" const char *YYCURSOR = extra->file->data + extra->offset;"},{"Add":" const char *YYMARKER;"},{"Add":""},{"Add":" #define RETURN(KIND) \\"},{"Add":" do { \\"},{"Add":" struct Token _result; \\"},{"Add":" _result.kind = KIND; \\"},{"Add":" _result.location = extra->file->location + extra->offset; \\"},{"Add":" _result.string.start = extra->file->data + extra->offset; \\"},{"Add":" _result.string.end = YYCURSOR - 1; \\"},{"Add":" extra->offset = YYCURSOR - extra->file->data; \\"},{"Add":" return _result; \\"},{"Add":" } while(0)"},{"Add":" "},{"Add":" /*!re2c"},{"Add":" "},{"Add":" re2c:yyfill:enable = 0;"},{"Add":" re2c:define:YYCTYPE = char;"},{"Add":""},{"Add":" end = \"\\x00\";"},{"Add":" * { RETURN(INVALID); }"},{"Add":" end { RETURN(END); }"},{"Add":""},{"Add":" ws = [ \\t]+;"},{"Add":" nl = [\\n\\r]+;"},{"Add":""},{"Add":" line_comment = \"#\" [^\\n]* nl;"},{"Add":""},{"Add":" newline = ws? ((nl | line_comment) ws?)+;"},{"Add":" newline {"},{"Add":" for(int location = extra->offset; extra->file->data + location < YYCURSOR; location++) {"},{"Add":" if(extra->file->data[location] == '\\n') {"},{"Add":" File_register_newline(extra->file, location);"},{"Add":" }"},{"Add":" }"},{"Add":" RETURN(NEWLINE);"},{"Add":" }"},{"Add":""},{"Add":" whitespace = ws;"},{"Add":" whitespace { RETURN(WHITESPACE); }"},{"Add":""},{"Add":" oct_number = [0] [0-7]*;"},{"Add":" dec_number = [1-9] [0-9]*;"},{"Add":" hex_number = \"0x\" [0-9a-fA-F]+;"},{"Add":""},{"Add":" oct_number { RETURN(INTEGER); }"},{"Add":" dec_number { RETURN(INTEGER); }"},{"Add":" hex_number { RETURN(INTEGER); }"},{"Add":""},{"Add":" decimal = [0-9]* \".\" [0-9]+ | [0-9]+ \".\";"},{"Add":" decimal { RETURN(REAL); }"},{"Add":""},{"Add":" //\"and\" { RETURN(KEYWORD_AND); }"},{"Add":" //\"or\" { RETURN(KEYWORD_OR); }"},{"Add":" \"true\" { RETURN(KEYWORD_TRUE); }"},{"Add":" \"false\" { RETURN(KEYWORD_FALSE); }"},{"Add":""},{"Add":" identifier = [a-zA-Z_][a-zA-Z_0-9]*;"},{"Add":" full_identifier = identifier (\".\" identifier)*;"},{"Add":" full_identifier { RETURN(IDENTIFIER); }"},{"Add":""},{"Add":" \"(\" { RETURN(LEFT_PARENTHESIS); }"},{"Add":" \")\" { RETURN(RIGHT_PARENTHESIS); }"},{"Add":" \"<\" { RETURN(LESS_THAN_SIGN); }"},{"Add":" \">\" { RETURN(GREATER_THAN_SIGN); }"},{"Add":" \"=\" { RETURN(EQUALS_SIGN); }"},{"Add":" \"+\" { RETURN(PLUS_SIGN); }"},{"Add":" \"-\" { RETURN(HYPHEN_MINUS); }"},{"Add":" \"*\" { RETURN(ASTERISK); }"},{"Add":" \"/\" { RETURN(SOLIDUS); }"},{"Add":" \"!=\" { RETURN(NOT_EQUAL_TO); }"},{"Add":""},{"Add":" */"},{"Add":"}"},{"Add":""},{"Add":"static bool Parser_next(struct yyParser * parser) {"},{"Add":" struct Token t = Parser_next_token(parser);"},{"Add":""},{"Add":" if(t.kind == END) {"},{"Add":" Parse(parser, 0, t);"},{"Add":" return false;"},{"Add":" }"},{"Add":""},{"Add":" if(t.kind == INVALID) {"},{"Add":" fprintf(stderr, \"invalid token encountered at %8s\\n\", t.string.start);"},{"Add":" return false;"},{"Add":" }"},{"Add":""},{"Add":" if(t.kind == LEFT_PARENTHESIS || t.kind == RIGHT_PARENTHESIS) {"},{"Add":" Parse(parser, INSERTED_TERMINATOR, t);"},{"Add":" }"},{"Add":""},{"Add":" if(t.kind != WHITESPACE) {"},{"Add":" Parse(parser, t.kind, t);"},{"Add":" }"},{"Add":""},{"Add":" return true;"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_parse(struct solver_Algebra *a, const char * string) {"},{"Add":" struct File * test_file = File_from_string(\"input\", string);"},{"Add":""},{"Add":" struct yyParser p; "},{"Add":""},{"Add":" struct Values expressions = VALUES_INIT;"},{"Add":""},{"Add":" Parser_init(&p, test_file, &expressions);"},{"Add":" while(Parser_next(&p)) ;"},{"Add":""},{"Add":" assert(Values_count(&expressions) > 0);"},{"Add":" uint64_t result = Values_values(&expressions)[Values_count(&expressions) - 1];"},{"Add":""},{"Add":" Values_free(&expressions);"},{"Add":""},{"Add":" return result;"},{"Add":"}"},{"Add":""},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"algebra-number.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"#include "},{"Add":""},{"Add":"static bool is_number(uint64_t bits) {"},{"Add":" return is_integer(bits) || is_big_integer(bits) || is_fraction(bits) || is_real(bits);"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t integer_integer_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" return pack_integer(unpack_integer(lhs) + unpack_integer(rhs));"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t integer_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" assert(is_number(rhs));"},{"Add":" switch(get_tag(rhs)) {"},{"Add":" case Tag_Integer:"},{"Add":" return integer_integer_add(a, lhs, rhs);"},{"Add":" default:"},{"Add":" return pack_undefined();"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t number_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" assert(is_number(lhs));"},{"Add":" assert(is_number(rhs));"},{"Add":" switch(get_tag(lhs)) {"},{"Add":" case Tag_Integer:"},{"Add":" return integer_add(a, lhs, rhs);"},{"Add":" default:"},{"Add":" return pack_undefined();"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t integer_integer_multiply(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" // TODO big integer upgrade"},{"Add":" return pack_integer(unpack_integer(lhs) * unpack_integer(rhs));"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t integer_multiply(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" assert(is_number(rhs));"},{"Add":" switch(get_tag(rhs)) {"},{"Add":" case Tag_Integer:"},{"Add":" return integer_integer_multiply(a, lhs, rhs);"},{"Add":" default:"},{"Add":" return pack_undefined();"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t number_multiply(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" assert(is_number(lhs));"},{"Add":" assert(is_number(rhs));"},{"Add":" switch(get_tag(lhs)) {"},{"Add":" case Tag_Integer:"},{"Add":" return integer_multiply(a, lhs, rhs);"},{"Add":" default:"},{"Add":" return pack_undefined();"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t embed_fraction(struct solver_Algebra *a, uint64_t numerator, uint64_t denominator) {"},{"Add":" uint64_t values[2] = {numerator, denominator};"},{"Add":" uint32_t index = embed_values(a, 2, values);"},{"Add":" return pack_fraction(index);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_real(struct solver_Algebra *a, double value) {"},{"Add":" if(value == floor(value)) {"},{"Add":" return solver_Algebra_integer(a, (int64_t)value);"},{"Add":" }"},{"Add":" return pack_real(value);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_integer(struct solver_Algebra *a, int64_t value) {"},{"Add":" return pack_integer(value);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_fraction(struct solver_Algebra *a, uint64_t numerator, uint64_t denominator) {"},{"Add":" return embed_fraction(a, numerator, denominator);"},{"Add":"}"},{"Add":""}]}},{"FileAdd":{"meta":{"basename":"algebra-encoding.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"// 0x7 f f 8 | 7 "},{"Add":"// <01111111 1111 12-bit nan header> <1-bit silent flag, 0 on most cpus> <3-bit tag> <48-bit payload>"},{"Add":"// 000 - variable - pointer to variable name"},{"Add":"// 001 - atom"},{"Add":"// 010 - integer - 32-bit integer"},{"Add":"// 011 - integer - pointer to big integer implementation"},{"Add":"// 100 - pair - <3-bit type> <21-bit unused> <24-bit index to first>"},{"Add":"// 000 - fraction"},{"Add":"// 001 - power"},{"Add":"// 010 - unused"},{"Add":"// 011 - unused"},{"Add":"// 100 - equals"},{"Add":"// 101 - not equals"},{"Add":"// 110 - less than"},{"Add":"// 111 - greater than"},{"Add":"// 101 - list - <1-bit type> <23-bit count> <24-bit index to first>"},{"Add":"// 0 - sum"},{"Add":"// 1 - product"},{"Add":"// 110 - unused"},{"Add":"// 111 - unused"},{"Add":""},{"Add":"#define NAN_MASK 0xFFF0000000000000ull"},{"Add":"#define NAN_BITS 0x7FF0000000000000ull"},{"Add":"#define QUEIT_BITS 0x7FF0000000000000ull"},{"Add":"#define SIGNALING_BITS 0x7FF8000000000000ull"},{"Add":"#define TAG_MASK 0xFFF7000000000000ull"},{"Add":"#define TAG_VARIABLE_BITS 0x7FF0000000000000ull"},{"Add":"#define TAG_ATOM_BITS 0x7FF1000000000000ull"},{"Add":"#define TAG_INTEGER_BITS 0x7FF2000000000000ull"},{"Add":"#define TAG_BIGINT_BITS 0x7FF3000000000000ull"},{"Add":"#define TAG_PAIR_BITS 0x7FF4000000000000ull"},{"Add":"#define TAG_LIST_BITS 0x7FF5000000000000ull"},{"Add":"#define TAG_UNUSED1_BITS 0x7FF6000000000000ull"},{"Add":"#define TAG_UNUSED2_BITS 0x7FF7000000000000ull"},{"Add":"#define PAIR_MASK 0xFFF7e00000000000ull"},{"Add":"#define PAIR_FRACTION_BITS 0x7FF4000000000000ull"},{"Add":"#define PAIR_POWER_BITS 0x7FF4200000000000ull"},{"Add":"#define PAIR_UNUSED1_BITS 0x7FF4400000000000ull"},{"Add":"#define PAIR_UNUSED2_BITS 0x7FF4600000000000ull"},{"Add":"#define PAIR_EQUAL_BITS 0x7FF4800000000000ull"},{"Add":"#define PAIR_NOT_EQUAL_BITS 0x7FF4a00000000000ull"},{"Add":"#define PAIR_LESS_THAN_BITS 0x7FF4c00000000000ull"},{"Add":"#define PAIR_GREATER_THAN_BITS 0x7FF4e00000000000ull"},{"Add":"#define LIST_MASK 0xFFF7800000000000ull"},{"Add":"#define LIST_SUM_BITS 0x7FF5000000000000ull"},{"Add":"#define LIST_PRODUCT_BITS 0x7FF5800000000000ull"},{"Add":"#define PAYLOAD_MASK 0x0000FFFFFFFFFFFFull"},{"Add":"#define PAIR_INDEX_MASK 0x0000000000FFFFFFull"},{"Add":"#define LIST_COUNT_MASK 0x00007FFFFF000000ull"},{"Add":"#define LIST_INDEX_MASK 0x0000000000FFFFFFull"},{"Add":""},{"Add":"static uint64_t get_pair_index(uint64_t expr) {"},{"Add":" assert((expr & TAG_MASK) == TAG_PAIR_BITS);"},{"Add":" return expr & LIST_INDEX_MASK;"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t get_list_count(uint64_t expr) {"},{"Add":" assert((expr & TAG_MASK) == TAG_LIST_BITS);"},{"Add":" return (expr & LIST_COUNT_MASK) >> 24;"},{"Add":"}"},{"Add":""},{"Add":"static uint64_t get_list_index(uint64_t expr) {"},{"Add":" assert((expr & TAG_MASK) == TAG_LIST_BITS);"},{"Add":" return expr & LIST_INDEX_MASK;"},{"Add":"}"},{"Add":""},{"Add":"// --------------------------------------------------------------------------------------------------------------------"},{"Add":"#define DEFINE_ENCODING(TYPE, CTYPE, IS_FN, PACK_FN, UNPACK_FN) \\"},{"Add":" static inline bool is_##TYPE(uint64_t packed) IS_FN \\"},{"Add":" static inline uint64_t pack_##TYPE(CTYPE unpacked) PACK_FN \\"},{"Add":" static inline CTYPE unpack_##TYPE(uint64_t packed) { assert(is_##TYPE(packed)); UNPACK_FN }"},{"Add":""},{"Add":"union DoubleBits {"},{"Add":" uint64_t u;"},{"Add":" double d;"},{"Add":"};"},{"Add":""},{"Add":"DEFINE_ENCODING("},{"Add":" real, double,"},{"Add":" { return (packed & NAN_MASK) != NAN_BITS; },"},{"Add":" { "},{"Add":" union DoubleBits _;"},{"Add":" _.d = unpacked;"},{"Add":" return _.u;"},{"Add":" },"},{"Add":" {"},{"Add":" union DoubleBits _;"},{"Add":" _.u = packed;"},{"Add":" return _.d;"},{"Add":" }"},{"Add":")"},{"Add":""},{"Add":"DEFINE_ENCODING("},{"Add":" variable, const char *,"},{"Add":" { return (packed & TAG_MASK) == TAG_VARIABLE_BITS; },"},{"Add":" { return TAG_VARIABLE_BITS | ((uint64_t)unpacked & PAYLOAD_MASK); },"},{"Add":" { return (const char *)(packed & PAYLOAD_MASK); }"},{"Add":")"},{"Add":""},{"Add":""},{"Add":"DEFINE_ENCODING("},{"Add":" boolean, bool,"},{"Add":" { return (packed & TAG_MASK) == TAG_ATOM_BITS && (packed & (PAYLOAD_MASK ^ 1)) == 0; },"},{"Add":" { return TAG_ATOM_BITS | !!unpacked; },"},{"Add":" { return packed ^ 1; }"},{"Add":")"},{"Add":""},{"Add":"static inline bool is_undefined(uint64_t packed) { return packed == (TAG_ATOM_BITS | 2); }"},{"Add":"static inline uint64_t pack_undefined() { return TAG_ATOM_BITS | 2; }"},{"Add":"static inline void unpack_undefined(uint64_t packed) { assert(is_undefined(packed)); }"},{"Add":""},{"Add":"union Int32x2 {"},{"Add":" int32_t i[2];"},{"Add":" uint64_t u;"},{"Add":"};"},{"Add":""},{"Add":"DEFINE_ENCODING("},{"Add":" integer, int32_t,"},{"Add":" { return (packed & TAG_MASK) == TAG_INTEGER_BITS; },"},{"Add":" {"},{"Add":" union Int32x2 _;"},{"Add":" _.i[0] = unpacked;"},{"Add":" _.i[1] = unpacked;"},{"Add":" return TAG_INTEGER_BITS | (_.u & PAYLOAD_MASK);"},{"Add":" },"},{"Add":" {"},{"Add":" union Int32x2 _;"},{"Add":" _.u = packed & PAYLOAD_MASK;"},{"Add":" return _.i[0] | _.i[1];"},{"Add":" }"},{"Add":")"},{"Add":""},{"Add":"struct BigInteger {"},{"Add":" int64_t big;"},{"Add":"};"},{"Add":""},{"Add":"DEFINE_ENCODING("},{"Add":" big_integer, struct BigInteger *,"},{"Add":" { return (packed & TAG_MASK) == TAG_BIGINT_BITS; },"},{"Add":" { return TAG_BIGINT_BITS | ((uint64_t)unpacked & PAYLOAD_MASK); },"},{"Add":" { return (struct BigInteger *)(packed & PAYLOAD_MASK); }"},{"Add":")"},{"Add":""},{"Add":"#define DEFINE_PAIR_ENCODING(TYPE, BITS) \\"},{"Add":" DEFINE_ENCODING( \\"},{"Add":" TYPE, uint32_t, \\"},{"Add":" { return (packed & PAIR_MASK) == BITS; }, \\"},{"Add":" { return BITS | (unpacked & PAIR_INDEX_MASK); }, \\"},{"Add":" { return packed & PAIR_INDEX_MASK; } \\"},{"Add":" )"},{"Add":""},{"Add":"DEFINE_PAIR_ENCODING(fraction, PAIR_FRACTION_BITS)"},{"Add":"DEFINE_PAIR_ENCODING(power, PAIR_POWER_BITS)"},{"Add":""},{"Add":"struct EncodedList {"},{"Add":" uint32_t count;"},{"Add":" uint32_t index;"},{"Add":"};"},{"Add":""},{"Add":"#define DEFINE_LIST_ENCODING(TYPE, BITS) \\"},{"Add":" DEFINE_ENCODING( \\"},{"Add":" TYPE, struct EncodedList, \\"},{"Add":" { return (packed & LIST_MASK) == BITS; }, \\"},{"Add":" { return BITS | (unpacked.count << 24) | unpacked.index; }, \\"},{"Add":" { struct EncodedList _; _.count = (packed & LIST_COUNT_MASK) >> 24; _.index = (packed & LIST_INDEX_MASK); return _; } \\"},{"Add":" )"},{"Add":""},{"Add":"DEFINE_LIST_ENCODING(sum, LIST_SUM_BITS)"},{"Add":"DEFINE_LIST_ENCODING(product, LIST_PRODUCT_BITS)"},{"Add":""},{"Add":"DEFINE_PAIR_ENCODING(equals, PAIR_EQUAL_BITS)"},{"Add":"DEFINE_PAIR_ENCODING(not_equals, PAIR_NOT_EQUAL_BITS)"},{"Add":"DEFINE_PAIR_ENCODING(less_than, PAIR_LESS_THAN_BITS)"},{"Add":"DEFINE_PAIR_ENCODING(greater_than, PAIR_GREATER_THAN_BITS)"},{"Add":""},{"Add":"enum Tag {"},{"Add":" Tag_Real,"},{"Add":" Tag_Variable,"},{"Add":" Tag_Boolean, // atom 0 and 1"},{"Add":" Tag_Undefined, // atom 2"},{"Add":" Tag_Integer,"},{"Add":" Tag_BigInteger,"},{"Add":" Tag_Fraction,"},{"Add":" Tag_Power,"},{"Add":" Tag_Sum,"},{"Add":" Tag_Product,"},{"Add":" Tag_Equals,"},{"Add":" Tag_NotEquals,"},{"Add":" Tag_LessThan,"},{"Add":" Tag_GreaterThan,"},{"Add":" Tag_Invalid"},{"Add":"};"},{"Add":""},{"Add":"static enum Tag get_tag(uint64_t bits) {"},{"Add":" if(is_real(bits)) {"},{"Add":" return Tag_Real;"},{"Add":" } else if(is_variable(bits)) {"},{"Add":" return Tag_Variable;"},{"Add":" } else if(is_boolean(bits)) {"},{"Add":" return Tag_Boolean;"},{"Add":" } else if(is_undefined(bits)) {"},{"Add":" return Tag_Undefined;"},{"Add":" } else if(is_integer(bits)) {"},{"Add":" return Tag_Integer;"},{"Add":" } else if(is_big_integer(bits)) {"},{"Add":" return Tag_BigInteger;"},{"Add":" } else if(is_fraction(bits)) {"},{"Add":" return Tag_Fraction;"},{"Add":" } else if(is_power(bits)) {"},{"Add":" return Tag_Power;"},{"Add":" } else if(is_equals(bits)) {"},{"Add":" return Tag_Equals;"},{"Add":" } else if(is_not_equals(bits)) {"},{"Add":" return Tag_NotEquals;"},{"Add":" } else if(is_less_than(bits)) {"},{"Add":" return Tag_LessThan;"},{"Add":" } else if(is_greater_than(bits)) {"},{"Add":" return Tag_GreaterThan;"},{"Add":" } else if(is_sum(bits)) {"},{"Add":" return Tag_Sum;"},{"Add":" } else if(is_product(bits)) {"},{"Add":" return Tag_Product;"},{"Add":" } else {"},{"Add":" return Tag_Invalid;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"#undef DEFINE_LIST_ENCODING"},{"Add":"#undef DEFINE_PAIR_ENCODING"},{"Add":"#undef DEFINE_ENCODING"}]}},{"FileAdd":{"meta":{"basename":"algebra-boolean.inc","metadata":0},"context":[{"change":2,"pos":2472}],"contents":[{"Add":"static uint64_t boolean_not(struct solver_Algebra *a, uint64_t expr_) {"},{"Add":" if(expr_ == (TAG_ATOM_BITS | 0)) return TAG_ATOM_BITS | 1;"},{"Add":" if(expr_ == (TAG_ATOM_BITS | 1)) return TAG_ATOM_BITS | 0;"},{"Add":" return TAG_ATOM_BITS | 2;"},{"Add":"}"},{"Add":""},{"Add":"static bool equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs);"},{"Add":""},{"Add":"#define BINARY_EQUALS(TYPE, TAG, FN) \\"},{"Add":"static bool TYPE##_##TYPE##_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) FN \\"},{"Add":"static bool TYPE##_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) { \\"},{"Add":" switch(get_tag(rhs)) { \\"},{"Add":" case TAG: \\"},{"Add":" return TYPE##_##TYPE##_equals(a, lhs, rhs); \\"},{"Add":" default: \\"},{"Add":" return pack_undefined(); \\"},{"Add":" } \\"},{"Add":"}"},{"Add":""},{"Add":"#define BINARY_PAIR_EQUALS(TYPE, TAG) \\"},{"Add":" BINARY_EQUALS(TYPE, TAG, { \\"},{"Add":" return equals(a, get_car(a, lhs), get_car(a, rhs)) && \\"},{"Add":" equals(a, get_cdr(a, lhs), get_cdr(a, rhs)) ; \\"},{"Add":" })"},{"Add":""},{"Add":""},{"Add":"#define BINARY_LIST_EQUALS(TYPE, TAG) \\"},{"Add":" BINARY_EQUALS(TYPE, TAG, { \\"},{"Add":" uint32_t count = get_count(a, lhs); \\"},{"Add":" if(count != get_count(a, rhs)) { \\"},{"Add":" return false; \\"},{"Add":" } \\"},{"Add":" for(uint32_t i = 0; i < count; i++) { \\"},{"Add":" if(!equals(a, get_index(a, lhs, i), get_index(a, rhs, i))) { \\"},{"Add":" return false; \\"},{"Add":" } \\"},{"Add":" } \\"},{"Add":" return true; \\"},{"Add":" })"},{"Add":""},{"Add":"BINARY_EQUALS(real, Tag_Real, { return unpack_real(lhs) == unpack_real(rhs); })"},{"Add":""},{"Add":"#if 0"},{"Add":""},{"Add":"BINARY_EQUALS(variable, Tag_Variable, { return unpack_variable(lhs) == unpack_variable(rhs); })"},{"Add":"BINARY_EQUALS(boolean, Tag_Boolean, { return unpack_boolean(lhs) == unpack_boolean(rhs); })"},{"Add":"BINARY_EQUALS(undefined, Tag_Undefined, { unpack_undefined(); unpack_undefined(); return true; })"},{"Add":"BINARY_EQUALS(integer, Tag_Integer, { return unpack_integer(lhs) == unpack_integer(rhs); })"},{"Add":"BINARY_EQUALS(big_integer, Tag_BigInteger, {"},{"Add":" // TODO"},{"Add":" return false;"},{"Add":"})"},{"Add":""},{"Add":"BINARY_EQUALS(fraction, Tag_Fraction, {"},{"Add":" // TODO"},{"Add":" return false;"},{"Add":"})"},{"Add":""},{"Add":"BINARY_PAIR_EQUALS(power, Tag_Power)"},{"Add":"BINARY_LIST_EQUALS(sum, Tag_Sum)"},{"Add":"BINARY_LIST_EQUALS(product, Tag_Sum)"},{"Add":"BINARY_PAIR_EQUALS(equals, Tag_Equals)"},{"Add":"BINARY_PAIR_EQUALS(not_equals, Tag_NotEquals)"},{"Add":"BINARY_PAIR_EQUALS(less_than, Tag_LessThan)"},{"Add":"BINARY_PAIR_EQUALS(greater_than, Tag_GreaterThan)"},{"Add":""},{"Add":"#endif"},{"Add":""},{"Add":"static bool equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" if(lhs == rhs) return true;"},{"Add":" switch(get_tag(lhs)) {"},{"Add":" case Tag_Real:"},{"Add":" return real_equals(a, lhs, rhs);"},{"Add":"/* case Tag_Variable:"},{"Add":" return variable_equals(a, lhs, rhs);"},{"Add":" case Tag_Boolean:"},{"Add":" return boolean_equals(a, lhs, rhs);"},{"Add":" case Tag_Undefined:"},{"Add":" return undefined_equals(a, lhs, rhs);"},{"Add":" case Tag_Integer:"},{"Add":" return integer_equals(a, lhs, rhs);"},{"Add":" case Tag_BigInteger:"},{"Add":" return big_integer_equals(a, lhs, rhs);"},{"Add":" case Tag_Fraction:"},{"Add":" return fraction_equals(a, lhs, rhs);"},{"Add":" case Tag_Power:"},{"Add":" return power_equals(a, lhs, rhs);"},{"Add":" case Tag_Sum:"},{"Add":" return sum_equals(a, lhs, rhs);"},{"Add":" case Tag_Product:"},{"Add":" return product_equals(a, lhs, rhs);"},{"Add":" case Tag_Equals:"},{"Add":" return equals_equals(a, lhs, rhs);"},{"Add":" case Tag_NotEquals:"},{"Add":" return not_equals_equals(a, lhs, rhs);"},{"Add":" case Tag_LessThan:"},{"Add":" return less_than_equals(a, lhs, rhs);"},{"Add":" case Tag_GreaterThan:"},{"Add":" return greater_than_equals(a, lhs, rhs);"},{"Add":" case Tag_Invalid:"},{"Add":"*/"},{"Add":" default:"},{"Add":" return pack_undefined();"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_boolean(struct solver_Algebra *a, bool value) {"},{"Add":" return pack_boolean(value);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" uint64_t values[2] = { lhs, rhs };"},{"Add":" uint32_t index = embed_values(a, 2, values);"},{"Add":" return pack_equals(index);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_not_equals(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" uint64_t values[2] = { lhs, rhs };"},{"Add":" uint32_t index = embed_values(a, 2, values);"},{"Add":" return pack_not_equals(index);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_less_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" uint64_t values[2] = { lhs, rhs };"},{"Add":" uint32_t index = embed_values(a, 2, values);"},{"Add":" return pack_less_than(index);"},{"Add":"}"},{"Add":""},{"Add":"uint64_t solver_Algebra_greater_than(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"},{"Add":" uint64_t values[2] = { lhs, rhs };"},{"Add":" uint32_t index = embed_values(a, 2, values);"},{"Add":" return pack_greater_than(index);"},{"Add":"}"},{"Add":""}]}},{"Edit":{"inode":{"change":2,"pos":38518},"path":"solver/include/solver/algebra.h","line":5,"atom":{"NewVertex":{"up_context":[{"change":2,"pos":38597}],"down_context":[{"change":2,"pos":38597}],"flag":"BLOCK","start":38089,"end":38110,"inode":{"change":2,"pos":38518}}},"contents":[{"Add":"#include "}]}},{"Edit":{"inode":{"change":2,"pos":38518},"path":"solver/include/solver/algebra.h","line":17,"atom":{"NewVertex":{"up_context":[{"change":2,"pos":38863}],"down_context":[{"change":2,"pos":38863}],"flag":"BLOCK","start":38111,"end":38172,"inode":{"change":2,"pos":38518}}},"contents":[{"Add":"uint64_t solver_Algebra_undefined(struct solver_Algebra *a);"}]}},{"Replacement":{"inode":{"change":2,"pos":38518},"path":"solver/include/solver/algebra.h","line":19,"ins":{"up_context":[{"change":2,"pos":38937}],"down_context":[{"change":2,"pos":39037}],"flag":"BLOCK","start":38173,"end":38275,"inode":{"change":2,"pos":38518}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":38937},"to":{"change":2,"start":38937,"end":39037},"introduced_by":2}],"inode":{"change":2,"pos":38518}},"ins_contents":[{"Add":"uint64_t solver_Algebra_fraction(struct solver_Algebra *a, uint64_t numerator, uint64_t denominator);"}],"del_contents":[{"Del":"uint64_t solver_Algebra_fraction(struct solver_Algebra *a, int64_t numerator, int64_t denominator);\n"}]}},{"Replacement":{"inode":{"change":2,"pos":38518},"path":"solver/include/solver/algebra.h","line":31,"ins":{"up_context":[{"change":2,"pos":39848}],"down_context":[{"change":2,"pos":39932}],"flag":"BLOCK","start":38276,"end":38374,"inode":{"change":2,"pos":38518}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":39848},"to":{"change":2,"start":39848,"end":39932},"introduced_by":2}],"inode":{"change":2,"pos":38518}},"ins_contents":[{"Add":"static inline uint64_t solver_Algebra_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {"}],"del_contents":[{"Del":"uint64_t solver_Algebra_add(struct solver_Algebra *a, uint64_t lhs, uint64_t rhs) {\n"}]}},{"Edit":{"inode":{"change":2,"pos":38518},"path":"solver/include/solver/algebra.h","line":54,"atom":{"NewVertex":{"up_context":[{"change":2,"pos":40769}],"down_context":[{"change":2,"pos":40769}],"flag":"BLOCK","start":38375,"end":38454,"inode":{"change":2,"pos":38518}}},"contents":[{"Add":"uint64_t solver_Algebra_parse(struct solver_Algebra *a, const char * string);"},{"Add":""}]}},{"Replacement":{"inode":{"change":2,"pos":38518},"path":"solver/include/solver/algebra.h","line":58,"ins":{"up_context":[{"change":2,"pos":40837}],"down_context":[{"change":2,"pos":40910}],"flag":"BLOCK","start":38455,"end":38532,"inode":{"change":2,"pos":38518}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":40837},"to":{"change":2,"start":40837,"end":40910},"introduced_by":2}],"inode":{"change":2,"pos":38518}},"ins_contents":[{"Add":"uint64_t solver_Algebra_to_boolean(struct solver_Algebra *a, uint64_t expr);"}],"del_contents":[{"Del":"bool solver_Algebra_to_boolean(struct solver_Algebra *a, uint64_t expr);\n"}]}},{"Edit":{"inode":{"change":3,"pos":109071895},"path":"configure.sh","line":8,"atom":{"NewVertex":{"up_context":[{"change":3,"pos":326}],"down_context":[{"change":3,"pos":109074912}],"flag":"BLOCK","start":38533,"end":38581,"inode":{"change":3,"pos":109071895}}},"contents":[{"Add":""},{"Add":"rule lemon --command \"lemon -d\\$builddir \\$in\""}]}},{"Edit":{"inode":{"change":3,"pos":109071895},"path":"configure.sh","line":64,"atom":{"NewVertex":{"up_context":[{"change":3,"pos":109076906}],"down_context":[{"change":2,"pos":47535}],"flag":"BLOCK","start":38582,"end":38730,"inode":{"change":3,"pos":109071895}}},"contents":[{"Add":"build \"\\$builddir/algebra-parse.re.c\" lemon solver/src/algebra-parse.re.y"},{"Add":""},{"Add":"build \"\\$builddir/algebra-parse.c\" re2c \"\\$builddir/algebra-parse.re.c\""},{"Add":""}]}},{"Replacement":{"inode":{"change":3,"pos":109071895},"path":"configure.sh","line":71,"ins":{"up_context":[{"change":2,"pos":47609}],"down_context":[{"change":2,"pos":47632}],"flag":"BLOCK","start":38731,"end":38787,"inode":{"change":3,"pos":109071895}},"del":{"edges":[{"previous":"BLOCK","flag":"BLOCK | DELETED","from":{"change":2,"pos":47609},"to":{"change":2,"start":47609,"end":47632},"introduced_by":2}],"inode":{"change":3,"pos":109071895}},"ins_contents":[{"Add":" solver/src/algebra.c \\"},{"Add":" \"\\$builddir/algebra-parse.c\""}],"del_contents":[{"Del":" solver/src/algebra.c\n"}]}}],"owner":"mystical.unicat","repo":"monorepo","token":"hvWcxg0Dm8f1n8fgM1qJW0LWAIWTNCULAmuj19eIxvU=","login":null}

…

Dependencies

Change contents