diff --git a/.gitattributes b/.gitattributes index 6825630198..c063c14595 100644 --- a/.gitattributes +++ b/.gitattributes @@ -18,3 +18,5 @@ research/coordinated-frames-and-entrance-banks/** -text -whitespace # Frozen PR210 package and round-nine evidence retain their audited bytes. research/five-stage-source527-banks/** -text -whitespace research/community-round9-audit/** -text -whitespace + +research/r489-pooled-retimed-complex/** -text diff --git a/.github/workflows/r489-pooled-retimed-complex.yml b/.github/workflows/r489-pooled-retimed-complex.yml new file mode 100644 index 0000000000..34cff259e2 --- /dev/null +++ b/.github/workflows/r489-pooled-retimed-complex.yml @@ -0,0 +1,24 @@ +name: R489 pooled retimed complex +on: + workflow_dispatch: + pull_request: + paths: + - 'research/r489-pooled-retimed-complex/**' + - '.github/workflows/r489-pooled-retimed-complex.yml' +jobs: + verify: + runs-on: ubuntu-latest + timeout-minutes: 60 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.14' + - run: sudo apt-get update && sudo apt-get install -y libboost-dev + - run: python -m pip install numpy==2.3.5 sympy==1.14.0 + - run: python -B research/r489-pooled-retimed-complex/verify.py "$RUNNER_TEMP/r489-retimed-proof" --boost-include /usr/include --cxx g++ + - uses: actions/upload-artifact@v4 + if: always() + with: + name: r489-retimed-proof + path: ${{ runner.temp }}/r489-retimed-proof diff --git a/research/r489-pooled-retimed-complex/EXPECTED.json b/research/r489-pooled-retimed-complex/EXPECTED.json new file mode 100644 index 0000000000..43948fd60a --- /dev/null +++ b/research/r489-pooled-retimed-complex/EXPECTED.json @@ -0,0 +1,143 @@ +{ + "complex_lower": "1345325487149526878087/1000000000000000000000000", + "next_b_rejected": "168165685893690859761/125000000000000000000000", + "bit_lower": "391360506745414227149/250000000000000000000000", + "kappa": "1343518018117309/1000000000000000000", + "kappa_decimal": "0.001343518018117309", + "bit_charged_three_level_coefficient_bits": 6464, + "external_row_allowance": 20161, + "binding_component": "complex", + "strict_outer_constraints": { + "bit_positive": "1345325487149526868992575856839905152764432850162883798594382642865111184103929043593461548579749789321934545152248060885802500101307959888208157061594640680690829891010070337816975637009406902638543011689072391228548734410720296997142426977989919733310440705316844294091418110991919766801783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "9094424143160094847235567149837116201405617357134888815896070956406538451420250210678065454847751939114197499898692040111791842938405359319309170108989929662183024362990593097361456988310927608771451265589279703002857573022010080266689559294683155705908581889008080233198217/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "29904674512850473121913/1000000000000000000000000", + "beta_positive": "1/1000000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "leaf_saving_above_bit": "7749098656010567969148567149837116201405617357134888815896070956406538451420250210678065454847751939114197499898692040111791842938405359319309170108989929662183024362990593097361456988310927608771451265589279703002857573022010080266689559294683155705908581889008080233198217/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "1345325487149526868992575856839905152764432850162883798594382642865111184103929043593461548579749789321934545152248060885802500101307959888208157061594640680690829891010070337816975637009406902638543011689072391228548734410720296997142426977989919733310440705316844294091418110991919766801783/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "5219874815154810853566859431758463253467241528730328206542418121068380409814054148932494276003625758879033295101594080941698421570510639547862742116089605511782342072505366886497704131164870707024268644483712242729977520921725337130487206625331497586264731649820884410690526610991919766801783/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "672662743574763558150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "499327337256425236441849037558729574292610359431758463253467241528730328206542418121068380409814054148932494276003625758879033295101594080941698421570510639547862742116089605511782342072505366886497704131164870707024268644483712242729977520921725337130487206625331497586264731649820884410690526610991919766801783/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000", + "lambda_above_tau": "1345325487149526868992575856839905152764432850162883798594382642865111184103929043593461548579749789321934545152248060885802500101307959888208157061594640680690829891010070337816975637009406902638543011689072391228548734410720296997142426977989919733310440705316844294091418110991919766801783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "10439749630309621716228143006677021354170050207297772614490453599271649635524179254271527003427501728436132045050940100997594343039713319207517327170584570342873854254000663435178432625320334511409994277278352094231406307432730377263831986272673075439219022594324924527289635110991919766801783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "1345325487149526868992575856839905152764432850162883798594382642865111184103929043593461548579749789321934545152248060885802500101307959888208157061594640680690829891010070337816975637009406902638543011689072391228548734410720296997142426977989919733310440705316844294091418110991919766801783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "1345325487149526868992575856839905152764432850162883798594382642865111184103929043593461548579749789321934545152248060885802500101307959888208157061594640680690829891010070337816975637009406902638543011689072391228548734410720296997142426977989919733310440705316844294091418110991919766801783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "5219874815154810853566859431758463253467241528730328206542418121068380409814054148932494276003625758879033295101594080941698421570510639547862742116089605511782342072505366886497704131164870707024268644483712242729977520921725337130487206625331497586264731649820884410690526610991919766801783/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000", + "lambda_prime_below_one": "672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "499999999999999999500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217", + "epsilon_below_one": "672662743574763933150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217", + "guard_width": "672662743574763933150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217", + "K_geometry": "375672662743574763558150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217000000000000000000", + "K_dominates_log": "672662743574763557478299697695662149238678126971111039143117903028135046924823407661947796728363972135886133810428390053460980902031677937334873531083441393835679454421034036080400043584238625284637941340496179473435486681158464294291123561986905599490314296393839544222474975510613175574205038828964643888743610991919766801783/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217000000000000000000", + "record_suffix": "672662743574763933150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217", + "phase_local": "5381301948598110964535036786588642225966162104661868264872427201915837601127896560183284928029984929608426201785048077900227915190873111345445922537508964558796484641793795453604005536046670419800709023186401230303554975295172765184448477109909545686079867919073356440369353426764422300740518761885526276276262610991919766801783/4005381301948598107465207699530163405659117124545932293972262067770157374347660655031452956721487566808540045791970993928967733639187247352466412627435914883617098063071283155905741263419957064908018366950681034343805850844130302058160179832626197302956102346997348019309882146801432924714475787112064641865585736000000000000000000", + "phase_boundary": "1076260389719621792368877162457917698672462467916033087062772985789938122999372535020919550839931482776389568208252934726041003841075229372315820588777057665118034184767270729010994800081018493386015462641573755258874299990931118656304611008951703321197990321194940992463635985618082529159889072233812783807673810991919766801783/801076260389719621493041539906032681131823424909186458794452413554031474869532131006290591344297513361708009158394198785793546727837449470493282525487182976723419612614256631181148252683991412981603673390136206868761170168826060411632035966525239460591220469399469603861976429360286584942895157422412928373117147200000000000000000", + "gamma_sublinear": "1/2000000000000000000", + "cell_above_band": "999999999999999998499327337256425236566849037558729574292610359431758463253467241528730328206542418121068380409814054148932494276003625758879033295101594080941698421570510639547862742116089605511782342072505366886497704131164870707024268644483712242729977520921725337130487206625331497586264731649820884410690526610991919766801783/2002690650974299053732603849765081702829558562272966146986131033885078687173830327515726478360743783404270022895985496964483866819593623676233206313717957441808549031535641577952870631709978532454009183475340517171902925422065151029080089916313098651478051173498674009654941073400716462357237893556032320932792868000000000000000000", + "prime_interval_packing": "672662743574763933150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217", + "alpha_positive": "1345325487149527365629262138966087981628318695212647785675876374297806840382405286593567386914309823203391857806802631174427685800437596995636451960572801845972937338331428524298057971078871738786933810175625472449166842197446221564313602640261568469003107671062341957957743325689728764883678427837044877086960610991919766801783/1001345325487149526866301924882540851414779281136483073493065516942539343586915163757863239180371891702135011447992748482241933409796811838116603156858978720904274515767820788976435315854989266227004591737670258585951462711032575514540044958156549325739025586749337004827470536700358231178618946778016160466396434000000000000000000", + "alpha_below_one": "999999999999999999500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217/1001345325487149526866301924882540851414779281136483073493065516942539343586915163757863239180371891702135011447992748482241933409796811838116603156858978720904274515767820788976435315854989266227004591737670258585951462711032575514540044958156549325739025586749337004827470536700358231178618946778016160466396434000000000000000000", + "alpha_below_one_fourth": "248991005884637854350946219081669124872066501588908120587590502861337029056346385652872242408178663102330361004191384489386055666648765362533514337254171878380095691603623768719810770992668444817964214124241939174038698835560697657070697636898875762965753289016271909248909890849399829029771058266666995239512147889008080233198217/1001345325487149526866301924882540851414779281136483073493065516942539343586915163757863239180371891702135011447992748482241933409796811838116603156858978720904274515767820788976435315854989266227004591737670258585951462711032575514540044958156549325739025586749337004827470536700358231178618946778016160466396434000000000000000000", + "delta_positive": "1/8000000000000000000", + "delta_below_one_eighth": "999999999999999999/8000000000000000000", + "short_record_fallback": "499326432306092049009613163770790158586250205066999959156201532245145540413174402660869205729354123659157891274119095686471982691562749290658561831704897859550540055210546186361883634279201071116081281021628912866181895717918931969782775871823952585339019078052142553492513812355612631277347329410676651264536299848491488456442750348735246869464063041382552712165327920061116549880751267032883306744591781767946035823229030787687058598251181651959990310745308466039793082702735988407121546712217114955015938661332657863045307856229625489693297296432067521222246280248629090322777422327207863568128411979089/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000", + "artificial_boundary": "28043050415588784865223679584472031535572389883691269628900265463865983605020883515665432669152273280105115225106325788984944386285487101543094201134182536826111689239858733328602341881011387702728799909387932174090953694359547804344208632727558441695458886213213608143087595554535468904957012101947054481692614308167024240699594651/4005381301948598107465207699530163405659117124545932293972262067770157374347660655031452956721487566808540045791970993928967733639187247352466412627435914883617098063071283155905741263419957064908018366950681034343805850844130302058160179832626197302956102346997348019309882146801432924714475787112064641865585736000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "515354650572792958117388209198022252311992362764802079842702619069230145949203973667483719062400024099332373318946945162363383973566432691053966529883948968551340145970896265211082189627335070491273181679421194370906073133185850383760596534031461564579687349539118931943393040261461190049243534404810949844361947/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217000000000000000000", + "coordinate_movement_above_kappa": "1807469032217868992575856839905152764432850162883798594382642865111184103929043593461548579749789321934545152248060885802500101307959888208157061594640680690829891010070337816975637009406902638543011689072391228548734410720296997142426977989919733310440705316844294091418110991919766801783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "1468198782921819468423724675675182660460272219656054309616986059796047415574639178855209947221407824826486759495057092124241726866802677199566495145445960809920288808698587072286453169984043737777088581058606507793034177766956262649057405495318690171017455616445042952965777191128207445993406101580286961116373/50067266274357476343315096244127042570738964056824153674653275847126967179345758187893161959018594585106750572399637424112096670489840591905830157842948936045213725788391039448821765792749463311350229586883512929297573135551628775727002247907827466286951279337466850241373526835017911558930947338900808023319821700000000000000000", + "bulk_exposure_above_kappa": "1807469032217868992575856839905152764432850162883798594382642865111184103929043593461548579749789321934545152248060885802500101307959888208157061594640680690829891010070337816975637009406902638543011689072391228548734410720296997142426977989919733310440705316844294091418110991919766801783/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "1619473890864469847773350861377825889958990699277208955008957160197492808626343879945211654548270463539321457931593690093302238264039431933140224346924144946150034878347618149247569227381207398362673974091193908502369928287905364283734659876860319202289934829439608943478467980340793942447400908293447197588904491/4005381301948598107465207699530163405659117124545932293972262067770157374347660655031452956721487566808540045791970993928967733639187247352466412627435914883617098063071283155905741263419957064908018366950681034343805850844130302058160179832626197302956102346997348019309882146801432924714475787112064641865585736000000000000000000", + "scalar_work_above_kappa": "3622164541838768901505954711142907592788549261550175101995088194082571495800174207460938132909014246943591480827579187057786105083633055609373430660642102387958583909883259727200439859091185930816683157566534425674272853709970515312814749793173417853767986002938282953133409053741510404804638801849479518521697359/4005381301948598107465207699530163405659117124545932293972262067770157374347660655031452956721487566808540045791970993928967733639187247352466412627435914883617098063071283155905741263419957064908018366950681034343805850844130302058160179832626197302956102346997348019309882146801432924714475787112064641865585736000000000000000000", + "dimension_above_kappa": "499327337256425236082203688131522532409998568629780715565459604293532408049245037190298526359018027816416213338403649858211406614048539243305082395136943330601829272000038574063122488043401632097579893758499941198297450323904906613636050654107575720891083740656793062165952081188939816354083566872453109816045317404810949844361947/500672662743574763433150962441270425707389640568241536746532758471269671793457581878931619590185945851067505723996374241120966704898405919058301578429489360452137257883910394488217657927494633113502295868835129292975731355516287757270022479078274662869512793374668502413735268350179115589309473389008080233198217000000000000000000" + }, + "outer_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "bootstrap": [ + { + "gap": "1758159582670889716837073442589143979241877340631521741383360094008444560779569/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "11646244853943" + }, + { + "gap": "2365296897043323580235593796713331224359102922711242285417443568347607440533838658287883342632128620436712124456595497/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "6434742563675516635" + }, + { + "gap": "3182094200268073613258330737871604385159398312818584759030361331023465449845962963572866924372637461460991714706389286417141215447817880845731834997007825761/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "3555301505339871712559428" + }, + { + "gap": "4280952430131330271569312938290607170548049457218387702776481869165237563881772088820459930734043025684617181823404503474086934186594826107261530302537502214354109776201343892825140220650015000793/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1964362780451609826625858782139" + }, + { + "gap": "5759274413530382817909766623916775143192486762684579405449795987991774807500876422670017378960082169125093253051222582964109462520055219080673488460271189026964351351536233865146474220170340782765207268471350481041234815890703880677009/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1085342868228752973196028259077591767" + }, + { + "gap": "7748098656010567969148567149837116201405617357134888815896070956406538451420250210678065454847751939114197499898692040111791842938405359319309170108989929662183024362990593097361456988310927608771451265589279703002857573022010080266689559294683155705908581889008080233198217/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "599669853927999715648938728111173559232484" + } + ], + "complex_profile": { + "1": 172056, + "2": 19008, + "3": 42032, + "4": 6048, + "5": 22496, + "6": 6624, + "7": 1800, + "8": 4120 + }, + "complex_live": 7680, + "complex_physical": 8258, + "complex_invoice": { + "physical_stock_bits": 2641, + "router_bits": 7984, + "literal_bits": 35282, + "physical_row_coefficient": 15443, + "retained_row_coefficient": 20161, + "required_C0_bits": 200012, + "halving_integer_inequality": [ + 5329, + 128 + ], + "G_exponent": 30000, + "E_exponent": 100000, + "C0_exponent": 210000 + }, + "bit_profile": { + "1": 105600, + "2": 130560, + "4": 19680, + "6": 14400, + "7": 7680, + "8": 1584, + "48": 2, + "56": 2628 + }, + "bit_finite": { + "live": 9600, + "physical": 9609, + "maxchild": 56, + "rank_mass": 745536, + "hosted_residuals": 43032, + "prefix_bits": 2119, + "charged_prefix_bits": 2176, + "coefficient_bits": 2119, + "three_level_coefficient_bits": 6411, + "charged_three_level_coefficient_bits": 6464, + "row_coefficient": 19431, + "halving_depth": 3 + }, + "bit_emitted_program_sha256": "e37b52e4861c39154b5891460fb45df8651c92cd68961078f8f06596f057c822" +} diff --git a/research/r489-pooled-retimed-complex/LICENSE b/research/r489-pooled-retimed-complex/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/r489-pooled-retimed-complex/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/r489-pooled-retimed-complex/MANIFEST.json b/research/r489-pooled-retimed-complex/MANIFEST.json new file mode 100644 index 0000000000..99cdcbc540 --- /dev/null +++ b/research/r489-pooled-retimed-complex/MANIFEST.json @@ -0,0 +1,311 @@ +{ + "PROOF.md": "a2fd0785fdb5d83366c01be1263ab09675bc76d2a5ff78c7ac6aa2e919592a2d", + "EXPECTED.json": "940505b40dee096d0426ca545e15d98fa93b2e6af1a675e59d0760748a70a659", + "LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "SOURCE.json": "08da45430fbaaf47c82cc2a1a29dc50ced39ef4fc5d00f86e2b24467d8743fdf", + "README.md": "7d71d903d1fe9e9c2428be46911e1455fd8514a5936ce2abf4ceb57ce74b7ba6", + "verify.py": "a55e2a0faa83d9925b3e9073bfea3fc4f39cb9e850325f3060c6ae708c5f468d", + "NOTICE.md": "abeb8984b07b520ae39c5336465f2066c90bf17a6ebe816a8d7f71a517bed362", + "code/apply_retime.py": "030819cf70ed4cfd0020957b1ff8d3e322a7e7e090dcf3aec79391584e20370f", + "code/finite_serial_pool.py": "6b7ec1e2a3251b67c39729d144c9a0ff9c08049d56ecbf3f8217774f2553ccca", + "code/audit_pooled.py": "f8542d91ebce7785355af9088a1338a682df0148baa178f2012a49b788548939", + "code/rebuild_retimed.py": "99ad1fe3616e8c1cb13c56b168a32f4e728d42142ef6f50d51d3ba87cd4d4072", + "code/guarded_lemma.py": "6314c8f453c5ddabc48d7792dd8aeb1b68f6527f4770461d0481a790392ce19c", + "code/emit_pooled.py": "c2a939f2d7c678327e73708b15e98e829a7f9e2b3f5f2e4c3139e959525313a3", + "code/review_frames.py": "d5f194f22e08da34f50e85c99fdc150b6b6860767c8f523c5093067f8c9af1ce", + "code/retimed_lemma_mutants.py": "c1c0e6c43db07925a745321e8c092d292be0fac3c5ebd406b32996647bbf076b", + "code/review_composition.py": "6e0cbb849f42d44e3fae802044bc50a96c28329131610b848ff2c3cc40588922", + "code/audit484/audit_pooled_candidate.py": "81b3dbefcb8d9cbd15ef56b09cc4babff2fdbd818c67451cf04a93dfb46d33d1", + "code/audit484/audit_scalar_invoice.py": "652eed65fe8f72ab486dcdbe761f401f8a2d43530f2fb0c5c7777be488cd4648", + "code/audit484/assemble_candidate.py": "25b9f8e94e1964a122894c1f3d0de1a8a1994acb9a1c58ac99f1f318a73c8da4", + "code/audit484/audit_pooled_prefix.py": "5dab1df1a17987d5200c398b7f1f0e3085e06440a6f58acdc2dabf357d707c11", + "code/audit484/audit_pooled_owners.py": "bd071b772e2431f9d71108ac4a00d165e950e08cfea0e3698baac0723bb379c7", + "code/audit493/review_local.py": "0b847b6ec61d17223e5e352d1e6af7cfebfc9ff727b982e71f04f8b4363358d9", + "code/audit493/review_invoice.py": "c9770db17cb668b4d148b55f3d9d9440dc50050aad6df91e021b3d0c3f4b8248", + "provenance/retime_word.py": "6be3b24558180650490781d71cba29e4227a28d5e7fc72780249bcae1d95ee53", + "provenance/POOLED-ALLOCATION.json": "7bd4ccf92bdec87ea99aca9ce0cefbed6a4a42d85dc3e935b4ca7c4ec0f0f1a5", + "provenance/RETIME-FRAME-REVIEW.json": "d3df6f943f38a58a4848e3437983b23b706f148fce1d30e64aedfefee34c9644", + "provenance/RETIME-FROZEN.json": "d4b8df5ea74be9de1ca6ed58632c6f1f848aff90bc4e7a4dd9f4033f543c0688", + "provenance/PR493-LOCAL.json": "0c2ac175eb853d98fcde7a4b0a6a3c0a8dbbbe13e5987e85881d6260204a5eb7", + "provenance/RETIME-FINITE-ADMISSION.json": "b46a878c6ea3c5da9d2eb1c7a7f01ef34a887762eca08e382167630baa3d9007", + "provenance/PR493-INVOICE.json": "30c0ab2f4f9b8bb702d72c72825c8f1819d2ad1adb73bc26d3cfc43915611bf1", + "provenance/retime_continue.py": "e3619582761711f7803593374dff9221b95c5ea9479b5e8c02352541b584f6d9", + "provenance/UNPOOLED-SELECTION.json": "85089fb301976b5739cb3d219070ae89f75e42582a54c5a0557f8530035f9eb8", + "provenance/POOLING-PROOF.txt": "dcc30730f8fd7bd6c68dbf0d0df1bc7a707d608bd0f286a61f375716a13987cb", + "provenance/NOMINATION.json": "0bbd0d7df7ea8c111b6e58a8e4757e66d8f7947fc9b29b32ed3ec26f2eb3d9ef", + "provenance/RETIME-GAUSSIAN-ADMISSION.json": "ae6306dfebaffa34c5beeb375eead93e51aa5b0632b1655828f7462b9cbec438", + "provenance/MUTANT-ADAPTER-PREFLIGHT.json": "2493cc35690117c2b90b96b51761f37d91975f3e166fd830430d7057d0d1990d", + "provenance/PR484-INDEPENDENT.json": "8427cec228cccd2030cd61bbdfb52e38207235ffde94459f2385a5649efc81b6", + "provenance/POOLED-COLORING.json": "5c683d2768c60a7d7eb0bddca215717d8b390614dd2d45bc6e36e1a33b2db0d1", + "provenance/nominate.py": "ff393ff86291218f8acd9f086a5d3426e67d765b2712cb9937434b0b18c593e5", + "provenance/retime_neutral.py": "3ac82aeae437880b3ded869cfabb85e3739fb07aaa2ae00a79aa126926c2491c", + "provenance/BOUND-ADMISSION.json": "21db5fbaa6d73c03691eef54f965792a5f2d5c073defa19be2c968944535ef92", + "data/COLORED-OWNERS.json.gz": "e597d547372420a4d4fbdc2d0317bfb404c57d1ee5f39c5f1afcbe070a3b28b0", + "data/RETIME-FRAMES.json.gz": "0ef98bd78bb62b59c28578a9fc56c97c97578883d62a966b5d51c2c1c3583481", + "vendor/bit/MANIFEST.sha256": "7f25c41d0400ef5adf763eae6e166003a9b59e5a655b860c04b052f6731c7297", + "vendor/bit/SOURCE-pr436.json": "4a4f99f5bdb7530a0dcf9433f7f02afbf2abf908e718f7c63ffa5503d4f49693", + "vendor/bit/EXPECTED.json": "3494ba83280cc86548fe0cc6695c50d23e6b6ffca85aeb1a33337c1196e280cb", + "vendor/bit/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/bit/requirements.txt": "6023d480f929cdfa4e2f35e361eea003451cd6695af806935a32038b0115abb5", + "vendor/bit/SOURCE-pr483.json": "24e3eab4a985e115adb7f8665a401423e9636e9f16cc4373ec68cc86950445a8", + "vendor/bit/SOURCE-pr381.json": "16b1977240ca9acb58fa64572fb4231a423bc10bbf3e7bb30f1c8201fe369ba5", + "vendor/bit/SOURCE-pr471.json": "499d861e090c9e646d978dd67890a8e58a9ff6bf08512684e66605179132076b", + "vendor/bit/SOURCE-pr386.json": "87c659ba932525631a40be14dca28a6a2efade8641f23bb08d6e1567fc991131", + "vendor/bit/SOURCE-pr451.json": "a639956eec858341987a815b7464ef472505300db754b5f9ac012dd01d18c8df", + "vendor/bit/verify.sh": "0f9248aa3611dfe2b5d59dbe992c6f7d21a0cc4f1de2b5ed05a6110191191224", + "vendor/bit/SOURCE-pr484.json": "b92f43fbcba3921a1aa37bcb9f05cf5fa612ff708785e05512438a6317bf0867", + "vendor/bit/README.md": "e5212e8058c92a2b02cc12b4e174a65ce1cef7b4d7977ae770e64f5ff91b7204", + "vendor/bit/SOURCE-pr473.json": "2515c4f23dfa22a21913d92597669770f7f44c2a5b3ef069ef68a0c89779a656", + "vendor/bit/SOURCE-pr445.json": "e6f4a272442bb71ef68aaa3545b271236f9c99297e444fa01c62b0b5fb6a170f", + "vendor/bit/SOURCE-pr448.json": "c771fa9be492408a78d6d970c839e68c4dfd1b66f4f4a4748e3d12726a43cf27", + "vendor/bit/SOURCE-pr370.json": "03de1d341196cfa8cf1d39f3cc8648b25bb5f39c3c602a728cfbd089e8253ac0", + "vendor/bit/SOURCE-pr472.json": "6753bcf50c91806b75dd4dbe3963a79699a614d0dab8ce32b261cc3e76b288b1", + "vendor/bit/SOURCE-pr458.json": "cbdea984a46ab5de354b95e73fd76c1918fdc6676c658398a552772c4dc3dcaf", + "vendor/bit/NOTICE.md": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a", + "vendor/bit/SOURCE-pr478.json": "9c7c4ea678865a955b0c89f0952927159976fdf55cadc6a488dec5757f03fe7d", + "vendor/bit/portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99", + "vendor/bit/discovery/plan.py": "40e8dea1b4b71c5afd5993625f57bcac089dd2f72dfbc4dbc23ce917e5a61010", + "vendor/bit/discovery/README.md": "b09aa45d5651720e10326cde559c863ba3ea45fe2fb6b4aaa3bfaa66a8fcf69f", + "vendor/bit/discovery/d4part.py": "a64927c340a4772ce0682b349e0c90c80d1a766000ccf397fb41b36a31929179", + "vendor/bit/discovery/host_select.py": "2aaaac18e083d289d4341e734c32571c89c51fefba04b388d407c7372b906dc7", + "vendor/bit/code/cited.py": "a4c2dd4755f2a45ceda327b36d9ee400c2804893000626ca8ff3f6ee296fd842", + "vendor/bit/code/provenance.py": "e28fd87d0e34a6f6f6f1fddb6c4891deac220662c954de855d7aa5a7f9cceca4", + "vendor/bit/code/bit/mutate_records.py": "b0e75d6550412a7be4017695e6b237392b611bb852ad8ff309d6682c9f166a4e", + "vendor/bit/code/bit/mutate_records_mut.py": "a9e085ec60d5657cd5d77832e3d95004e81b9f4f249d9e0fc95e345366cb2d2e", + "vendor/bit/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/bit/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "vendor/bit/code/bit/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "vendor/bit/code/bit/checkers/legality_h.cpp": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3", + "vendor/bit/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "vendor/bit/code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "vendor/bit/code/bit/independent/mutate_mut.py": "3b002c19a5dcca76a5594f2a30fac7c01d2b45fc96b3e7cfbfd8b720f5ffb4e8", + "vendor/bit/code/bit/independent/interface.py": "2c63a039f97e3a11ce5a6b83302d4f5beda160c1db14164a5a9b0855aeb19d3c", + "vendor/bit/code/bit/independent/mutate.py": "0ff65aace5da4b57d96235bf830f8f11969322e75134d498aeb70e9753ec6b0d", + "vendor/bit/code/bit/independent/relax.py": "d6e9f58de3fa41f538516b6227c249d61fb30f0f6843027cc8a07a1a372fa6b6", + "vendor/bit/code/bit/independent/checkword.py": "11bf9620ca9db16d52d9fe806b814fc9ec9a89c4d7645354d1861d96f6e805ad", + "vendor/bit/code/bit/regression/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "vendor/bit/code/eleven/audit.py": "5ad832830c19ec6c904d1b64480f6b1e71c5673fdd38d487d17e179b1d197c09", + "vendor/bit/code/eleven/local_audit.py": "95275473d7f9811011bda760dd0f04de5169c2a6922456dc9a5725a5d671f941", + "vendor/bit/code/eleven/assemble.py": "c47889a606701ae592374dd82a13cee8c5a4e8449b7facfdad2d90563a30a18c", + "vendor/bit/code/eleven/adapt.py": "d8a8c13b484d985f0133a5d06de4a78b8477314f922b9f693ba73640b7184d6b", + "vendor/bit/code/eleven/emit.py": "b0b25955875625ed63f82690f83aef976e3e9a978ae6620b23a23fc1207acd46", + "vendor/bit/code/skeleton/gen.py": "7cdcf48078ed4beacd2e240aa8145e4aa6984558748d07659cb1b252786e073a", + "vendor/bit/code/skeleton/geom.py": "bb356568fa05e7bfd5fcd9012903611cf742729a99b4dc3a13685355b2678ae3", + "vendor/bit/code/skeleton/e8.py": "721d859a6517d665ca84d03ef89668da3aae7433ffb0ee47faf37f2aeb85450e", + "vendor/bit/code/skeleton/wordkit.py": "2b6c12d96f24a4e81f2c807827c2b74cf80037367fc8034e8c871dd5ce008351", + "vendor/bit/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "vendor/bit/code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/bit/code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/bit/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "vendor/bit/code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/bit/code/hub/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/audit.py": "d28062127a9b0d3866a3b79aad98a307233b20ebdb94cfb9f197d726b82ffea5", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/local_audit.py": "23eda3fe3d774e7f2dbf4dbdd4ff90d69ae7d1762ff95c8629cdc7667aa3fe71", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/assemble.py": "abb60c35e448e0f94073f38a0352d11249aaf7bb8dbd7352414ae60a1d2b79c3", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/emit.py": "98d77cefbc3a76f9f10bd7df3a2590ab88b411f6afe77b5f8d73f1602eb2bef3", + "vendor/bit/code/hub/e8-r715-whole-hosted/data/hosting.json": "765382d4fefd594e94c8c5826ec6300422ce9f79c816d7f7323ef85e99320f28", + "vendor/bit/code/hub/e8-r715-whole-hosted/data/word.json.gz": "b2af02f593cd161bea64e6cd793508386914136be519f80726c071697379d5a9", + "vendor/bit/code/hub/e8-r715-whole-hosted/data/residual-isometries.json": "750221cc66badd0ed0a74e7aad2d59f91f89c107370af21c6d929fbdd4a08a9f", + "vendor/bit/code/hub/r740-hosted-rank149/code/emit.py": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4", + "vendor/bit/code/hub/r740-hosted-rank149/data/word.json.gz": "41626789888ee070e1b435fa380b10ab9b88e3cf7d8d8e166ecef17269bbcf47", + "vendor/bit/code/hub/r740-hosted-rank149/data/residual-isometries.json": "b23fda74a7979179e8fd83ee9870c1e232442cc90c05077adaabfe31d050d1e4", + "vendor/bit/code/hub/r740-hosted-rank149/data/selection.json": "4d9c2cf6a3d31a6faa287731e0721cb16601b0bc5c1a186b9645bfb5760ce8db", + "vendor/bit/code/hub/e8-r740-replica32/code/e8core.py": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb", + "vendor/bit/code/hub/e8-r740-replica32/code/bank_routes.py": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d", + "vendor/bit/code/hub/e8-r740-replica32/code/tile_m.py": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd", + "vendor/bit/code/hub/e8-r740-replica32/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/bit/code/hub/e8-r740-replica32/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/bit/code/hub/e8-r740-replica32/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/bit/code/hub/e8-r740-replica32/data/word.json.gz": "d8d6d3d3f336720302bc40b3c1504fe3c3583a7a8d707bb9bd7b21f85e5e69c6", + "vendor/bit/code/hub/e8-r740-replica32/data/residual-isometries.json": "e12ed7ddd13cee101ba74a083b54665fd64d0b122b0bad5b83d817dcc8bae9d8", + "vendor/bit/code/hub/r740-hosted-eleven/code/geometry.py": "9554182d67e434ea84b4430f909a2c400abc755d8487b51454a8e6968e62859d", + "vendor/bit/code/hub/r740-hosted-eleven/code/emit.py": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4", + "vendor/bit/code/hub/r740-hosted-eleven/code/row_bound.py": "de4a9b9cd797e1a05da56f62cfe725c8728cea3a4aa031b7d1b0a68f869760d6", + "vendor/bit/code/hub/r740-hosted-eleven/data/selection.json": "52dbbb68e8c147690d15eaa1d952df05d074b0c121885a4159d9f6732f391872", + "vendor/bit/data/complex-b.json": "dce3f4b76aa3f6c3ba826ce556ffa61398b33e81e4d1a226dd2a36ce684fb02e", + "vendor/bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "vendor/bit/data/bit/bitE8mut-r489.json.gz": "835eb96e147740fc7454f8cfb3dbd34ae89524b1dbd89a61e9288eae8ab6a5b9", + "vendor/bit/data/eleven/hosting.json": "61f790657c465d16d3455f48f90f816797b9ea08bf02dbd0c90d2cf41836257e", + "vendor/bit/data/eleven/residual-isometries.json": "0fa5b353a0321af2ce4e2045db1d4c2d6418a11663894e2afcdb1eaa1984bddc", + "vendor/bit/data/complex/pr458/EXPECTED.json": "a4312cb0c53c2066a28b683a971a41e7d76c5f6d828a96481c3ae7b3c01bb2f3", + "vendor/bit/data/complex/pr473/EXPECTED.json": "70e515f0a5a2f9508cd030d35a99f90981a6eccc027c9ad5a3c77f5860310910", + "vendor/bit/data/complex/pr484/EXPECTED.json": "0c93018a23bc573c7d155d4786e0c3978e95be0fda974076697939a1a1d8e5be", + "vendor/bit/data/complex/pr483/EXPECTED.json": "799fa4ab2f785c478c3cdcb6c1c0428a5ce6e3ddbe4a4b2fd88630d811a593f6", + "vendor/bit/data/complex/pr448/EXPECTED.json": "18b42250c3faf6f0df76fcab6c3a483582192ad7bb09cb1985f4b0bb91d67024", + "vendor/bit/data/complex/pr478/EXPECTED.json": "07bd05d14c71df8925b0b03510b2b337334b73ac425a94e03b2ec34ed2680164", + "vendor/bit/data/complex/pr471/EXPECTED.json": "188f9d1a7450496dbfd8d64381febd20b0597141537eb1a003435297df2d1720", + "vendor/bit/data/skeleton/d4part-pairs.json": "d69ffe3326140bc541b8f1639e02db43a5835ab8ca02cc742b5bee2bf2ef1ba9", + "vendor/bit/data/skeleton/plan-skB.json": "f6162bb4d8092bc233700fa7ebc6a0d79f2893135aee18e998369044abb3f44b", + "vendor/complex/idle-axis-hosting/PROOF.md": "cfe34bf0b64259661312dae22c3a23adc5bf6f6326951eee5c1488ccfc347542", + "vendor/complex/idle-axis-hosting/audit.py": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "vendor/complex/idle-axis-hosting/EXPECTED.json": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "vendor/complex/idle-axis-hosting/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/idle-axis-hosting/complex_hosted.py": "829c5c4f4bdfccedadd31505f1f0a394f7a208d1446b7bbf9cc92d3aa1530c0c", + "vendor/complex/idle-axis-hosting/bit_hosted.py": "6dfbf26213e8adf87563b3575cfb722bd07ecd65627f056b3293411dd3d89a61", + "vendor/complex/idle-axis-hosting/assemble.py": "f9a2e6a42aadcf971702a5a867760a092566ed03356f4f34387d38f4093ad1a6", + "vendor/complex/idle-axis-hosting/README.md": "1151f74cad54ac4937282b7a8b5d1108ed4ce35944ef9b7bb7d17abfce1fe4a0", + "vendor/complex/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "vendor/complex/idle-axis-hosting/MANIFEST.json": "f68b82604363329618529313ac9c3796dc1e88b176eaee4a7b0dec9be428e987", + "vendor/complex/idle-axis-hosting/SELECTION.json": "315d54be472842707cce879618be477d8b897050e873bc136d114eec6a232f97", + "vendor/complex/idle-axis-hosting/verify.py": "737a974d79fdd232b6c4b9e059c56835079971447342ed7ca3b82a614e30cb53", + "vendor/complex/idle-axis-hosting/NOTICE.md": "027a868628d0408602dbeae688b031ed9b4abfd6e5401f6e8106a3eb25ebc4ca", + "vendor/complex/e8-early-reset-reuse/PROOF.md": "09388e2f9e6b8fcc626a5172d55c45a957835075c51c68d1e86fd42ff4655ae8", + "vendor/complex/e8-early-reset-reuse/EXPECTED.json": "5521c7e995fec77941243b28e090f95f2188f193d5f61275275cfa11215eecc0", + "vendor/complex/e8-early-reset-reuse/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/e8-early-reset-reuse/SOURCE.json": "c52287239c43aece2b3533ef48ee204d845d652066bca716c288b0c47e779521", + "vendor/complex/e8-early-reset-reuse/bit_global.py": "9c2178df133dc663416aac13d8c8da80a9e4f5f7174bb36413180fcbad994ffb", + "vendor/complex/e8-early-reset-reuse/bit_audit.py": "219eb4dd8e5380fb0432daa6a30c265755a78834616b2c5fc7aa161feb0231ee", + "vendor/complex/e8-early-reset-reuse/README.md": "442bf686c0b24b9d7781b7b138f32fddea5d4efffeddc6e41d04719d2545e0cd", + "vendor/complex/e8-early-reset-reuse/replay.py": "e0782ba05dda36323500390349d1180f6117a9c6112b09b9e21e29f67c4e5f5f", + "vendor/complex/e8-early-reset-reuse/VALIDATION.json": "bcb864a6b73d4ff4a24ab70ad51287653723c2115ce1c81db7817b81df2d9e92", + "vendor/complex/e8-early-reset-reuse/MANIFEST.json": "4d23bafa43634a59e25f875333408b67cbecb1c912929824b5d45dea4de51da7", + "vendor/complex/e8-early-reset-reuse/SELECTION.json": "9d47ade3fb69b3ef62a1a3ae75cebdddd57d144923977c5f2a07848ab596ea32", + "vendor/complex/e8-early-reset-reuse/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "vendor/complex/e8-early-reset-reuse/verify.py": "4e2082878acc1298f4354325b28f3cf047006170a9883148e7cf23002f6f02f1", + "vendor/complex/e8-early-reset-reuse/NOTICE.md": "c4085541471fe63d8f735beacd397d356446376ad3e56b2673940a2df3b8437e", + "vendor/complex/e8-early-reset-reuse/combined.py": "dc621dce9ac1634a2701318311b30dffee7cce7e0c6be7ae808f44b27eb17f0f", + "vendor/complex/e8-early-reset-reuse/local-evidence/PYTHON311-GZIP-FAILURE.log": "ec1937c575536aeebe8f9c22d673fd66d1355ff870e2fdc80346205b29e42784", + "vendor/complex/e8-early-reset-reuse/local-evidence/ASSEMBLY.json": "c9ce28f59a5e460d39a888bbbc464e3fd6dd1c0b2c54ae86baeeea99febc8176", + "vendor/complex/e8-early-reset-reuse/local-evidence/FULL-PORTABLE-PYTHON311.json": "1dcca855b20cbac311a435f23f60001c342083edbef3194ba42a30e1f24c1982", + "vendor/complex/e8-early-reset-reuse/local-evidence/PYTHON311-INITIAL-FAILURE.json": "7902e8ca1e167b98d1c29170f8d57c9896b38ccab89065e4ed4e2c3feea79076", + "vendor/complex/e8-early-reset-reuse/local-evidence/BIT-AUDIT.json": "2e458c3936e42539095610a50c730266dddd96e94d1ead171a99dd5f1fe9ef47", + "vendor/complex/e8-early-reset-reuse/local-evidence/BIT-GLOBAL.json": "39f89d1e5bf51e9b1f1155e123dc3226627e465a246d37bb00f55d44d20bcaa0", + "vendor/complex/e8-early-reset-reuse/local-evidence/FULL-PYTHON314-INITIAL.json": "0966528d4b30459d8b35296f31dbadfa34cdc7792419b34ab2505b7098923325", + "vendor/complex/e8-early-reset-reuse/local-evidence/FULL-PORTABLE-PYTHON314.json": "5687ed9209e11e64304d008a4a10678dc07cdc3522f5112c9a80557d45125c4a", + "vendor/complex/e8-early-reset-reuse/local-evidence/BIT-PRICE.json": "96ec606146b5157871048e28f6649c31c1b6117d43be732e6a96bcc269c0e1b6", + "vendor/complex/e8-early-reset-reuse/local-evidence/PARENT-FULL-REPLAY.json": "0ba447d6de6edd9fbe2371c36e3605dffa0c6526a874cfcb9bd19285c056bf1e", + "vendor/complex/e8-early-reset-reuse/local-evidence/FAILED-LATE-RESET.json": "f6ed36b59de745d50f37fcb4c80d129d9a2de0dfe1fe3de2d18e678135f7d9b6", + "vendor/complex/e8-early-reset-reuse/local-evidence/FAILED-INLINING.json": "95cbb0e6df953d25a888198c1072edf03db85b7c967a234680db3e095abd2dc7", + "vendor/complex/e8-complex-gauge-kernel/PROOF.md": "a6bf0662abdd9bbe0649b52cada82c3341e61b49b966b93aa6f8f1ab30d2d949", + "vendor/complex/e8-complex-gauge-kernel/EXPECTED.json": "0c93018a23bc573c7d155d4786e0c3978e95be0fda974076697939a1a1d8e5be", + "vendor/complex/e8-complex-gauge-kernel/SOURCE.json": "ee6dca44a773d457b9e0bbfc8d3d5f571673913686fa57187e63a84857ff505e", + "vendor/complex/e8-complex-gauge-kernel/PR-BODY.md": "839708cb1f21d34f7ecf8d9edc5c9ec800b747d92c99e384e0bc246211bd01a1", + "vendor/complex/e8-complex-gauge-kernel/README.md": "64bebef404af500d4f32e3cb17ba143a53c7f251712246e1b85a6887b2d444bc", + "vendor/complex/e8-complex-gauge-kernel/MANIFEST.json": "56199b350a49a6d9c114eec1620e889eedb89170af2b872bf8b8f42df8a961a2", + "vendor/complex/e8-complex-gauge-kernel/verify.py": "56a36950ed486a1b38334e8d75fd1efe75da7ba604fb4fafe7d8dc1e388349c5", + "vendor/complex/e8-complex-gauge-kernel/NOTICE.md": "7c7a022afe969a09ad5320935daf7db256b8f25ee56ecdcf9fc40eb0836e74ce", + "vendor/complex/e8-complex-gauge-kernel/code/controls_pipeline.py": "cc6fb8bf4644cc3a1799f3bc90dc074adb5663d1889c92f7f73ec9f307acbd36", + "vendor/complex/e8-complex-gauge-kernel/code/controls_hosting.py": "573966c7ad1deac24464414d3886171f594bb3ae3e7236a9ac2447cc40b20211", + "vendor/complex/e8-complex-gauge-kernel/code/gk_word.py": "f027a9273bcf4e0971258c160b7d3b3c196366b32a529cff6e6a0e666b03826b", + "vendor/complex/e8-complex-gauge-kernel/code/gk_common.py": "e68d190fd436b2f3955decb590adb53344d5d4ea0a19d62d86df1e4b55ecd198", + "vendor/complex/e8-complex-gauge-kernel/code/hosted_gk.py": "8d2c29a5f79e6a1391f96baf44dd9fbe35203b6c11b02a7b2d238cf792ea163f", + "vendor/complex/e8-complex-gauge-kernel/code/emit_gk.py": "4e415bff1d9f154496ed38e6889929b600aa0f3d583a375e8ca257ad8f51fa23", + "vendor/complex/e8-complex-gauge-kernel/code/controls_gk.py": "cf83aa95f03aa812c413905df9f75f13ac8f92f5db6a83cf9b1868aea2dd9de0", + "vendor/complex/e8-complex-gauge-kernel/code/controls_sel.py": "d2777571d59736c3fe62b81506ae62c22a3816fbc3abf9303d914e6da6d64258", + "vendor/complex/e8-complex-gauge-kernel/code/audit_gk.py": "cb79c6b788333a031e14c7f134823f5f6147d7f1dcc6e5e3b1420743c32f8ebc", + "vendor/complex/e8-complex-gauge-kernel/code/onehost_gk.py": "416b318c1b6b8c7b72e24713b1b18d8772ec368e042a321b4418c63a74711590", + "vendor/complex/e8-complex-gauge-kernel/code/make_meta.py": "06e44ae4fc4f3a88989828d6cbdf95524a2d9f65753045cbb3e6cfd7e042d96a", + "vendor/complex/e8-complex-gauge-kernel/code/integrate_gk.py": "2e807893180a3716b36a81f1a7d933bd55f2299489b6f236ba5c644d87739209", + "vendor/complex/e8-complex-gauge-kernel/code/audit_hosted_gk.py": "c46c69c1c6fdccce991bf5d5ec7def344d2749c53ad2db976a50ba3a6c37d657", + "vendor/complex/e8-complex-gauge-kernel/code/replay_gk.py": "2422b44fc2fb4742bb575572337158a15fb6831630f8746a1c7ee3133e0ee2e3", + "vendor/complex/e8-complex-gauge-kernel/code/adapters_gk.py": "a8d6d9ccf20c261cb0b216baa9906f2f7689e1bb1dca070313a60b2cb6d3043c", + "vendor/complex/e8-complex-gauge-kernel/code/run_variant.py": "feecf7dff32860a02fbfb96da1049ba35d05b3baf74c4f741b878d4d91903903", + "vendor/complex/e8-complex-gauge-kernel/code/assemble_gk.py": "e377ef9d9e90168290a4640250c0fb9c05015104bcc4827bc5ce63f6ca63763a", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_phys.py": "0ca37829b596d83d0b94c5f0b6b278a100f22e626b2ab3b5210a38f9657c8a27", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/check.py": "f572b7129a546e1b1193fdd5baee4f731a5b9b8a4e8dc7ac170bcad7758e5b9a", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_mutants.py": "cf0d1f8e90a0780244b6de38d6aad08dd42f4c439397a6d5a61fccd23fe7e798", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_lib.py": "00068882bf2f2ebadd3f87c94204f226c7938966124bafb9ce6da89bfaf91b45", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/gd.py": "64cdb2cfefc9ec3ed80c277a18848778427c3d3dbda9b7be13f740522478e1de", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_e2e.py": "8fe3719e8ec5ec49af480b40c15f07612a356f5071ea30e17ae2d8931b3f20ce", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/run_labels.py": "5f053e553b1c26e553a844e2891a73b6cc6b79404a7bb5d4722529f7db0d592c", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_instances.py": "47dcf2e9ae2d99699424d684abebc3d1d2d25b7aa6d440761e19835d140f5fbb", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge4.py": "e4e438034a3cd4c49adc744de86819dc574b130fb8bc8dc48b1d9955a3601a42", + "vendor/complex/e8-complex-gauge-kernel/provenance/sa_long.py": "e2270814c0ff0617b1104a007e4604ac713dbb1a033771d4a5357796198e646e", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge.py": "a0fbf14085161f89d52343de80cddc8a11451bac635bc2677549ae7a26562491", + "vendor/complex/e8-complex-gauge-kernel/provenance/cxcheck.py": "1df8db02ad02e8f1cf0bbaabd92d7d88341f8e10f0e76d7777d246eb52094ac8", + "vendor/complex/e8-complex-gauge-kernel/provenance/iso1.py": "1a7e3e08b0ecb9cdf19525ef23c5f790cf19427e238e71987a30c35aa54d9612", + "vendor/complex/e8-complex-gauge-kernel/provenance/kcap.py": "96e4e067d850f1b3b5cdf241371956a99fe4f60229edd3fe43b3f7d14ae78bea", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern4.py": "0a21980027d427a6377a525d7082e460eed9e8577328831e2edde7eede1998dc", + "vendor/complex/e8-complex-gauge-kernel/provenance/hostmodel.py": "1fe732f944166dca53363d63b0bc2a5c4ceaf0ffdb8973f554720be07bf07395", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern5.py": "bb0bbf4504f714d5d14c362d90c0d66c85c912e5b2f19c7401040e967c8a3c0c", + "vendor/complex/e8-complex-gauge-kernel/provenance/README.md": "76f04346717183300ec2d3bf852d5bacc8a6c3dee458a17a1957613ddf033af0", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern2.py": "62c02a73484f0b513c2d7bd4bdd9febf1c84bf42457506a36bab30b97b267efc", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern.py": "bdc708e887bda780b3145e2f536db9ace13cae165447c6057bb8b3476f8f1dc0", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern6.py": "849c7e9404edb5bb2d2064339014d6bbfd7bcb0ab62a4ca09d7d2c658dcd14c6", + "vendor/complex/e8-complex-gauge-kernel/provenance/cxlab.py": "46dd697395d69776eaefa7d5843ada050528d76832967c76afa2e80beb7d75ee", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern3.py": "e31d8b9728881d7921c404e55b875e6f8cea46a0c9fc6eea8263416cc6fba109", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge2.py": "3dda541e514944fc6486407a889ac6a0f3b1eeab08092799dec672a89cbcbcb8", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge3.py": "fb74644f093f8a725af146b560380b360dc655edde61c7695d1a2d9b33fc58fc", + "vendor/complex/e8-complex-gauge-kernel/data/bit-suppliers-pinned.json": "77121915641c8fef57ab10585fd5e8b13c817356bbbea21f4314d381cd029b83", + "vendor/complex/e8-complex-gauge-kernel/data/SELECTION.json": "89b19daca7db07a7e09723b1b74b55682ae64af98072dbb3110d0376b7f052b2", + "vendor/complex/e8-complex-gauge-kernel/data/selections/gauge80-kernel42.json": "436e4acadee227dbfcb66386c9ccaa38e68054e8ed4870bb174eeb41363375bb", + "vendor/complex/e8-complex-gauge-kernel/data/selections/empty.json": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", + "vendor/complex/e8-complex-gauge-kernel/data/selections/gauge80.json": "41e62cfd0d50f348eae3f81d9f62f7dab2667294554398d8bca43aadbb2c291b", + "vendor/complex/e8-complex-gauge-kernel/data/selections/kernel79.json": "febded05174c364049632db3214dc9209426d1b81581cab728d79fa6594c9e47", + "vendor/complex/split-centres-global/SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "vendor/complex/split-centres-global/PROOF.md": "6983e75f29af6eeaab20a30b08307ec6fab75ccb8b10291df8f9eb04d497f894", + "vendor/complex/split-centres-global/EXPECTED.json": "9b8e56eee3d5bdabd2e3e6e4ba0d9eba537525fba25a54126f9f0e41d2491a06", + "vendor/complex/split-centres-global/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/split-centres-global/README.md": "b432292594adf2fcba2a8ddd87eda6167c76ff055e85aa5e3e2af7dd7e0f976e", + "vendor/complex/split-centres-global/CERTIFICATE.json": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "vendor/complex/split-centres-global/VALIDATION.json": "656d9bd7bd66058fdeb60cc90bd887e7ce75c0e0f9a100514e2bd84b95de89b6", + "vendor/complex/split-centres-global/.gitattributes": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "vendor/complex/split-centres-global/MANIFEST.json": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "vendor/complex/split-centres-global/verify.py": "12fcdb20a87f75812b09c4916fbfc86305982cb410247186a123b5c58d517b4c", + "vendor/complex/split-centres-global/NOTICE.md": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389", + "vendor/complex/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "vendor/complex/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "vendor/complex/split-centres-global/proofs/PR426.md": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "vendor/complex/split-centres-global/proofs/PR425-COMPLEX.txt": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "vendor/complex/split-centres-global/code/complex_emit.py": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "vendor/complex/split-centres-global/code/complex_phases_full.py": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "vendor/complex/split-centres-global/code/bit_global.py": "3b2cb3ba21e5cf9b4deddb9e606322f33e9d8082020c0ee9092c21f4ebd9ad48", + "vendor/complex/split-centres-global/code/bit_audit.py": "7fdbc077b7501a53662769ff2bf2ab44cc2e32dafc34478d7ef2c10e3144503a", + "vendor/complex/split-centres-global/code/complex_construct.py": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "vendor/complex/split-centres-global/code/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "vendor/complex/split-centres-global/code/complex_audit.py": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "vendor/complex/split-centres-global/code/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "vendor/complex/split-centres-global/code/complex_integrate.py": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "vendor/complex/split-centres-global/code/complex_phases.py": "13a959c52092776ae217df554b51c0298fa9eb3a350279acff6dece651c3f9cc", + "vendor/complex/split-centres-global/code/combined.py": "9c5bc70f2331b7342ceb252adcddb993581c45f80c37bcc58642dbad3b9775c2", + "vendor/complex/split-centres-global/code/complex_replay.py": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "vendor/complex/split-centres-global/notices/PR426.md": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "vendor/complex/split-centres-global/notices/PR426-SOURCE-PINS.json": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "vendor/complex/split-centres-global/notices/NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "vendor/complex/split-centres-global/notices/PR386.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "vendor/complex/split-centres-global/notices/SUSSMAN-NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "vendor/complex/split-centres-global/notices/NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "vendor/complex/split-centres-global/vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/complex/split-centres-global/vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/complex/split-centres-global/vendor/hamming_packets.py": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "vendor/complex/split-centres-global/vendor/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/complex/split-centres-global/vendor/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/complex/split-centres-global/vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/complex/split-centres-global/inputs/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "vendor/complex/split-centres-global/inputs/complex-template.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "vendor/complex/split-centres-global/inputs/e8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "vendor/complex/split-centres-global/inputs/complex-phase-receipt.json": "01763fee5017745de982f2ff5ee68004e815d6684097cc88011dfbfb1e789581", + "vendor/complex/split-centres-global/inputs/bit-r767.json.gz": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "vendor/complex/split-centres-global/inputs/complex-ports.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "vendor/complex/split-centres-global/inputs/complex-phase-recipes.json.gz": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "vendor/complex/split-centres-global/inputs/complex-data-phases.json.gz": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "vendor/complex/e8-early-reset-kernel/PROOF.md": "fb4e1c3a23e3a0be48b5254133e584dad6fb523042ca8ef70358684fb9185962", + "vendor/complex/e8-early-reset-kernel/EXPECTED.json": "6710a99055d7ee1d83d9f811822bb72db84f6ce95bd4e1e17f1df1659c7e958b", + "vendor/complex/e8-early-reset-kernel/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/e8-early-reset-kernel/SOURCE.json": "a5e84250b687624b2158597831fb36a5f2b068983862c491f8e1020c9806cc65", + "vendor/complex/e8-early-reset-kernel/bit_global.py": "79c7dc84e65dca10c35c842cf170e4719d45c38a25d03bf762332b24c700b6c9", + "vendor/complex/e8-early-reset-kernel/bit_audit.py": "203bb609952ad7b7ca761e9f9883ee9fa35a0a0474503b396d47a31169102e7d", + "vendor/complex/e8-early-reset-kernel/README.md": "4d7d736eda667533ab55bf3949e30832d4676d7ebeee00d9608307ecc5aacd4b", + "vendor/complex/e8-early-reset-kernel/VALIDATION.json": "77ad775cf69f5d913568b6276b0dfeb2eaef0306f57b71c0a467bff793807267", + "vendor/complex/e8-early-reset-kernel/MANIFEST.json": "95a9570287b64d22de30e6ae3acf931d5f6daef1a163f0c99532e1a24639fbc2", + "vendor/complex/e8-early-reset-kernel/SELECTION.json": "b5f5d8c78d912820c8ed1a67c21062bec799714b9caa6724dfd515306ad42a2b", + "vendor/complex/e8-early-reset-kernel/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "vendor/complex/e8-early-reset-kernel/verify.py": "16c07414bc956744dc93b8e35b642267ea9819be922b0d3e081c543fdbf92a70", + "vendor/complex/e8-early-reset-kernel/NOTICE.md": "ff88b6031fe2fb5cbc483e8fcc08d228eaf2c982221adb3659da234dfa24cfeb", + "vendor/complex/e8-early-reset-kernel/combined.py": "4d514b6c70e969ec306d8c2bb38edec95b0cb7fa09f48dadbec8aa1eead69ce1", + "vendor/complex/e8-early-reset-kernel/source_span.py": "4772d177f37254c6f854af5ee3871aca193cfb24307a53c143c3bf517e56631e", + "vendor/complex/e8-early-reset-kernel/apply.py": "0d530e9703e1d1734c7af205bd393cba89ac41f75ed9781ea3dc5e46650f44f5", + "vendor/complex/e8-early-reset-kernel/local-evidence/ASSEMBLY.json": "7c3cc4b503e4cf0fd3e050be46ad0da183c5b1c490f4901245df944fd9d6194e", + "vendor/complex/e8-early-reset-kernel/local-evidence/SOURCE-SPANS.log": "bdf95dbce8337be57aab8a3d3b42a711ee276496c40cbb4c5356fc9cc9b2e811", + "vendor/complex/e8-early-reset-kernel/local-evidence/AUDIT.json": "76a146a9123d8b653e6e46ff93f153653f9cefd0f5c3fdd264a59f1322110262", + "vendor/complex/e8-early-reset-kernel/local-evidence/FULL-PYTHON314.json": "85797531db037d06fb597a4c9b6ef6bd71e6a0ab4f220ae70b1b6bf3aeda205f", + "vendor/complex/e8-early-reset-kernel/local-evidence/GLOBAL.json": "16c4e829eea1b2d12b70cec7e6a9c0e33ea0eae98a40894a3b779790fd2efbb3", + "vendor/complex/e8-early-reset-kernel/local-evidence/BIT-PRICE.json": "9a4a320cab1ce62b0c2329ac1bf3b81f73580fd603a406e4bfaae2962dfdad35", + "vendor/complex/e8-early-reset-kernel/local-evidence/FULL-PYTHON311.json": "62b37525bf7b60c0d9101ed571681f3bf46ea75df065939864307e4986018332", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/stages.py": "e73ab7836519510ed30dd7e3022dae557fa50fc513d723197929bff741859668", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" +} diff --git a/research/r489-pooled-retimed-complex/NOTICE.md b/research/r489-pooled-retimed-complex/NOTICE.md new file mode 100644 index 0000000000..786ba20895 --- /dev/null +++ b/research/r489-pooled-retimed-complex/NOTICE.md @@ -0,0 +1,34 @@ +# Attribution and AI disclosure + +The bit word and full verifier are vendored unchanged from eumemic's PR493, +commit c3a9a436b84fe44fdc223a5784d84736d1c2d3c7. Its sources-as-carriers +construction retains the authors and disclosures recorded in that package. +The complex word, exact Gaussian phases, wrappers and full verifier are +vendored unchanged from DreamingOfClouds' PR484, commit +035845ce95f31d0a2dcfb42b8c8e13411271fa5f, with Claude Opus 5.5 assistance. +The complete pinned dependency packages retain their original notices. + +Whole-family hosting and the supplier pipeline derive from DaysSky (#442), +icekylinx (#433), chafreaky (#458/#471/#472 and related kernels), +Zhihao Chen/jacklightChen (#425/#386), Rohan Arun, Dylan Crow (#370), Jacob +Sussman and the authors credited in the vendored source. See those notices for +exact upstream identities and detailed contributions. + +This new whole-owner replica allocation, deterministic coloring, serialization, +independent physical and arithmetic audits, composition and documentation were +prepared with substantial OpenAI Codex assistance. No Lean proof or unconditional +all-size multiplication theorem is claimed. Apache-2.0; original copyright, +license and AI disclosures are preserved. + +The frame-only retiming search, frozen map, fresh retimed orchestration and +independent frame-ledger audit are new OpenAI Codex-assisted work derived +from PR484 and frozen PR496 (00cf70efd6a8637531deafef698157ca83e249ee). +PR496's complete sources and all previous published heads remain frozen. +The new word uses recompiled Gaussian recipes; the vendored PR484 source files +remain byte-identical to their pinned originals. + +The derivative M8 necessity-test adapter changes only the choice of an +available invalid intermediate frame and its actual codimension charge. +It preserves the source checker and physical test, and requires all 14 +controls to be rejected. The original source suite still runs unchanged +on the original PR484 word. diff --git a/research/r489-pooled-retimed-complex/PROOF.md b/research/r489-pooled-retimed-complex/PROOF.md new file mode 100644 index 0000000000..902cba3da5 --- /dev/null +++ b/research/r489-pooled-retimed-complex/PROOF.md @@ -0,0 +1,141 @@ +# Common-frame retiming with whole-owner pooling + +This construction is conditional on the all-size compiler, common-label, +restored-row, precision/tape and analytic-transfer contracts retained by the +pinned PR493 bit and PR484 complex packages. It also retains PR484's explicit +Lemma A realization contract for paid residual wrappers with borrowed spectators. +Its Lemma G schedule/conjugation identities are checked on the serialized local +programs, with independent pre-operation integer bounds. Finite verification +alone does not establish the inherited all-size contracts. + +## Frame-only change + +A frozen map changes the common frames of 411 A gates and 504 B gates of +PR484's gauge80-kernel42 word. All 4,107 scalar payloads and their order are +unchanged. The first 531 A gates, all helper entrances, target levels, centre +frames, cuts and cleanup are fixed. Each register's frame path stays nested; +each scalar gate executes at one common frame for every participating register. + +The verifier starts from a newly reconstructed PR484 word, applies the frozen +map, and recompiles both emitted orientations. The independent frame reviewer +checks the actual GF(2) subspaces, the orthogonal tau43 raw-to-canonical map, +every event of both 25,082-event ledgers, per-register telescoping and all +private-centre lifetimes. The changed local paid profile is +`{1:2385,2:264,3:530,4:84,5:270,6:92,7:1,8:17}`. Its rank mass remains 6,884; +its 3,643 children redistribute that mass and improve the complete charged +moment. No scalar cost or dimension reduction is inferred merely from rank. + +All phase recipes are rebuilt for the changed transitions. The exhaustive +512-column normalization audit includes all used transition operators, gauge +compensations, centres and entering-helper chains. Both full physical +orientations are tested on 806 basis columns and eight dense dirty columns. +The exact all-800-column scalar audit and common-label proof supply the +universal scalar identity; the end-to-end samples alone are not a universal +physical proof. Integer bounds are established before int64 arithmetic, with +observed maxima of 14 bits for normalization and 29 for end-to-end replay. +The pinned source contracts remain the stated conditional interfaces. + +## Placement + +Retain PR496's pooled whole-owner placement. Entrances and helper residual +widths are fixed by the retiming, so all of its actual host charts and execution +windows remain valid. Use the newly compiled word and exact Gaussian recipes +in both orientations with the freshly verified entry/exit wrappers. There are 560 helper roles in each of +72 complete local invocations, indexed by nine stages and eight replicas. A +helper of entrance rank e has one residual of width 9-e. No residual is split. + +Pool the idle coordinates of all eight physical replicas. A frozen allocation +places every whole residual in a single pending idle child, and a frozen +bipartite edge coloring assigns that slot to its invocation replica. Left +vertices are physical families; right vertices are actual helpers. Each helper +has degree eight and every physical family has degree at most eight at the +stage. The eight matching colors give each invocation exactly one of every +helper and at most one helper on any family. The verifier reads every actual +role, rather than trusting existence of a coloring or the optimizer status. + +Every host is an idle pair at that stage. Thus no host is an active data wire, +even if its physical replica differs from its invocation replica. The literal +loop order is retained: recipe phase, replica, cover class, complete local +invocation. Entry wrapper, local word and exit wrapper all finish before the +next replica or cover class. This is necessary when spectators are borrowed +from coordinates that another invocation later uses. + +## Actual maps and restoration + +For each physical port q, take the pinned orthogonal 73-column basis B_q. A +helper's first w columns are precisely its pending residual coordinates. Its +next 9-w columns are the canonical unused spectator coordinates. Append every +remaining B_q column in increasing basis-index order. The resulting full +matrix is an orthogonal coordinate permutation of B_q, with inverse its +transpose. Both reflected local programs use this same whole-family chart. + +The fresh retimed local check establishes the normalized helper action +L_E^-1 S_E R_E^-1 = C_[w] tensor I on all 512 local address columns, including +spectators, with all global phases. Its emitted scalar word restores arbitrary +dirty helper inputs and its private work. Unique physical owners within a +complete invocation let the scalar/common-label identity be transported through +these full charts without aliasing. Because that invocation restores the +borrowed work before the next, reusing the physical family in a later replica +is allowed under the same whole-invocation realization contract. + +Across all calls, occupied cells of each pending idle child are disjoint. The +explicit remainder child uses that family's actual replica, starts at the +recorded pending offset, and executes once. The old `replicas=8` shorthand is +not applied to these heterogeneous remainders. The independent controller audit +checks these cells, execution windows, full charts, source-program hashes, +private-family rebase and cover correction. Deliberately corrupted programs +must fail the controller audit. + +## Paid profile and finite charge + +All 40,320 whole residuals fit on the 7,680 existing data families. There are no +bank families. The physical stock is 8,258, including unchanged private centres, +reserved tableau and two coefficient registers. The complete paid profile is + +``` +rank 1 2 3 4 5 6 7 8 +count 172056 19008 42032 6048 22496 6624 1800 4120 +``` + +Its rank mass is 558,144, and 73*7680 - 558144 = 2496. Both exact moment engines +include the inherited bad-cover fallback. The complete invoice counts freshly recomputed +local primitives, wrappers and selectors, and rebases stock, private families, +idle remainders, routing and final correction to the actual emitted program. +The exact complex lower endpoint is +`1345325487149526878087/10^24`; both rational engines reject the next grid +point. The strict outer assembly yields `κ = 1343518018117309/10^18`. +No new factor is hidden in a cached coefficient. For the global prefix, use +maximum stream L2 norm over every physical family and cover class. Each +completed helper endpoint is unitary; each completed data shear or bridge has +at most two unitary summands. For each actual orthogonal chart, right +multiplication permutes the cover classes, so an active stream is visited once +per complete call sweep. The bound uses all 72 ordered call sweeps and nine +bridges, without assuming replica independence. The local scalar/Horner envelope +costs 20 bits; conversion from the initial supremum norm to L2 on 2^73 entries +costs 37 bits; four bits cover primitive arithmetic. Thus 142 bits suffice, +within the retained 192-bit allowance. The verifier checks the actual matrices, +complete-call endpoints, scalar envelope and controller premises used here. Each remainder is at most +rank eight, so the degree-two halving inequality is 73^2 > 2*8^2. + +The bit side is reconstructed from PR493 with real Boost. Its physical prefix, +charged three-level coefficient and row coefficient are read from the fresh +receipt. Six bootstrap levels and all 47 strict outer inequalities use the +fresh complex exponent, common row allowance, and C0=2^210000. The next grid +point and zero-eta, zero-beta and unit-beta controls must all fail. + +## Provenance and limits + +The selections are finite nominations, not optimality theorems. Frame discovery +used common-frame component moves, including zero-cost moves before descent; +the final 1,500-move continuation plateau does not prove local or global +optimality. The exact verifier applies only the frozen map. The inherited +whole-owner allocation search used +floating-point MILP objectives and matching only to propose the frozen map; +certification uses the actual scalar words, complete emitted role map, exact +integer/rational checks and fresh source replays. The earlier unpooled padding +experiment is retained as provenance, not a separately published record. + +This does not use the cross-family split of PR448/480/494. Those submissions +carry a distinct disputed operator interface. This package makes a conditional +whole-owner claim only and does not claim the largest number among all draft +submissions under different assumptions. diff --git a/research/r489-pooled-retimed-complex/README.md b/research/r489-pooled-retimed-complex/README.md new file mode 100644 index 0000000000..35454e3407 --- /dev/null +++ b/research/r489-pooled-retimed-complex/README.md @@ -0,0 +1,60 @@ +# Conditional κ = 0.001343518018117309 + +This finite construction combines the pinned PR493 R489 bit word with a +frame-only retiming of PR484's gauge/kernel complex word and PR496's pooled +whole-owner placement. The 4,107 scalar gates keep their payloads and order; +411 A frames and 504 B frames change. Fixed entrances, centres, boundaries +and cleanup remain exact. Every helper residual occupies one physical family, +each invocation has 800 distinct owners, and no bank families are needed. + +The exact complex saving is +`b = 1345325487149526878087/10^24`; the bit saving is +`c = 391360506745414227149/250000000000000000000000`. +The resulting bound is +`κ = 1343518018117309/10^18 = 0.001343518018117309`. +It improves the frozen whole-owner PR496 result by about 0.859%. +The larger draft PR494 number uses the disputed cross-family split of PR448 +and is not a comparison within this package's whole-owner scope. + +Run from the committed repository package: + +```sh +python3 -B research/r489-pooled-retimed-complex/verify.py /absolute/fresh/output \ + --boost-include /path/to/boost/headers +``` + +Requirements: Python 3.14, NumPy, SymPy, Bash, a C++17 compiler and genuine +Boost headers (`boost/multiprecision/cpp_int.hpp`). The release replays use +Python 3.14; inherited source receipts compare gzip byte hashes, so other +Python minor versions are not covered by this release. Search additionally used SciPy, but verification performs no +optimization and needs no network. + +The verifier reconstructs both pinned suppliers in full, applies the frozen +retiming map to the fresh word, rebuilds all changed scalar programs and exact +Gaussian recipes with the unchanged upstream tools, then rebuilds the +serialized owner map, audits both reflected local programs and arbitrary dirty +restoration, checks all actual whole-family matrices and spectators, checks +complete idle remainders and mutation controls, and independently recomputes +the complete paid profiles, finite invoices, six bootstrap cutoffs and all 47 +strict inequalities. Guarded exact simulations bound expanding integer +operations before they execute. Source files are checked before and after the +run; each subprocess exit is recorded. `EXACT-MATH.json` contains reproducible +mathematical results; runtime-dependent source/template hashes are bound +separately in each run's receipts. + +`PROOF.md` gives the retiming, placement and serial execution argument. +The independent frame reviewer checks both 25,082-event ledgers, all fixed +scalar payloads, raw-to-canonical orthogonality and 12 targeted rejection +controls. Fresh source mutation suites and all 14 Lemma G necessity controls also run. +A derivative adapter nominates an available nonnested frame for control M8; +its two transition ranks are recomputed, preserving the same total charge. +All other source mutation code and the pinned source files stay unchanged. +`SOURCE.json` pins all 266 original supplier files. `MANIFEST.json` binds this +entire package. `EXPECTED.json` fixes the exact result. `NOTICE.md` preserves +provenance and AI disclosures. The original bit/complex packages and previously +published PRs are unchanged. + +This remains conditional on the inherited all-size compiler, mutable-basis and +common-label interfaces, PR484's Lemma A realization, restored-row, +precision/tape and analytic-transfer contracts. It is a finite construction +with exact checks, not an unconditional multiplication theorem or Lean proof. diff --git a/research/r489-pooled-retimed-complex/SOURCE.json b/research/r489-pooled-retimed-complex/SOURCE.json new file mode 100644 index 0000000000..3a82c7659f --- /dev/null +++ b/research/r489-pooled-retimed-complex/SOURCE.json @@ -0,0 +1,285 @@ +{ + "bit": { + "pr": 493, + "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7", + "manifest_sha256": "7f25c41d0400ef5adf763eae6e166003a9b59e5a655b860c04b052f6731c7297" + }, + "complex": { + "pr": 484, + "head": "035845ce95f31d0a2dcfb42b8c8e13411271fa5f", + "manifest_sha256": "56199b350a49a6d9c114eec1620e889eedb89170af2b872bf8b8f42df8a961a2" + }, + "files": { + "vendor/bit/MANIFEST.sha256": "7f25c41d0400ef5adf763eae6e166003a9b59e5a655b860c04b052f6731c7297", + "vendor/bit/SOURCE-pr436.json": "4a4f99f5bdb7530a0dcf9433f7f02afbf2abf908e718f7c63ffa5503d4f49693", + "vendor/bit/EXPECTED.json": "3494ba83280cc86548fe0cc6695c50d23e6b6ffca85aeb1a33337c1196e280cb", + "vendor/bit/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/bit/requirements.txt": "6023d480f929cdfa4e2f35e361eea003451cd6695af806935a32038b0115abb5", + "vendor/bit/SOURCE-pr483.json": "24e3eab4a985e115adb7f8665a401423e9636e9f16cc4373ec68cc86950445a8", + "vendor/bit/SOURCE-pr381.json": "16b1977240ca9acb58fa64572fb4231a423bc10bbf3e7bb30f1c8201fe369ba5", + "vendor/bit/SOURCE-pr471.json": "499d861e090c9e646d978dd67890a8e58a9ff6bf08512684e66605179132076b", + "vendor/bit/SOURCE-pr386.json": "87c659ba932525631a40be14dca28a6a2efade8641f23bb08d6e1567fc991131", + "vendor/bit/SOURCE-pr451.json": "a639956eec858341987a815b7464ef472505300db754b5f9ac012dd01d18c8df", + "vendor/bit/verify.sh": "0f9248aa3611dfe2b5d59dbe992c6f7d21a0cc4f1de2b5ed05a6110191191224", + "vendor/bit/SOURCE-pr484.json": "b92f43fbcba3921a1aa37bcb9f05cf5fa612ff708785e05512438a6317bf0867", + "vendor/bit/README.md": "e5212e8058c92a2b02cc12b4e174a65ce1cef7b4d7977ae770e64f5ff91b7204", + "vendor/bit/SOURCE-pr473.json": "2515c4f23dfa22a21913d92597669770f7f44c2a5b3ef069ef68a0c89779a656", + "vendor/bit/SOURCE-pr445.json": "e6f4a272442bb71ef68aaa3545b271236f9c99297e444fa01c62b0b5fb6a170f", + "vendor/bit/SOURCE-pr448.json": "c771fa9be492408a78d6d970c839e68c4dfd1b66f4f4a4748e3d12726a43cf27", + "vendor/bit/SOURCE-pr370.json": "03de1d341196cfa8cf1d39f3cc8648b25bb5f39c3c602a728cfbd089e8253ac0", + "vendor/bit/SOURCE-pr472.json": "6753bcf50c91806b75dd4dbe3963a79699a614d0dab8ce32b261cc3e76b288b1", + "vendor/bit/SOURCE-pr458.json": "cbdea984a46ab5de354b95e73fd76c1918fdc6676c658398a552772c4dc3dcaf", + "vendor/bit/NOTICE.md": "5f4b7fcbf99f572be28b6da612ce775363908cdfc7810f7aca167be01c86e49a", + "vendor/bit/SOURCE-pr478.json": "9c7c4ea678865a955b0c89f0952927159976fdf55cadc6a488dec5757f03fe7d", + "vendor/bit/portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99", + "vendor/bit/discovery/plan.py": "40e8dea1b4b71c5afd5993625f57bcac089dd2f72dfbc4dbc23ce917e5a61010", + "vendor/bit/discovery/README.md": "b09aa45d5651720e10326cde559c863ba3ea45fe2fb6b4aaa3bfaa66a8fcf69f", + "vendor/bit/discovery/d4part.py": "a64927c340a4772ce0682b349e0c90c80d1a766000ccf397fb41b36a31929179", + "vendor/bit/discovery/host_select.py": "2aaaac18e083d289d4341e734c32571c89c51fefba04b388d407c7372b906dc7", + "vendor/bit/code/cited.py": "a4c2dd4755f2a45ceda327b36d9ee400c2804893000626ca8ff3f6ee296fd842", + "vendor/bit/code/provenance.py": "e28fd87d0e34a6f6f6f1fddb6c4891deac220662c954de855d7aa5a7f9cceca4", + "vendor/bit/code/bit/mutate_records.py": "b0e75d6550412a7be4017695e6b237392b611bb852ad8ff309d6682c9f166a4e", + "vendor/bit/code/bit/mutate_records_mut.py": "a9e085ec60d5657cd5d77832e3d95004e81b9f4f249d9e0fc95e345366cb2d2e", + "vendor/bit/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/bit/code/bit/checkers/gram_frames.py": "223a5a07731fc315a90a3e48177796babc155c1d9985c7ae5017eff6af2a0608", + "vendor/bit/code/bit/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "vendor/bit/code/bit/checkers/legality_h.cpp": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3", + "vendor/bit/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "vendor/bit/code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "vendor/bit/code/bit/independent/mutate_mut.py": "3b002c19a5dcca76a5594f2a30fac7c01d2b45fc96b3e7cfbfd8b720f5ffb4e8", + "vendor/bit/code/bit/independent/interface.py": "2c63a039f97e3a11ce5a6b83302d4f5beda160c1db14164a5a9b0855aeb19d3c", + "vendor/bit/code/bit/independent/mutate.py": "0ff65aace5da4b57d96235bf830f8f11969322e75134d498aeb70e9753ec6b0d", + "vendor/bit/code/bit/independent/relax.py": "d6e9f58de3fa41f538516b6227c249d61fb30f0f6843027cc8a07a1a372fa6b6", + "vendor/bit/code/bit/independent/checkword.py": "11bf9620ca9db16d52d9fe806b814fc9ec9a89c4d7645354d1861d96f6e805ad", + "vendor/bit/code/bit/regression/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "vendor/bit/code/eleven/audit.py": "5ad832830c19ec6c904d1b64480f6b1e71c5673fdd38d487d17e179b1d197c09", + "vendor/bit/code/eleven/local_audit.py": "95275473d7f9811011bda760dd0f04de5169c2a6922456dc9a5725a5d671f941", + "vendor/bit/code/eleven/assemble.py": "c47889a606701ae592374dd82a13cee8c5a4e8449b7facfdad2d90563a30a18c", + "vendor/bit/code/eleven/adapt.py": "d8a8c13b484d985f0133a5d06de4a78b8477314f922b9f693ba73640b7184d6b", + "vendor/bit/code/eleven/emit.py": "b0b25955875625ed63f82690f83aef976e3e9a978ae6620b23a23fc1207acd46", + "vendor/bit/code/skeleton/gen.py": "7cdcf48078ed4beacd2e240aa8145e4aa6984558748d07659cb1b252786e073a", + "vendor/bit/code/skeleton/geom.py": "bb356568fa05e7bfd5fcd9012903611cf742729a99b4dc3a13685355b2678ae3", + "vendor/bit/code/skeleton/e8.py": "721d859a6517d665ca84d03ef89668da3aae7433ffb0ee47faf37f2aeb85450e", + "vendor/bit/code/skeleton/wordkit.py": "2b6c12d96f24a4e81f2c807827c2b74cf80037367fc8034e8c871dd5ce008351", + "vendor/bit/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "vendor/bit/code/pricing/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/bit/code/pricing/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/bit/code/pricing/prime_witnesses.py": "98cd03bc9582e7bd0ab194c191ea8eea940539e510051443ab9fd3e572a364ab", + "vendor/bit/code/pricing/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/bit/code/hub/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/audit.py": "d28062127a9b0d3866a3b79aad98a307233b20ebdb94cfb9f197d726b82ffea5", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/local_audit.py": "23eda3fe3d774e7f2dbf4dbdd4ff90d69ae7d1762ff95c8629cdc7667aa3fe71", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/assemble.py": "abb60c35e448e0f94073f38a0352d11249aaf7bb8dbd7352414ae60a1d2b79c3", + "vendor/bit/code/hub/e8-r715-whole-hosted/code/emit.py": "98d77cefbc3a76f9f10bd7df3a2590ab88b411f6afe77b5f8d73f1602eb2bef3", + "vendor/bit/code/hub/e8-r715-whole-hosted/data/hosting.json": "765382d4fefd594e94c8c5826ec6300422ce9f79c816d7f7323ef85e99320f28", + "vendor/bit/code/hub/e8-r715-whole-hosted/data/word.json.gz": "b2af02f593cd161bea64e6cd793508386914136be519f80726c071697379d5a9", + "vendor/bit/code/hub/e8-r715-whole-hosted/data/residual-isometries.json": "750221cc66badd0ed0a74e7aad2d59f91f89c107370af21c6d929fbdd4a08a9f", + "vendor/bit/code/hub/r740-hosted-rank149/code/emit.py": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4", + "vendor/bit/code/hub/r740-hosted-rank149/data/word.json.gz": "41626789888ee070e1b435fa380b10ab9b88e3cf7d8d8e166ecef17269bbcf47", + "vendor/bit/code/hub/r740-hosted-rank149/data/residual-isometries.json": "b23fda74a7979179e8fd83ee9870c1e232442cc90c05077adaabfe31d050d1e4", + "vendor/bit/code/hub/r740-hosted-rank149/data/selection.json": "4d9c2cf6a3d31a6faa287731e0721cb16601b0bc5c1a186b9645bfb5760ce8db", + "vendor/bit/code/hub/e8-r740-replica32/code/e8core.py": "1cb286196c1530d06f50f0997febc5993b388f33464e295611b920ba30a24eeb", + "vendor/bit/code/hub/e8-r740-replica32/code/bank_routes.py": "7c6997c455bd55acca3a1603797c34e7733d557c27a7694a1429ff15773a505d", + "vendor/bit/code/hub/e8-r740-replica32/code/tile_m.py": "d6ae4a556472d403773cd2117c992bfc10e1187112da1b3893f3fae628a131dd", + "vendor/bit/code/hub/e8-r740-replica32/code/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/bit/code/hub/e8-r740-replica32/code/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/bit/code/hub/e8-r740-replica32/code/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/bit/code/hub/e8-r740-replica32/data/word.json.gz": "d8d6d3d3f336720302bc40b3c1504fe3c3583a7a8d707bb9bd7b21f85e5e69c6", + "vendor/bit/code/hub/e8-r740-replica32/data/residual-isometries.json": "e12ed7ddd13cee101ba74a083b54665fd64d0b122b0bad5b83d817dcc8bae9d8", + "vendor/bit/code/hub/r740-hosted-eleven/code/geometry.py": "9554182d67e434ea84b4430f909a2c400abc755d8487b51454a8e6968e62859d", + "vendor/bit/code/hub/r740-hosted-eleven/code/emit.py": "ac63ee481f3d75cb9f0658faaa2412db81d55bc44d9f1ff1c0329ce1e75aa0d4", + "vendor/bit/code/hub/r740-hosted-eleven/code/row_bound.py": "de4a9b9cd797e1a05da56f62cfe725c8728cea3a4aa031b7d1b0a68f869760d6", + "vendor/bit/code/hub/r740-hosted-eleven/data/selection.json": "52dbbb68e8c147690d15eaa1d952df05d074b0c121885a4159d9f6732f391872", + "vendor/bit/data/complex-b.json": "dce3f4b76aa3f6c3ba826ce556ffa61398b33e81e4d1a226dd2a36ce684fb02e", + "vendor/bit/data/bit/bitE8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "vendor/bit/data/bit/bitE8mut-r489.json.gz": "835eb96e147740fc7454f8cfb3dbd34ae89524b1dbd89a61e9288eae8ab6a5b9", + "vendor/bit/data/eleven/hosting.json": "61f790657c465d16d3455f48f90f816797b9ea08bf02dbd0c90d2cf41836257e", + "vendor/bit/data/eleven/residual-isometries.json": "0fa5b353a0321af2ce4e2045db1d4c2d6418a11663894e2afcdb1eaa1984bddc", + "vendor/bit/data/complex/pr458/EXPECTED.json": "a4312cb0c53c2066a28b683a971a41e7d76c5f6d828a96481c3ae7b3c01bb2f3", + "vendor/bit/data/complex/pr473/EXPECTED.json": "70e515f0a5a2f9508cd030d35a99f90981a6eccc027c9ad5a3c77f5860310910", + "vendor/bit/data/complex/pr484/EXPECTED.json": "0c93018a23bc573c7d155d4786e0c3978e95be0fda974076697939a1a1d8e5be", + "vendor/bit/data/complex/pr483/EXPECTED.json": "799fa4ab2f785c478c3cdcb6c1c0428a5ce6e3ddbe4a4b2fd88630d811a593f6", + "vendor/bit/data/complex/pr448/EXPECTED.json": "18b42250c3faf6f0df76fcab6c3a483582192ad7bb09cb1985f4b0bb91d67024", + "vendor/bit/data/complex/pr478/EXPECTED.json": "07bd05d14c71df8925b0b03510b2b337334b73ac425a94e03b2ec34ed2680164", + "vendor/bit/data/complex/pr471/EXPECTED.json": "188f9d1a7450496dbfd8d64381febd20b0597141537eb1a003435297df2d1720", + "vendor/bit/data/skeleton/d4part-pairs.json": "d69ffe3326140bc541b8f1639e02db43a5835ab8ca02cc742b5bee2bf2ef1ba9", + "vendor/bit/data/skeleton/plan-skB.json": "f6162bb4d8092bc233700fa7ebc6a0d79f2893135aee18e998369044abb3f44b", + "vendor/complex/idle-axis-hosting/PROOF.md": "cfe34bf0b64259661312dae22c3a23adc5bf6f6326951eee5c1488ccfc347542", + "vendor/complex/idle-axis-hosting/audit.py": "38594423a401110bd430b734037c6ecba422ee6a94d71709984e0afa9cd1edf8", + "vendor/complex/idle-axis-hosting/EXPECTED.json": "ed83c1bf1ca2d01eaab5149a34520806a07ef375dfa9e3ed69d123f4be4c9960", + "vendor/complex/idle-axis-hosting/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/idle-axis-hosting/complex_hosted.py": "829c5c4f4bdfccedadd31505f1f0a394f7a208d1446b7bbf9cc92d3aa1530c0c", + "vendor/complex/idle-axis-hosting/bit_hosted.py": "6dfbf26213e8adf87563b3575cfb722bd07ecd65627f056b3293411dd3d89a61", + "vendor/complex/idle-axis-hosting/assemble.py": "f9a2e6a42aadcf971702a5a867760a092566ed03356f4f34387d38f4093ad1a6", + "vendor/complex/idle-axis-hosting/README.md": "1151f74cad54ac4937282b7a8b5d1108ed4ce35944ef9b7bb7d17abfce1fe4a0", + "vendor/complex/idle-axis-hosting/hosting_core.py": "d8b90cd5d152df3c7c351230863d9e61816ad5e1f21d69bea1a86a5daad559a3", + "vendor/complex/idle-axis-hosting/MANIFEST.json": "f68b82604363329618529313ac9c3796dc1e88b176eaee4a7b0dec9be428e987", + "vendor/complex/idle-axis-hosting/SELECTION.json": "315d54be472842707cce879618be477d8b897050e873bc136d114eec6a232f97", + "vendor/complex/idle-axis-hosting/verify.py": "737a974d79fdd232b6c4b9e059c56835079971447342ed7ca3b82a614e30cb53", + "vendor/complex/idle-axis-hosting/NOTICE.md": "027a868628d0408602dbeae688b031ed9b4abfd6e5401f6e8106a3eb25ebc4ca", + "vendor/complex/e8-early-reset-reuse/PROOF.md": "09388e2f9e6b8fcc626a5172d55c45a957835075c51c68d1e86fd42ff4655ae8", + "vendor/complex/e8-early-reset-reuse/EXPECTED.json": "5521c7e995fec77941243b28e090f95f2188f193d5f61275275cfa11215eecc0", + "vendor/complex/e8-early-reset-reuse/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/e8-early-reset-reuse/SOURCE.json": "c52287239c43aece2b3533ef48ee204d845d652066bca716c288b0c47e779521", + "vendor/complex/e8-early-reset-reuse/bit_global.py": "9c2178df133dc663416aac13d8c8da80a9e4f5f7174bb36413180fcbad994ffb", + "vendor/complex/e8-early-reset-reuse/bit_audit.py": "219eb4dd8e5380fb0432daa6a30c265755a78834616b2c5fc7aa161feb0231ee", + "vendor/complex/e8-early-reset-reuse/README.md": "442bf686c0b24b9d7781b7b138f32fddea5d4efffeddc6e41d04719d2545e0cd", + "vendor/complex/e8-early-reset-reuse/replay.py": "e0782ba05dda36323500390349d1180f6117a9c6112b09b9e21e29f67c4e5f5f", + "vendor/complex/e8-early-reset-reuse/VALIDATION.json": "bcb864a6b73d4ff4a24ab70ad51287653723c2115ce1c81db7817b81df2d9e92", + "vendor/complex/e8-early-reset-reuse/MANIFEST.json": "4d23bafa43634a59e25f875333408b67cbecb1c912929824b5d45dea4de51da7", + "vendor/complex/e8-early-reset-reuse/SELECTION.json": "9d47ade3fb69b3ef62a1a3ae75cebdddd57d144923977c5f2a07848ab596ea32", + "vendor/complex/e8-early-reset-reuse/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "vendor/complex/e8-early-reset-reuse/verify.py": "4e2082878acc1298f4354325b28f3cf047006170a9883148e7cf23002f6f02f1", + "vendor/complex/e8-early-reset-reuse/NOTICE.md": "c4085541471fe63d8f735beacd397d356446376ad3e56b2673940a2df3b8437e", + "vendor/complex/e8-early-reset-reuse/combined.py": "dc621dce9ac1634a2701318311b30dffee7cce7e0c6be7ae808f44b27eb17f0f", + "vendor/complex/e8-early-reset-reuse/local-evidence/PYTHON311-GZIP-FAILURE.log": "ec1937c575536aeebe8f9c22d673fd66d1355ff870e2fdc80346205b29e42784", + "vendor/complex/e8-early-reset-reuse/local-evidence/ASSEMBLY.json": "c9ce28f59a5e460d39a888bbbc464e3fd6dd1c0b2c54ae86baeeea99febc8176", + "vendor/complex/e8-early-reset-reuse/local-evidence/FULL-PORTABLE-PYTHON311.json": "1dcca855b20cbac311a435f23f60001c342083edbef3194ba42a30e1f24c1982", + "vendor/complex/e8-early-reset-reuse/local-evidence/PYTHON311-INITIAL-FAILURE.json": "7902e8ca1e167b98d1c29170f8d57c9896b38ccab89065e4ed4e2c3feea79076", + "vendor/complex/e8-early-reset-reuse/local-evidence/BIT-AUDIT.json": "2e458c3936e42539095610a50c730266dddd96e94d1ead171a99dd5f1fe9ef47", + "vendor/complex/e8-early-reset-reuse/local-evidence/BIT-GLOBAL.json": "39f89d1e5bf51e9b1f1155e123dc3226627e465a246d37bb00f55d44d20bcaa0", + "vendor/complex/e8-early-reset-reuse/local-evidence/FULL-PYTHON314-INITIAL.json": "0966528d4b30459d8b35296f31dbadfa34cdc7792419b34ab2505b7098923325", + "vendor/complex/e8-early-reset-reuse/local-evidence/FULL-PORTABLE-PYTHON314.json": "5687ed9209e11e64304d008a4a10678dc07cdc3522f5112c9a80557d45125c4a", + "vendor/complex/e8-early-reset-reuse/local-evidence/BIT-PRICE.json": "96ec606146b5157871048e28f6649c31c1b6117d43be732e6a96bcc269c0e1b6", + "vendor/complex/e8-early-reset-reuse/local-evidence/PARENT-FULL-REPLAY.json": "0ba447d6de6edd9fbe2371c36e3605dffa0c6526a874cfcb9bd19285c056bf1e", + "vendor/complex/e8-early-reset-reuse/local-evidence/FAILED-LATE-RESET.json": "f6ed36b59de745d50f37fcb4c80d129d9a2de0dfe1fe3de2d18e678135f7d9b6", + "vendor/complex/e8-early-reset-reuse/local-evidence/FAILED-INLINING.json": "95cbb0e6df953d25a888198c1072edf03db85b7c967a234680db3e095abd2dc7", + "vendor/complex/e8-complex-gauge-kernel/PROOF.md": "a6bf0662abdd9bbe0649b52cada82c3341e61b49b966b93aa6f8f1ab30d2d949", + "vendor/complex/e8-complex-gauge-kernel/EXPECTED.json": "0c93018a23bc573c7d155d4786e0c3978e95be0fda974076697939a1a1d8e5be", + "vendor/complex/e8-complex-gauge-kernel/SOURCE.json": "ee6dca44a773d457b9e0bbfc8d3d5f571673913686fa57187e63a84857ff505e", + "vendor/complex/e8-complex-gauge-kernel/PR-BODY.md": "839708cb1f21d34f7ecf8d9edc5c9ec800b747d92c99e384e0bc246211bd01a1", + "vendor/complex/e8-complex-gauge-kernel/README.md": "64bebef404af500d4f32e3cb17ba143a53c7f251712246e1b85a6887b2d444bc", + "vendor/complex/e8-complex-gauge-kernel/MANIFEST.json": "56199b350a49a6d9c114eec1620e889eedb89170af2b872bf8b8f42df8a961a2", + "vendor/complex/e8-complex-gauge-kernel/verify.py": "56a36950ed486a1b38334e8d75fd1efe75da7ba604fb4fafe7d8dc1e388349c5", + "vendor/complex/e8-complex-gauge-kernel/NOTICE.md": "7c7a022afe969a09ad5320935daf7db256b8f25ee56ecdcf9fc40eb0836e74ce", + "vendor/complex/e8-complex-gauge-kernel/code/controls_pipeline.py": "cc6fb8bf4644cc3a1799f3bc90dc074adb5663d1889c92f7f73ec9f307acbd36", + "vendor/complex/e8-complex-gauge-kernel/code/controls_hosting.py": "573966c7ad1deac24464414d3886171f594bb3ae3e7236a9ac2447cc40b20211", + "vendor/complex/e8-complex-gauge-kernel/code/gk_word.py": "f027a9273bcf4e0971258c160b7d3b3c196366b32a529cff6e6a0e666b03826b", + "vendor/complex/e8-complex-gauge-kernel/code/gk_common.py": "e68d190fd436b2f3955decb590adb53344d5d4ea0a19d62d86df1e4b55ecd198", + "vendor/complex/e8-complex-gauge-kernel/code/hosted_gk.py": "8d2c29a5f79e6a1391f96baf44dd9fbe35203b6c11b02a7b2d238cf792ea163f", + "vendor/complex/e8-complex-gauge-kernel/code/emit_gk.py": "4e415bff1d9f154496ed38e6889929b600aa0f3d583a375e8ca257ad8f51fa23", + "vendor/complex/e8-complex-gauge-kernel/code/controls_gk.py": "cf83aa95f03aa812c413905df9f75f13ac8f92f5db6a83cf9b1868aea2dd9de0", + "vendor/complex/e8-complex-gauge-kernel/code/controls_sel.py": "d2777571d59736c3fe62b81506ae62c22a3816fbc3abf9303d914e6da6d64258", + "vendor/complex/e8-complex-gauge-kernel/code/audit_gk.py": "cb79c6b788333a031e14c7f134823f5f6147d7f1dcc6e5e3b1420743c32f8ebc", + "vendor/complex/e8-complex-gauge-kernel/code/onehost_gk.py": "416b318c1b6b8c7b72e24713b1b18d8772ec368e042a321b4418c63a74711590", + "vendor/complex/e8-complex-gauge-kernel/code/make_meta.py": "06e44ae4fc4f3a88989828d6cbdf95524a2d9f65753045cbb3e6cfd7e042d96a", + "vendor/complex/e8-complex-gauge-kernel/code/integrate_gk.py": "2e807893180a3716b36a81f1a7d933bd55f2299489b6f236ba5c644d87739209", + "vendor/complex/e8-complex-gauge-kernel/code/audit_hosted_gk.py": "c46c69c1c6fdccce991bf5d5ec7def344d2749c53ad2db976a50ba3a6c37d657", + "vendor/complex/e8-complex-gauge-kernel/code/replay_gk.py": "2422b44fc2fb4742bb575572337158a15fb6831630f8746a1c7ee3133e0ee2e3", + "vendor/complex/e8-complex-gauge-kernel/code/adapters_gk.py": "a8d6d9ccf20c261cb0b216baa9906f2f7689e1bb1dca070313a60b2cb6d3043c", + "vendor/complex/e8-complex-gauge-kernel/code/run_variant.py": "feecf7dff32860a02fbfb96da1049ba35d05b3baf74c4f741b878d4d91903903", + "vendor/complex/e8-complex-gauge-kernel/code/assemble_gk.py": "e377ef9d9e90168290a4640250c0fb9c05015104bcc4827bc5ce63f6ca63763a", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_phys.py": "0ca37829b596d83d0b94c5f0b6b278a100f22e626b2ab3b5210a38f9657c8a27", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/check.py": "f572b7129a546e1b1193fdd5baee4f731a5b9b8a4e8dc7ac170bcad7758e5b9a", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_mutants.py": "cf0d1f8e90a0780244b6de38d6aad08dd42f4c439397a6d5a61fccd23fe7e798", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_lib.py": "00068882bf2f2ebadd3f87c94204f226c7938966124bafb9ce6da89bfaf91b45", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/gd.py": "64cdb2cfefc9ec3ed80c277a18848778427c3d3dbda9b7be13f740522478e1de", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_e2e.py": "8fe3719e8ec5ec49af480b40c15f07612a356f5071ea30e17ae2d8931b3f20ce", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/run_labels.py": "5f053e553b1c26e553a844e2891a73b6cc6b79404a7bb5d4722529f7db0d592c", + "vendor/complex/e8-complex-gauge-kernel/code/lemmaG/lg_instances.py": "47dcf2e9ae2d99699424d684abebc3d1d2d25b7aa6d440761e19835d140f5fbb", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge4.py": "e4e438034a3cd4c49adc744de86819dc574b130fb8bc8dc48b1d9955a3601a42", + "vendor/complex/e8-complex-gauge-kernel/provenance/sa_long.py": "e2270814c0ff0617b1104a007e4604ac713dbb1a033771d4a5357796198e646e", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge.py": "a0fbf14085161f89d52343de80cddc8a11451bac635bc2677549ae7a26562491", + "vendor/complex/e8-complex-gauge-kernel/provenance/cxcheck.py": "1df8db02ad02e8f1cf0bbaabd92d7d88341f8e10f0e76d7777d246eb52094ac8", + "vendor/complex/e8-complex-gauge-kernel/provenance/iso1.py": "1a7e3e08b0ecb9cdf19525ef23c5f790cf19427e238e71987a30c35aa54d9612", + "vendor/complex/e8-complex-gauge-kernel/provenance/kcap.py": "96e4e067d850f1b3b5cdf241371956a99fe4f60229edd3fe43b3f7d14ae78bea", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern4.py": "0a21980027d427a6377a525d7082e460eed9e8577328831e2edde7eede1998dc", + "vendor/complex/e8-complex-gauge-kernel/provenance/hostmodel.py": "1fe732f944166dca53363d63b0bc2a5c4ceaf0ffdb8973f554720be07bf07395", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern5.py": "bb0bbf4504f714d5d14c362d90c0d66c85c912e5b2f19c7401040e967c8a3c0c", + "vendor/complex/e8-complex-gauge-kernel/provenance/README.md": "76f04346717183300ec2d3bf852d5bacc8a6c3dee458a17a1957613ddf033af0", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern2.py": "62c02a73484f0b513c2d7bd4bdd9febf1c84bf42457506a36bab30b97b267efc", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern.py": "bdc708e887bda780b3145e2f536db9ace13cae165447c6057bb8b3476f8f1dc0", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern6.py": "849c7e9404edb5bb2d2064339014d6bbfd7bcb0ab62a4ca09d7d2c658dcd14c6", + "vendor/complex/e8-complex-gauge-kernel/provenance/cxlab.py": "46dd697395d69776eaefa7d5843ada050528d76832967c76afa2e80beb7d75ee", + "vendor/complex/e8-complex-gauge-kernel/provenance/kern3.py": "e31d8b9728881d7921c404e55b875e6f8cea46a0c9fc6eea8263416cc6fba109", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge2.py": "3dda541e514944fc6486407a889ac6a0f3b1eeab08092799dec672a89cbcbcb8", + "vendor/complex/e8-complex-gauge-kernel/provenance/gauge3.py": "fb74644f093f8a725af146b560380b360dc655edde61c7695d1a2d9b33fc58fc", + "vendor/complex/e8-complex-gauge-kernel/data/bit-suppliers-pinned.json": "77121915641c8fef57ab10585fd5e8b13c817356bbbea21f4314d381cd029b83", + "vendor/complex/e8-complex-gauge-kernel/data/SELECTION.json": "89b19daca7db07a7e09723b1b74b55682ae64af98072dbb3110d0376b7f052b2", + "vendor/complex/e8-complex-gauge-kernel/data/selections/gauge80-kernel42.json": "436e4acadee227dbfcb66386c9ccaa38e68054e8ed4870bb174eeb41363375bb", + "vendor/complex/e8-complex-gauge-kernel/data/selections/empty.json": "44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a", + "vendor/complex/e8-complex-gauge-kernel/data/selections/gauge80.json": "41e62cfd0d50f348eae3f81d9f62f7dab2667294554398d8bca43aadbb2c291b", + "vendor/complex/e8-complex-gauge-kernel/data/selections/kernel79.json": "febded05174c364049632db3214dc9209426d1b81581cab728d79fa6594c9e47", + "vendor/complex/split-centres-global/SOURCES.json": "11aa666d678fed084b01d1e8e47239e1674eaedbc6fe0cee7edb2753477af9be", + "vendor/complex/split-centres-global/PROOF.md": "6983e75f29af6eeaab20a30b08307ec6fab75ccb8b10291df8f9eb04d497f894", + "vendor/complex/split-centres-global/EXPECTED.json": "9b8e56eee3d5bdabd2e3e6e4ba0d9eba537525fba25a54126f9f0e41d2491a06", + "vendor/complex/split-centres-global/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/split-centres-global/README.md": "b432292594adf2fcba2a8ddd87eda6167c76ff055e85aa5e3e2af7dd7e0f976e", + "vendor/complex/split-centres-global/CERTIFICATE.json": "f71580f22193726fb582eae604807ff70a7302265e001d9484a718e63bbe14c4", + "vendor/complex/split-centres-global/VALIDATION.json": "656d9bd7bd66058fdeb60cc90bd887e7ce75c0e0f9a100514e2bd84b95de89b6", + "vendor/complex/split-centres-global/.gitattributes": "2f9541c7c27f084baad73b4cd50ddaeb264cc3aa8dbf13ec21df5ab3f673ca7e", + "vendor/complex/split-centres-global/MANIFEST.json": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f", + "vendor/complex/split-centres-global/verify.py": "12fcdb20a87f75812b09c4916fbfc86305982cb410247186a123b5c58d517b4c", + "vendor/complex/split-centres-global/NOTICE.md": "66101a9e74d0ba9c2da4c8802bcb1968534adfa7130b954628eb8bf515fc0389", + "vendor/complex/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt": "c5f077b849e9add9957ab4ee36095dd47bc678dee7e09baa146dac4c0a0d66b2", + "vendor/complex/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2", + "vendor/complex/split-centres-global/proofs/PR426.md": "5787738ceb6faf14d3d96e8452592860a6c6a469733a9bcf196e8d1562ba1ffb", + "vendor/complex/split-centres-global/proofs/PR425-COMPLEX.txt": "2cda27b9b9a1eb24127c38c2c7a6e085155a2472183e220189a3ea2c2b7720dc", + "vendor/complex/split-centres-global/code/complex_emit.py": "f56d5f01f7c121741f175814138dca7190d769920f0a27e2d5b99c21aebed0f1", + "vendor/complex/split-centres-global/code/complex_phases_full.py": "0f2795aaffafe0c64d77f3748ef2109a3c42c58da867e4cf269a0a8cb6109466", + "vendor/complex/split-centres-global/code/bit_global.py": "3b2cb3ba21e5cf9b4deddb9e606322f33e9d8082020c0ee9092c21f4ebd9ad48", + "vendor/complex/split-centres-global/code/bit_audit.py": "7fdbc077b7501a53662769ff2bf2ab44cc2e32dafc34478d7ef2c10e3144503a", + "vendor/complex/split-centres-global/code/complex_construct.py": "0f7f45b2333ec7daf4291e2bf675b49bc330b97fb5965dd27220ba353c291d6f", + "vendor/complex/split-centres-global/code/bit_construct.py": "a461e6c983531beb5c8ac82ff593f39ce4e056387d1d6061f6e6b294dde4395f", + "vendor/complex/split-centres-global/code/complex_audit.py": "adeba5ea113652b60105db2e8719b18ffa292d3cc23730cca614b40272348330", + "vendor/complex/split-centres-global/code/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "vendor/complex/split-centres-global/code/complex_integrate.py": "3792f41e409383e6989bda22801a4836a646a530f99e99bbd7244a8f3a1a8b4f", + "vendor/complex/split-centres-global/code/complex_phases.py": "13a959c52092776ae217df554b51c0298fa9eb3a350279acff6dece651c3f9cc", + "vendor/complex/split-centres-global/code/combined.py": "9c5bc70f2331b7342ceb252adcddb993581c45f80c37bcc58642dbad3b9775c2", + "vendor/complex/split-centres-global/code/complex_replay.py": "be2dccce2d1ad2c4f5c01a851c9c3896cc88236b5aeae706aad2ab16d6bfdad9", + "vendor/complex/split-centres-global/notices/PR426.md": "6a5593d0f284a2f0865037f5c5fa9e5f76f9e12cf50ec5284486d3b8137c89da", + "vendor/complex/split-centres-global/notices/PR426-SOURCE-PINS.json": "18ace817f2f9af22511bb303e99656ed114e534b87f3dd95a65ca4ca670baf2f", + "vendor/complex/split-centres-global/notices/NOTICE-PR352.md": "967e6d7e76e216e4898cf543c75b527e8d397ec1ddba3800cb20701f24c89524", + "vendor/complex/split-centres-global/notices/PR386.txt": "ae2241615a23063b18a04f1b7a88a52e62b3d7d42e333fbd21e3668567ab83d1", + "vendor/complex/split-centres-global/notices/SUSSMAN-NOTICE": "9419dd03a2f52cf8bdfc4d18216ce29f263ab583b27f01ced8e420985bcb7c81", + "vendor/complex/split-centres-global/notices/NOTICE.md": "025773f32fb43667395e64c627a1752877bdc93afbfe01b106703eee438d21d3", + "vendor/complex/split-centres-global/vendor/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "vendor/complex/split-centres-global/vendor/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "vendor/complex/split-centres-global/vendor/hamming_packets.py": "daa9301e2767a711cfe66c6bebaad68e1a3bdb97ec9e848c927527ab43b37ae5", + "vendor/complex/split-centres-global/vendor/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/complex/split-centres-global/vendor/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/complex/split-centres-global/vendor/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c", + "vendor/complex/split-centres-global/inputs/bit-geometry.json.gz": "5c980202227859e8bb9b863f94503930c2a59d460c0421356688e2b0d828b4a1", + "vendor/complex/split-centres-global/inputs/complex-template.json.gz": "1b84904a31a733aab9bfdda3f528c06719f590d2133a43687a8bded955dc991e", + "vendor/complex/split-centres-global/inputs/e8-r865.json.gz": "1fb726ea3818fe0837cceb0dd22a71a0814f064e5e781628104610d6468e0e55", + "vendor/complex/split-centres-global/inputs/complex-phase-receipt.json": "01763fee5017745de982f2ff5ee68004e815d6684097cc88011dfbfb1e789581", + "vendor/complex/split-centres-global/inputs/bit-r767.json.gz": "bd3b84244528767b85d8d7fe423b155630b5c659e21e51563674b1dcb6305ad7", + "vendor/complex/split-centres-global/inputs/complex-ports.json.gz": "77b0c0fa19ef3da1c7316010e13493aa5eea1a50c3506eddc08f7480e659878b", + "vendor/complex/split-centres-global/inputs/complex-phase-recipes.json.gz": "b5472bb1d3f9ff41b0819780a42886a7686b4caf3c0617bb1dc86158b3fb8671", + "vendor/complex/split-centres-global/inputs/complex-data-phases.json.gz": "c972b5b60649c2a52354f5160f69adc0f4a270fa09d32012beff9888774ab84f", + "vendor/complex/e8-early-reset-kernel/PROOF.md": "fb4e1c3a23e3a0be48b5254133e584dad6fb523042ca8ef70358684fb9185962", + "vendor/complex/e8-early-reset-kernel/EXPECTED.json": "6710a99055d7ee1d83d9f811822bb72db84f6ce95bd4e1e17f1df1659c7e958b", + "vendor/complex/e8-early-reset-kernel/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/e8-early-reset-kernel/SOURCE.json": "a5e84250b687624b2158597831fb36a5f2b068983862c491f8e1020c9806cc65", + "vendor/complex/e8-early-reset-kernel/bit_global.py": "79c7dc84e65dca10c35c842cf170e4719d45c38a25d03bf762332b24c700b6c9", + "vendor/complex/e8-early-reset-kernel/bit_audit.py": "203bb609952ad7b7ca761e9f9883ee9fa35a0a0474503b396d47a31169102e7d", + "vendor/complex/e8-early-reset-kernel/README.md": "4d7d736eda667533ab55bf3949e30832d4676d7ebeee00d9608307ecc5aacd4b", + "vendor/complex/e8-early-reset-kernel/VALIDATION.json": "77ad775cf69f5d913568b6276b0dfeb2eaef0306f57b71c0a467bff793807267", + "vendor/complex/e8-early-reset-kernel/MANIFEST.json": "95a9570287b64d22de30e6ae3acf931d5f6daef1a163f0c99532e1a24639fbc2", + "vendor/complex/e8-early-reset-kernel/SELECTION.json": "b5f5d8c78d912820c8ed1a67c21062bec799714b9caa6724dfd515306ad42a2b", + "vendor/complex/e8-early-reset-kernel/bit_price.py": "36bf15803567a95b139a908461541bf19efe1f5b85fb31c270021833ab1393ee", + "vendor/complex/e8-early-reset-kernel/verify.py": "16c07414bc956744dc93b8e35b642267ea9819be922b0d3e081c543fdbf92a70", + "vendor/complex/e8-early-reset-kernel/NOTICE.md": "ff88b6031fe2fb5cbc483e8fcc08d228eaf2c982221adb3659da234dfa24cfeb", + "vendor/complex/e8-early-reset-kernel/combined.py": "4d514b6c70e969ec306d8c2bb38edec95b0cb7fa09f48dadbec8aa1eead69ce1", + "vendor/complex/e8-early-reset-kernel/source_span.py": "4772d177f37254c6f854af5ee3871aca193cfb24307a53c143c3bf517e56631e", + "vendor/complex/e8-early-reset-kernel/apply.py": "0d530e9703e1d1734c7af205bd393cba89ac41f75ed9781ea3dc5e46650f44f5", + "vendor/complex/e8-early-reset-kernel/local-evidence/ASSEMBLY.json": "7c3cc4b503e4cf0fd3e050be46ad0da183c5b1c490f4901245df944fd9d6194e", + "vendor/complex/e8-early-reset-kernel/local-evidence/SOURCE-SPANS.log": "bdf95dbce8337be57aab8a3d3b42a711ee276496c40cbb4c5356fc9cc9b2e811", + "vendor/complex/e8-early-reset-kernel/local-evidence/AUDIT.json": "76a146a9123d8b653e6e46ff93f153653f9cefd0f5c3fdd264a59f1322110262", + "vendor/complex/e8-early-reset-kernel/local-evidence/FULL-PYTHON314.json": "85797531db037d06fb597a4c9b6ef6bd71e6a0ab4f220ae70b1b6bf3aeda205f", + "vendor/complex/e8-early-reset-kernel/local-evidence/GLOBAL.json": "16c4e829eea1b2d12b70cec7e6a9c0e33ea0eae98a40894a3b779790fd2efbb3", + "vendor/complex/e8-early-reset-kernel/local-evidence/BIT-PRICE.json": "9a4a320cab1ce62b0c2329ac1bf3b81f73580fd603a406e4bfaae2962dfdad35", + "vendor/complex/e8-early-reset-kernel/local-evidence/FULL-PYTHON311.json": "62b37525bf7b60c0d9101ed571681f3bf46ea75df065939864307e4986018332", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/e8core.py": "3f4e25f700b7eb5821ab9cdfc65541f3f921baffeb8704beb21c6d7072052d29", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/stages.py": "e73ab7836519510ed30dd7e3022dae557fa50fc513d723197929bff741859668", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/engines/base_two_moment.py": "aee70c242a2f1d225528fabe2002e1564d1dc884797c07d28a831c7878ee9098", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/engines/moment.py": "81cbc864e106418fc7854322746f72180cb8110ff39f74450a3b8d55a82c1482", + "vendor/complex/e8-early-reset-kernel/vendor/kernel417/engines/outer.py": "c1ebb52163a7219504c728a5c2b098bf1e50bf20148a2879c5a74c3cadc7c03c" + }, + "pooled_parent": { + "pr": 496, + "head": "00cf70efd6a8637531deafef698157ca83e249ee", + "manifest_sha256": "b7a3bdb801f4a9ae8c389edaee545a8d0cb16fd6211f38b54b71b5c50eb5a80c" + } +} diff --git a/research/r489-pooled-retimed-complex/code/apply_retime.py b/research/r489-pooled-retimed-complex/code/apply_retime.py new file mode 100644 index 0000000000..01a0d7008c --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/apply_retime.py @@ -0,0 +1,60 @@ +"""OpenAI Codex: apply a frozen frame-only retiming to verified PR484. +Usage: python -B apply_retime.py BASE_FULL-WORD.json.gz RETIME-FRAMES.json.gz OUT_FULL-WORD.json.gz +Source PR433/PR484 notices remain inherited. Frame accounting follows their +nested-frame contract, implemented here for independent frozen-map replay. +No optimizer runs; scalar gates, selected entrances and boundaries are fixed. +""" +import copy,gzip,hashlib,json,sys +from pathlib import Path +from collections import Counter + +def canonical(x):return json.dumps(x,sort_keys=True,separators=(',',':')).encode() +def basis(vs): + b={} + for x in vs: + for p in sorted(b,reverse=True): + if x>>p&1:x^=b[p] + if x: + p=x.bit_length()-1 + for q in b: + if b[q]>>p&1:b[q]^=x + b[p]=x + return tuple(b[p]for p in sorted(b,reverse=True)) +def inside(a,b):return basis(list(a)+list(b))==basis(b) +def registers(e):return [e[1],e[2]]if e[0]=='add'else[e[1]] +def profile(w): + v=120;n=240+w['report']['R'];full=basis([1<=0 for k in globalpaid.values());globalpaid={r:k for r,k in sorted(globalpaid.items())if k};assert globalpaid=={int(r):k for r,k in p['expected_global_profile'].items()} + z['report']['local_profile']={str(r):k for r,k in local.items()};z['report']['global_profile']={str(r):k for r,k in globalpaid.items()} + assert hashlib.sha256(canonical(z)).hexdigest()==p['candidate_word_json_sha256'] + out.write_bytes(gzip.compress(canonical(z),mtime=0));print(json.dumps(dict(status='PASS_FROZEN_FRAME_ONLY_RETIME_APPLICATION',changed_A_frames=len(p['A']),changed_B_frames=len(p['B']),local_profile=local,output_json_sha256=hashlib.sha256(canonical(z)).hexdigest(),output_gzip_sha256=hashlib.sha256(out.read_bytes()).hexdigest()),indent=2)) +if __name__=='__main__':main(*map(Path,sys.argv[1:4])) diff --git a/research/r489-pooled-retimed-complex/code/audit484/assemble_candidate.py b/research/r489-pooled-retimed-complex/code/audit484/assemble_candidate.py new file mode 100644 index 0000000000..72ee6f0376 --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/audit484/assemble_candidate.py @@ -0,0 +1,35 @@ +"""Two exact moment engines and strict outer composition of a new PR484 rehosting +with a freshly verified bit supplier. Prepared by OpenAI Codex; arithmetic +engines are pinned inherited PR361/Mercator and independent base-two code. +Usage: assemble_candidate.py AUDIT_OUT PARENT_VARIANT HOSTED BIT_RESULT +""" +from pathlib import Path +from fractions import Fraction as Q +import json,gzip,sys,hashlib,importlib.util +O,V,H,B=map(Path,sys.argv[1:5]);sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +def load(n): + p=V/'work/pr361/code/engines'/(n+'.py');s=importlib.util.spec_from_file_location('candidate_'+n,p);m=importlib.util.module_from_spec(s);s.loader.exec_module(m);return m +M,Other,Outer=[load(n)for n in ['moment','base_two_moment','outer']] +owner=json.loads((O/'OWNERS-AND-PROFILE.json').read_text());inv=json.loads((O/'PREFIX-AND-INVOICE.json').read_text());host=json.loads((H/'HOSTED.json').read_text());bit=json.loads(B.read_text());P={int(r):n for r,n in owner['paid_profile'].items()};m,W=73,owner['live'];assert m*W-sum(r*n for r,n in P.items())==2496 +rc=M.certify(P,m,W,True);b=Q(rc['lower']);bp=Q(rc['upper']);assert bp-b==Q(1,10**24) +fallback=32*m*m*sum(P.values());receipts=[] +for z,accept in[(b,True),(bp,False)]: + ml,mh=M.moment(P,m,W,z,True);a,c=Other.moment(m,W,list(P.items()),z);d,e=Other.moment(m,W,[(1,fallback)],z);a+=d/10**16;c+=e/10**16 + assert (mh<1 and c<1)if accept else(ml>1 and a>1) + receipts.append(dict(endpoint=str(z),mercator=[str(ml-1),str(mh-1)],base_two=[str(a-1),str(c-1)],accept=accept)) +c=Q(bit['bit_lower']);eta=beta=Q(1,10**18);grid=Q(1,10**18);s=min(c,(1-beta)*b)-Q(1,10**24) +assert 00 + cut=max(ceil(36/gap**2),ceil(2*(4+coeff)/gap));assert cut*gap**2>=36 and cut*gap>=2*(4+coeff);cuts.append(dict(gap=str(gap),cutoff_log2=str(cut)));chain.append(a) +q=chain[-1]*(1-2*eta);margin=(1-eta)*q/(1+q);ticks=margin/grid;kap=grid*((ticks.numerator-1)//ticks.denominator) +bridge={'semantic':{'C0':{'base':2,'exponent':210000},'strict_literal_gap':1},'rows':{'degree_gap':Q(10**6)-Q(51*row,25)}} +a=Outer.assembly(chain[-1],b,bridge,kap,eta=eta,beta=beta);assert len(a['strict_constraints'])==47 and all(x>0 for x in a['strict_constraints'].values());controls=[] +for name,k,e,be in [('next_grid',kap+grid,eta,beta),('zero_eta',kap,Q(0),beta),('zero_beta',kap,eta,Q(0)),('unit_beta',kap,eta,Q(1))]: + try:Outer.assembly(chain[-1],b,bridge,k,eta=e,beta=be) + except AssertionError:controls.append(name) + else:raise AssertionError(name) +res=dict(status='PASS_REHOSTED_COMPLEX_AND_FRESH_BIT_EXACT_ASSEMBLY',complex_lower=str(b),complex_decimal=rc['lower'],next_b_rejected=str(bp),exact_moment_receipts=receipts,bit_lower=str(c),bit_result_sha256=sha(B),bit_template_sha256=bit['bit_template_sha256'],bit_prefix_bits=bit['bit']['charged_prefix_bits'],bit_charged_three_level_coefficient_bits=coeff,external_row_allowance=row,kappa=str(kap),kappa_decimal=f'{float(kap):.18f}',binding_component='bit'if c<(1-beta)*b else'complex',strict_outer_constraints={k:str(v)for k,v in a['strict_constraints'].items()},outer_controls=controls,bootstrap=cuts,complex_template_sha256=host['template_sha256'],owner_audit_sha256=sha(O/'OWNERS-AND-PROFILE.json'),invoice_sha256=sha(O/'PREFIX-AND-INVOICE.json'),scope='Conditional finite witness. Inherited compiler, precision/tape and analytic-transfer contracts remain assumed; changed-host operator admission recorded separately.') +(O/'EXACT-ASSEMBLY.json').write_text(json.dumps(res,indent=2)+'\n');print(res['status'],'b',res['complex_decimal'],'kappa',res['kappa_decimal'],flush=True) diff --git a/research/r489-pooled-retimed-complex/code/audit484/audit_pooled_candidate.py b/research/r489-pooled-retimed-complex/code/audit484/audit_pooled_candidate.py new file mode 100644 index 0000000000..fb1ca8e31d --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/audit484/audit_pooled_candidate.py @@ -0,0 +1,20 @@ +"""Portable independent admission of the complete pooled PR484 derivative. +Prepared by OpenAI Codex. Inputs are fresh supplier replay outputs and new +serialized candidate, with separate stdlib controller audit supplied by another +checker. No source or supplier result is modified. +""" +from pathlib import Path +import argparse,json,subprocess,sys,hashlib,gzip +p=argparse.ArgumentParser() +for x in ['parent','hosted','bit-result','phases','controller-audit','out']:p.add_argument('--'+x,type=Path,required=True) +a=p.parse_args();a.out.mkdir(parents=True,exist_ok=False);C=Path(__file__).resolve().parent;steps=[];sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +commands=[('owners',[C/'audit_pooled_owners.py',a.out,a.parent,a.hosted,a.phases]),('scalar-invoice',[C/'audit_scalar_invoice.py',a.out,a.parent,a.hosted]),('global-prefix',[C/'audit_pooled_prefix.py',a.out,a.parent,a.hosted,a.controller_audit]),('two-moments-outer',[C/'assemble_candidate.py',a.out,a.parent,a.hosted,a.bit_result])] +for label,args in commands: + with(a.out/(label+'.log')).open('w')as log:r=subprocess.run([sys.executable,'-B',*map(str,args)],stdout=log,stderr=subprocess.STDOUT) + steps.append(dict(stage=label,observed_exit=r.returncode));(a.out/'OBSERVED-EXITS.json').write_text(json.dumps(steps,indent=2)+'\n');r.check_returncode() +read=lambda p:json.loads(gzip.decompress(p.read_bytes())if p.suffix=='.gz'else p.read_bytes()) +raw=gzip.decompress((a.hosted/'GLOBAL-TEMPLATE.json.gz').read_bytes());t=json.loads(raw);h=read(a.hosted/'HOSTED.json');c=read(a.controller_audit);o=read(a.out/'OWNERS-AND-PROFILE.json');g=read(a.out/'GLOBAL-PREFIX.json');x=read(a.out/'EXACT-ASSEMBLY.json') +hash_=hashlib.sha256(raw).hexdigest();assert hash_==h['template_sha256']==c['complex_template_sha256']==g['template_sha256']==x['complex_template_sha256'];assert c['complex_profile']==h['global_profile']==o['paid_profile'];assert c['complex_live']==t['live']==o['live'] +assert len(c['mutations_rejected'])>=18 and c['one_owner_per_complete_invocation'];assert all(sha(a.parent/n)==v for n,v in h['source_artifacts'].items()) +report=dict(status='PASS_COMPLETE_POOLED_COMPLEX_FINITE_ADMISSION',complex_template_sha256=hash_,complex_profile=o['paid_profile'],complex_live=o['live'],physical=o['physical'],rank_mass=o['rank_mass'],deficit=o['deficit'],complex_hosted_residuals=o['hosted_residuals'],one_owner_per_complete_invocation=True,actual_73column_sigmas=o['actual_73column_sigmas'],cross_replica_helper_roles=o['cross_replica_helper_roles'],global_prefix_bits=g['global_prefix_bits'],retained_payload_bits=g['retained_payload_bits'],source_artifacts=h['source_artifacts'],controller_audit_sha256=sha(a.controller_audit),controller_mutations_rejected=c['mutations_rejected'],bit_result_sha256=sha(a.bit_result),complex_lower=x['complex_lower'],kappa=x['kappa'],kappa_decimal=x['kappa_decimal'],observed_stages=steps,files={str(p.name):sha(p)for p in a.out.glob('*.json')},scope='Exact finite program, complete-invocation normalization, whole physical owners, both scalar orientations, full paid profile, cross-replica-safe global prefix and strict arithmetic assembly. Retains inherited all-size compiler/precision/tape/common-grid and analytic-transfer contracts. PR484 source remains unchanged; independent audit by OpenAI Codex.') +(a.out/'ADMISSION.json').write_text(json.dumps(report,indent=2)+'\n');print(report['status'],'kappa',report['kappa_decimal'],flush=True) diff --git a/research/r489-pooled-retimed-complex/code/audit484/audit_pooled_owners.py b/research/r489-pooled-retimed-complex/code/audit484/audit_pooled_owners.py new file mode 100644 index 0000000000..7d3e8a4a88 --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/audit484/audit_pooled_owners.py @@ -0,0 +1,83 @@ +"""Independent actual whole-owner charts and full paid-profile recount for PR484. +Uses raw canonical word, local programs and emitted owner arrays, no package imports. +OpenAI Codex audit; inherited all-size assumptions are outside this finite check. +""" +from pathlib import Path +from collections import Counter,defaultdict +import json,gzip,hashlib +import sys +O=Path(sys.argv[1]);V=Path(sys.argv[2]);HOSTED=Path(sys.argv[3]);PHASES=Path(sys.argv[4]) +def read(p):return json.loads(gzip.decompress(p.read_bytes())if p.suffix=='.gz'else p.read_bytes()) +w=read(V/'split-centres/CANONICAL-WORD.json.gz');t=read(HOSTED/'GLOBAL-TEMPLATE.json.gz');parent=read(V/'split-centres/GLOBAL-TEMPLATE.json.gz');ph=read(PHASES);host=read(HOSTED/'HOSTED.json');M=73;DATA=7680;H=9;n=800 +assert (w['v'],w['R'],w['h'])==(120,560,9)and t['live']==7680 +widths=[H-len(w['frames'][w['start'][240+i]])for i in range(560)] +def par(a):return a.bit_count()&1 +def basis(q): + j=0 if not(q&1)else next(i for i in range(1,9)if not(q>>i&1));u=q^(1<0;sp=r[3] + idx=list(range(off,off+w0));assert len(sp)==e0 and len(set(idx+sp))==9 + assert not set(idx)&bank[f];bank[f].update(idx);specs.append((f,sp,e0));banked+=1 + chart=idx+sp+[i for i in range(M)if i not in idx+sp];assert len(chart)==M and set(chart)==set(range(M)) + charts.update(json.dumps([s,rep,h,f,chart],separators=(',',':')).encode()+b'\n');chartcache.add((r[0],f%120 if f d*sigma^-1 is a bijection on that finite group; no family can be active +# twice in a complete cover sweep. Different dirty-helper incidences are +# permitted, since their completed endpoint is a unitary coordinate factor. +locals_=len(t['calls']);bridges=[e for e in t['recipe']if e['kind']=='bridge'];assert locals_==72 and len(bridges)==9 and all(abs(e['coefficient'])==1 for e in bridges) +for row in t['calls']: + assert row['orientation']in('forward','backward') + assert len(row['owners'])==len(set(f for f,_ in row['owners']))==800 + assert row['owners'][:240]==next(x for x in base['calls']if(x['stage'],x['replica'])==(row['stage'],row['replica']))['owners'][:240] +# The independently replayed 800-column scalar maps have row-l1 <=2; their +# fixed frame and endpoint operators are unitary. Thus maximum stream L2 norm +# grows <=2 per complete invocation (more conservatively, per cover sweep). +# All idle factors, wrappers, addresses and terminal signed exchanges are +# unitary. Unit-modulus Gauss monomials are unitary; C_q=aI+bX_q is unitary +# since |a|^2+|b|^2=1 and a*conj(b)+b*conj(a)=0. +peak=max(F(x['prefix_l1'])for x in invoice['local'].values());localbits=peak.numerator.bit_length()-peak.denominator.bit_length()+1;assert localbits==20 and peak<2**20 +input_to_l2=37 # sqrt(2^73) <2^37 for input sup norm1 per physical stream +complete_bits=locals_+len(bridges);primitive_margin=4 +payload=localbits+input_to_l2+complete_bits+primitive_margin +assert payload==142 and payload<192 +# No extra helper role or chart operation is introduced: all40320roles still +# receive the two selectors already charged in the unhosted finite invoice. +assert len(t['idle_children'])==own['explicit_idle_remainder_children']<=own['source_idle_children_charged'] +assert own['banked_residuals']==0 and len(t['bank_padding']['families'])==0 +assert t['physical']<=base['physical']and t['live']<=base['live'] +assert invoice['conservative_pervertex_used']==invoice['unhosted_pervertex'] +report=dict(status='PASS_GLOBAL_POOLED_PREFIX_AND_NORMALIZED_INTERFACE',template_sha256=th,source_template_sha256=hashlib.sha256(gzip.decompress((V/'split-centres/GLOBAL-TEMPLATE.json.gz').read_bytes())).hexdigest(),controller_audit_sha256=sha(C),local_programs_sha256=sha(V/'split-centres/LOCAL-PROGRAMS.json.gz'),canonical_word_sha256=sha(V/'split-centres/CANONICAL-WORD.json.gz'),residual_adapters_sha256=sha(V/'split-centres/RESIDUAL-ADAPTERS.json'),actual_sigma_table_sha256=sha(H/'ACTUAL-SIGMAS.json.gz'),sigma_count=len(sigmas),orthogonal_73column_group_membership_checked=True,whole_owner_injection_all_calls=True,local_complete_row_l1_bound=2,complete_invocation_cover_sweeps=locals_,bridge_factor_two_sweeps=len(bridges),local_scalar_coefficient_work_prefix_bits=localbits,stream_input_sup_to_l2_bits=input_to_l2,primitive_arithmetic_margin_bits=primitive_margin,global_prefix_bits=payload,retained_payload_bits=192,charged_helper_selectors=2*40320,actual_idle_remainders=len(t['idle_children']),idle_children_already_charged=own['source_idle_children_charged'],conservative_pervertex_used=invoice['conservative_pervertex_used'],proof='Take the maximum L2 norm over all physical streams(F,g). A complete helper invocation has normalized endpoint C_pending tensor I and hence preserves this norm; full data endpoints have at most two unitary summands, and each bridge has coefficients±1. For each call, each actual orthogonal chart sigma induces a bijection d→d*sigma^-1 on O(73,2), so a complete cover sweep touches each active physical stream once. Completed helper interactions in other cover classes preserve its norm. Consequently72ordered invocation sweeps and9bridges contribute at most81bits, with no independence of replicas and no factor proportional to cover size. Inside an invocation the exact all-column scalar/Horner envelope contributes20bits; every frame/normalizer is unitary. An initial2^73entry stream with supremum≤1 has L2<2^37. Four bits cover primitive arithmetic before normalization, giving142<192. The all-size child/compiler interfaces and their existing precision/tape contracts remain inherited.',scope='New finite cross-replica global prefix argument under verified complete-invocation normalization and inherited O(73,2) cover/compiler contracts; no unconditional all-size theorem.') +(O/'GLOBAL-PREFIX.json').write_text(json.dumps(report,indent=2)+'\n');print(report['status'],'global_prefix_bits',payload,'<192',flush=True) diff --git a/research/r489-pooled-retimed-complex/code/audit484/audit_scalar_invoice.py b/research/r489-pooled-retimed-complex/code/audit484/audit_scalar_invoice.py new file mode 100644 index 0000000000..b03fdf510f --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/audit484/audit_scalar_invoice.py @@ -0,0 +1,82 @@ +"""Fresh PR484 scalar/prefix lowering and finite overcharge recount. OpenAI Codex. +Reads emitted programs, canonical word and raw routes, importing no supplier code. +Inherited all-size compiler admissibility is a condition, not inferred here. +""" +from pathlib import Path +from fractions import Fraction as F +from collections import Counter +import gzip,json,math,hashlib +import sys +O=Path(sys.argv[1]);V=Path(sys.argv[2]);HOSTED=Path(sys.argv[3]) +def read(p):return json.loads(gzip.decompress(p.read_bytes())if p.suffix=='.gz'else p.read_bytes()) +w=read(V/'split-centres/CANONICAL-WORD.json.gz');p=read(V/'split-centres/LOCAL-PROGRAMS.json.gz');old=read(V/'split-centres/GLOBAL-TEMPLATE.json.gz');new=read(HOSTED/'GLOBAL-TEMPLATE.json.gz');integ=read(V/'split-centres/INTEGRATION.json');checks=read(V/'split-centres/LOCAL-CHECKS.json');prior=read(V/'split-centres/INDEPENDENT-REPLAY.json');owners=read(O/'OWNERS-AND-PROFILE.json') +N=800;M=73;R=560;L=9;T=8;VV=120;K=4 +local={} +for ori,evs in p.items(): + rows={('L',i):{i:F(1)}for i in range(N)};env={('L',i):F(1)for i in range(N)};peak=F(1);real=macros=0;paid=Counter();workops=0 + for e in evs: + if e[0]=='climb':paid[e[5]]+=1 + elif e[0]=='center':paid[e[4]]+=1 + elif e[0]=='scalar': + macros+=1;x=e[1];op=x[0];a=tuple(x[1]);count=0 + if op=='clear':rows[a]={};env[a]=F(0);count=1 + elif op=='copy':rows[a]=dict(rows[tuple(x[2])]);env[a]=env[tuple(x[2])];count=1 + elif op=='scale': + q=F(x[2],x[3]);num,den=abs(q.numerator),q.denominator + assert num and num&(num-1)==0 and den&(den-1)==0 + rows[a]={j:q*v for j,v in rows[a].items()};env[a]*=abs(q) + count=abs(num.bit_length()-den.bit_length())+int(q<0) + elif op=='add': + b=tuple(x[2]);q=F(x[3],x[4]);num,den=abs(q.numerator),q.denominator + assert a!=b and num>0 and den&(den-1)==0 + # Lower actual coefficient to cleared Horner work. Every intermediate + # magnitude envelope is explicitly included, before denominator halvings. + acc=0;count=1 + for i,ch in enumerate(bin(num)[2:]): + if i:acc*=2;count+=1;peak=max(peak,acc*env[b]) + if ch=='1':acc+=1;count+=1;peak=max(peak,acc*env[b]) + v=F(acc) + for i in range(den.bit_length()-1):v/=2;count+=1;peak=max(peak,v*env[b]) + assert v==abs(q);count+=2 # signed accumulation and private work clear + env[a]=env.get(a,F(0))+abs(q)*env[b];rr=rows.setdefault(a,{}) + for j,z in list(rows[b].items()): + value=rr.get(j,F(0))+q*z + if value:rr[j]=value + else:rr.pop(j,None) + workops+=count + else:raise AssertionError(op) + real+=2*count;peak=max(peak,env[a]) + assert all(not row for reg,row in rows.items()if reg[0]=='C') + for i in range(N): + expected={i:F(1)} + if ori=='forward'and 120<=i<240:expected[i-120]=F(1) + if ori=='backward'and i<120:expected[i+120]=F(-1) + assert rows['L',i]==expected + assert peak==F(prior['local'][ori]['prefix_l1_upper']) and peak<2**192 + assert real==checks[ori]['real_component_primitive_bound']and macros==checks[ori]['scalar_macros'] + assert dict(paid)=={int(r):z for r,z in checks[ori]['paid_profile'].items()} + local[ori]=dict(events=len(evs),macros=macros,real_component_primitives=real,prefix_l1=str(peak),prefix_bits=peak.numerator.bit_length()-peak.denominator.bit_length()+1,coefficient_work_primitive_count=workops,all_exact_columns=N,all_560_dirty_helper_columns_restored=True,private_centres_and_coefficient_work_cleared=True) +centres=len(w['centers']);widths=[9-len(w['frames'][f])for f in w['start'][240:]];enter=sum(x<9 for x in widths) +children=sum(checks['forward']['paid_profile'].values());macros=max(x['macros']for x in local.values());compiler=64*(M+1)**3 +adapters=16*(macros+children+N+centres)+64*M +primitive_bound=max(x['real_component_primitives']for x in local.values())+adapters*compiler +bridges=sum(e['kind']=='bridge'for e in old['recipe']);bridgeadd=2*VV*T*bridges;shifts=K*VV*T;moves=2*K*VV*T +oldW=old['live'];oldP=old['physical'];oldNB=(oldW-2*VV*K*T)//L +scalar=sum(local[c['orientation']]['real_component_primitives']for c in old['calls']) +nonlocal_items=4*VV*T*L+2*VV*T*L+2*L*T*R+sum(e['replicas']for e in old['idle_children'])+L*oldNB+bridgeadd+shifts+moves+oldW+oldP+2*L*T*enter*144 +outside=8*nonlocal_items+64*M +pervertex=scalar+bridgeadd+shifts+moves+oldW+(72*adapters+outside)*compiler+64*oldP +invoice=integ['finite_invoice'];assert (primitive_bound,adapters,pervertex,compiler)==(invoice['local_primitive_bound'],invoice['local_adapters'],invoice['pervertex'],invoice['compiler']) +# Independent hosted stock rebase, retaining the larger unhosted operation +# overcharge; only the stock and mass in the common router/literal change. +W=new['live'];P=new['physical'];mass=owners['rank_mass'];profile=owners['paid_profile'] +assert M*W-mass==2496 and P==W+R+centres+2 +rebase=pervertex-oldP*65+P*65-oldW+W;used=max(rebase,pervertex) +r=M//2;group=2**(r*r) +for i in range(1,r+1):group*=2**(2*i)-1 +stock=group*P;smass=group*mass;logical=group*used+64;router=compiler*(logical+1)*(stock+1)**2 +G,E,C0=2**30000,2**100000,2**210000;B=smass+E;literal=2*G*stock**2+8*smass+4*stock+4+32*M;row=2*stock.bit_length()+9909+252;maxchild=max(map(int,profile)) +ineq=dict(local_primitive_bound=primitive_bound<2**48,logical=logical<2**6050,router=router2*maxchild*maxchild) +assert all(ineq.values()) +out=dict(status='PASS_INDEPENDENT_SCALAR_PREFIX_AND_HOSTED_FINITE_INVOICE',local=local,entering_helpers=enter,entrance_rank=sum(9-x for x in widths),local_adapters=adapters,local_primitive_bound=primitive_bound,wrapper_elementary_factors_charged=2*72*enter*144,compiler=compiler,unhosted_pervertex=pervertex,hosted_rebased_pervertex=rebase,conservative_pervertex_used=used,finite=dict(physical_stock_bits=stock.bit_length(),router_bits=router.bit_length(),literal_bits=literal.bit_length(),physical_row_coefficient=row,retained_row_coefficient=20161,required_C0_bits=(32*M*B*B).bit_length(),halving_integer_inequality=[M*M,2*maxchild*maxchild],G_exponent=30000,E_exponent=100000,C0_exponent=210000),strict_checks=ineq,scope='Exact finite recount conditional on inherited all-size compiler/precision/tape and analytic-transfer contracts. Signed accumulation uses the supplier scalar primitive convention.') +(O/'PREFIX-AND-INVOICE.json').write_text(json.dumps(out,indent=2)+'\n');print(json.dumps(out,indent=2),flush=True) diff --git a/research/r489-pooled-retimed-complex/code/audit493/review_invoice.py b/research/r489-pooled-retimed-complex/code/audit493/review_invoice.py new file mode 100644 index 0000000000..7e791e5dfb --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/audit493/review_invoice.py @@ -0,0 +1,73 @@ +"""Independent PR493 pinned-source invoice and exact arithmetic audit, OpenAI Codex. Apache-2.0. +Usage: review_invoice.py PR493_PACKAGE FRESH_OUTPUT REPORT.json +""" +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter +import gzip,hashlib,importlib.util,json,sys +if not __debug__:raise RuntimeError('assertions must remain enabled') +assert len(sys.argv)==4, 'usage: review_invoice.py PR493_PACKAGE FRESH_OUTPUT REPORT.json' +PKG,O,REPORT=map(lambda x:Path(x).resolve(),sys.argv[1:]) +sha=lambda p:hashlib.sha256(p.read_bytes()).hexdigest() +read=lambda p:json.loads(gzip.decompress(p.read_bytes()) if p.suffix=='.gz' else p.read_bytes()) +manifest={} +for line in (PKG/'MANIFEST.sha256').read_text().splitlines():h,p=line.split(' ',1);manifest[p]=h +actual={str(p.relative_to(PKG)):sha(p) for p in PKG.rglob('*') if p.is_file() and p.name!='MANIFEST.sha256' and '__pycache__' not in p.parts};assert actual==manifest +PINNED_BLOBS={'EXPECTED.json': '973aaf30f1ec6a4d58038acabb9361ee1f44787a', 'LICENSE': '261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64', 'MANIFEST.sha256': '1213654fbd423d66e785bf582ba8ee76a41cdd36', 'NOTICE.md': '5a0ecdcd2c7fad0488740a1da0f633b73b56a809', 'README.md': 'dd0d7c43611d6c527a17287bc550e763edca0294', 'SOURCE-pr370.json': '1b30f277afa20cb9db1e4495d655a32d64552317', 'SOURCE-pr381.json': 'fb0b0edd1375ffcbe9b2c9065bcca236a974660f', 'SOURCE-pr386.json': '3744861904f61f29b00e2dec9cb98639a0fb7dfe', 'SOURCE-pr436.json': 'f190527ae1c97a51fa9030518b59affeb0befcd3', 'SOURCE-pr445.json': 'ae29de391a7aa893bec6ab8c2b6e89688191b088', 'SOURCE-pr448.json': '3648ab36928a28564ce89d224cfb3f16c891ecf1', 'SOURCE-pr451.json': 'fbd9881e09d7219f264eb1ee67c40c2e43d0832e', 'SOURCE-pr458.json': 'c36c74cbeacf690473803b59a8d25008ec5a7710', 'SOURCE-pr471.json': '0dc019cfb1933e55d063fbd9e45bb316e4045857', 'SOURCE-pr472.json': '31acb027ecd0808f18e6f59c59662f6f94f5b9ac', 'SOURCE-pr473.json': '821caf8f073c615680ba5610e268eee2d23d2d03', 'SOURCE-pr478.json': '608323ccbe4150d5a6522ddb3b18aa9cb5dff4fa', 'SOURCE-pr483.json': '817396d9c89965a32979b943e638163d8261a205', 'SOURCE-pr484.json': '76292df8518ac72acb3754a7b4fb23c368725b13', 'code/bit/checkers/columns_h.cpp': '00c5a3a5d81d083582f60f33dd2e7bea5049c37f', 'code/bit/checkers/columns_k.cpp': '42bb232fbec4de703e70cc13dc2f39a3b43a3a01', 'code/bit/checkers/gram_frames.py': 'b740d47295c02692260d7cc01874a49fe48f78ab', 'code/bit/checkers/json.hpp': '82d69f7c5d044c9887c96b90c97f5639083ecd14', 'code/bit/checkers/legality_h.cpp': 'cb1233c7e96b1aa8bbf4d2e4165d75ab0dca64b9', 'code/bit/export_records.py': '3632d370486a02f5456f7643ced03f8c925b2350', 'code/bit/independent/checkword.py': 'da4e0fe05067184d4dab1e130ae1384c1fa983f5', 'code/bit/independent/interface.py': '8beb87c39a07e389c8f83f32ab9d17f8097ed9b1', 'code/bit/independent/mutate.py': 'eba592fd468e0d7e7e5100fe99da6eb548c5906b', 'code/bit/independent/mutate_mut.py': 'f4c6191b783094c4d241f179446085331feb052b', 'code/bit/independent/relax.py': 'a37e8b8176080d4a977bb48bd25f92f4a62b156b', 'code/bit/mutate_records.py': '6794516f665d36eac189894e350a5ad01113cb4c', 'code/bit/mutate_records_mut.py': 'ea26fcebf99312eb5d4f5440862959fa6a74ec52', 'code/bit/regression/stage_cohort.py': 'f6d7afe3e623208c4207b6a683a1e3e49249e31c', 'code/cited.py': 'e543cf2c9b2b1d43693bed6efbdba607ad9ac277', 'code/eleven/adapt.py': 'c13c91c245146670d4b454ff07b835f480171fc1', 'code/eleven/assemble.py': '87cc45bc831fa7003906e8b026ac1480a69da1de', 'code/eleven/audit.py': '10e47d32e3b4769ae5ce5bad9f76a7b3e5d797fc', 'code/eleven/emit.py': '640cdb4d1220950e198f2fd9994d76d69ecbf764', 'code/eleven/local_audit.py': '2233c5f35f2fcb58809f7a1d8f91e9b36ad74080', 'code/hub/e8-r715-whole-hosted/code/assemble.py': 'cd60b4bcfae515fccd7f21fd1ff5a7114a132eb9', 'code/hub/e8-r715-whole-hosted/code/audit.py': '155b61f2944116423a5be6ae666276e1c1827fe5', 'code/hub/e8-r715-whole-hosted/code/emit.py': 'df74ad698a98419e828b37d4dfd7c036fc49a890', 'code/hub/e8-r715-whole-hosted/code/local_audit.py': '931f884920125b334412f70cf30d9517b084dc7a', 'code/hub/e8-r715-whole-hosted/data/hosting.json': '381fb06ccbe055f4fbdc7544dcf8c0bae8f96701', 'code/hub/e8-r715-whole-hosted/data/residual-isometries.json': '5864e4d680035401d53d32adab0369046d80b171', 'code/hub/e8-r715-whole-hosted/data/word.json.gz': 'f7d55b8bd45d385011ced25e632a3d922bb77bba', 'code/hub/e8-r740-replica32/code/bank_routes.py': '9e43a876664a26899762f3b8e9a582e684a3650a', 'code/hub/e8-r740-replica32/code/e8core.py': '78983b368715e89fe8524a6dd2c13585d2b5394e', 'code/hub/e8-r740-replica32/code/engines/base_two_moment.py': '14a90fa0e788217856f070382c9e61bd7c603c61', 'code/hub/e8-r740-replica32/code/engines/moment.py': '7d697cb45203fe72d97037403d6da41f71f3b7fd', 'code/hub/e8-r740-replica32/code/engines/outer.py': '43007488ad2c43187c77cc6798beff8b1cd76ad2', 'code/hub/e8-r740-replica32/code/tile_m.py': 'cd5fd9b5399f5e7afe5d2a95bd3504bd543c0d60', 'code/hub/e8-r740-replica32/data/residual-isometries.json': '9b8b35cb1528a978e209e1098864cae48c57fd93', 'code/hub/e8-r740-replica32/data/word.json.gz': '85390b07e4747feddbf2e16f94b5e0a8a308c191', 'code/hub/idle-axis-hosting/hosting_core.py': '68b536daa9e6546c0aa046934bf840aaa3c3fde3', 'code/hub/r740-hosted-eleven/code/emit.py': '5ff0de0d6f088ac95e25a2a7aed8653e8cd0333e', 'code/hub/r740-hosted-eleven/code/geometry.py': 'b4ad5074014dc00a01143910eb1cd27fafe0e15c', 'code/hub/r740-hosted-eleven/code/row_bound.py': '11d3c0d48e4ea5a02ac3b6689f3c7d36f2972eb8', 'code/hub/r740-hosted-eleven/data/selection.json': '8e548e5a9204a909d539ba36b866804b256d4c2b', 'code/hub/r740-hosted-rank149/code/emit.py': '5ff0de0d6f088ac95e25a2a7aed8653e8cd0333e', 'code/hub/r740-hosted-rank149/data/residual-isometries.json': 'ec8b4131d203d7a288ca078ca559f922d38fe9d2', 'code/hub/r740-hosted-rank149/data/selection.json': 'c57069f7385c3b6aff4fe3c73c0a21bae727c76f', 'code/hub/r740-hosted-rank149/data/word.json.gz': '3c8489a29f0de2cad7dafaddc340a1ff197d5172', 'code/nine/geometry.py': '91594e0223e8fac49162b5aef834ffaa8e94a254', 'code/pricing/base_two_moment.py': '14a90fa0e788217856f070382c9e61bd7c603c61', 'code/pricing/moment.py': '7d697cb45203fe72d97037403d6da41f71f3b7fd', 'code/pricing/outer.py': '43007488ad2c43187c77cc6798beff8b1cd76ad2', 'code/pricing/prime_witnesses.py': '7f16d930302ae879c562dd58e085d9747fcac077', 'code/provenance.py': '9bfcb106230e454d9405ce5eb42dd2218d905ea6', 'code/skeleton/e8.py': '92e83a2e0c1f67551f583630a728b2a880b06f51', 'code/skeleton/gen.py': '9811c127d41521e906462a75322a29f0e193629c', 'code/skeleton/geom.py': '9e5fe3a781dc52e07b7c5de3a44c8be6f5024cd4', 'code/skeleton/wordkit.py': '7cc4e6d618d9d0166efe8be75a019b6aecee0582', 'data/bit/bitE8-r865.json.gz': '8bec1751f7e33c3a1e4673ef5dbc34d6f205321e', 'data/bit/bitE8mut-r489.json.gz': 'ef67bec220c96a1de7b87c9f1a6e7acb26cb3284', 'data/complex-b.json': '0df48f8e590fc9ad01ca4d6eaf97b9acc10aac7d', 'data/complex/pr448/EXPECTED.json': '1574e6488b6fc59191ae49fcc0c089e48b196fbd', 'data/complex/pr458/EXPECTED.json': 'e06a17c177eee0e0962c96ea61554239ef38ef4d', 'data/complex/pr471/EXPECTED.json': 'ed1e72239ebebdbfad847fb817e5546f980c1d8d', 'data/complex/pr473/EXPECTED.json': '45ee9fde7fdf6b19b6303372068977201b4ef61c', 'data/complex/pr478/EXPECTED.json': '77f5805cd8125602e8c50f4eaba1691440c611c2', 'data/complex/pr483/EXPECTED.json': 'f7ff643cd54a334bf46c82989ba155eb6e69adde', 'data/complex/pr484/EXPECTED.json': '7f93fcbb9f1c2799fd86dd308ec1e6f0ad2a3264', 'data/eleven/hosting.json': '72b63ff0866db6aec50ecd356d7d007b17bf6475', 'data/eleven/residual-isometries.json': '5c645b267861fd0994d2679885f8e0bbf99640b0', 'data/skeleton/d4part-pairs.json': '7ea439877369b6c2e94bb47980d08944d61454fb', 'data/skeleton/plan-skB.json': '52e341f4f0b441ff88897162cc9f25eb72f34405', 'discovery/README.md': '751a9e82df9c860b496affd423b938cb008e2d88', 'discovery/d4part.py': 'ed7418a0800321d7629e86b4946f77e8cf60a044', 'discovery/host_select.py': '5b50de453ddbd90d433f9ea8ed584308e7ab2d0f', 'discovery/plan.py': '050a3ca42bad8b3d34d149607a7c67de39a52356', 'portable-include/bits/stdc++.h': 'fc5664e929d9a81d9b4926bee049a93330be86ec', 'requirements.txt': '05bdf190fff0fda4cf958441aa15b9d7a9239ad4', 'verify.sh': 'dd7df2a4445f5a8b0d5e336a855a930ab5d34bee'} +blobs=0 +for path,blob in PINNED_BLOBS.items(): + raw=(PKG/path).read_bytes();assert hashlib.sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest()==blob;blobs+=1 +res=read(O/'RESULT.json');exp=read(PKG/'EXPECTED.json');g=read(O/'bit/GLOBAL.json');a=read(O/'bit/AUDIT.json');geo=read(O/'bit/GEOMETRY.json');t=read(O/'bit/GLOBAL-TEMPLATE.json.gz') +assert hashlib.sha256(json.dumps(read(O/'word.json.gz'),sort_keys=True,separators=(',',':')).encode()).hexdigest()==exp['word']['content_sha256'] +assert hashlib.sha256(gzip.decompress((O/'bit/GLOBAL-TEMPLATE.json.gz').read_bytes())).hexdigest()==g['template_sha256']==a['template_sha256']==res['bit_template_sha256'] +assert g['emitted_program_sha256']==a['emitted_program_sha256']==res['emitted_program_sha256']==exp['eleven']['emitted_program_sha256'] +p=Counter() +for call in t['calls']: + for ins in t['local_programs'][call['orientation']]: + if ins[0]==0 and ins[4]:p[ins[4]]+=1 + elif ins[0]==2:p[ins[5]]+=1 +for histogram in t['hosting']['remainders'].values(): + for rank,count in histogram.items(): + if int(rank):p[int(rank)]+=count +summarized={int(k) for k in t['hosting']['remainders']} +for e in t['schedule']: + if e['kind']=='idle' and e['rank'] and e['idx'] not in summarized:p[e['rank']]+=1920 +assert {str(k):v for k,v in p.items()}==a['profile']==res['bit_profile']==exp['eleven']['profile'] +m,W,T,L,V,K,H=78,9600,8,11,120,5,489;E=sum(p.values());physical=W+9;J=8*T*L*(2*V+H)+8*(2*K*V*T)+2*L*T*H+2*g['copy_erase_episodes'] +parts={'local_dispatch':L*T*g['local_additions']+g['bridge_additions'],'high_routes':J*16*(m*m+1)**2,'route_stock':J*physical,'children':E*(8*m*m+8+128*(2*m)**3),'fixed':16*m**3+g['copy_erase_episodes'],'selectors':2*L*T*((W-1)+H*m*(geo['max_route_factors']+144+2+(m-1)+m)),'prefix':int(g['global_prefix_bound']),'one':1} +coefficient=sum(parts.values());level3=(coefficient+1)**3*(E+1)**3 +assert coefficient.bit_length()==parts['prefix'].bit_length()==res['bit']['coefficient_bits']==2119 +assert level3.bit_length()==res['bit']['three_level_coefficient_bits']==6411 +assert 64*((6411+63)//64)==res['bit']['charged_three_level_coefficient_bits']==6464 +physical_exp=0 +while 3**physical_exp<=physical:physical_exp+=1 +row=3*(m*(m+1)//2+physical_exp)+9909+252;assert row==res['bit']['row_coefficient']==19431<20161 +eng=PKG/'code/hub/e8-r740-replica32/code/engines' +def load(name,path=None): + s=importlib.util.spec_from_file_location('review_'+name,path or eng/(name+'.py'));x=importlib.util.module_from_spec(s);s.loader.exec_module(x);return x +M,B,Outer=map(load,['moment','base_two_moment','outer']) +c=Q(res['bit_lower']);step=Q(1,10**24);fb=32*m*m*E;intervals={} +for endpoint in [c,c+step]: + ml,mh=M.moment(p,m,W,endpoint,True);bl,bh=B.moment(m,W,list(p.items()),endpoint);fl,fh=B.moment(m,W,[(1,fb)],endpoint);bl+=fl/Q(10**16);bh+=fh/Q(10**16) + assert (mh<1 and bh<1) if endpoint==c else (ml>1 and bl>1) + intervals[str(endpoint)]={'mercator':[str(ml),str(mh)],'base_two':[str(bl),str(bh)]} +# Each outer result is arithmetic on its cited b; only471 has already been +# independently source-replayed in this session. +outer={} +def assembly(bit,b,allow,charge): + eta=beta=grid=Q(1,10**18);s=min(bit,(1-beta)*b)-Q(1,10**24);chain=[Q(384599,10**10)];cutoffs=[] + for _ in range(6): + old=chain[-1];a=(1-s)*s+s*old;gap=min(s-a,1-a-s,1-a-s*(1-old),1-s);assert 00 for x in ar['strict_constraints'].values()) + controls=[] + for name,kk,ee,bb in [('next_grid',k+grid,eta,beta),('zero_eta',k,Q(0),beta),('zero_beta',k,eta,Q(0)),('unit_beta',k,eta,Q(1))]: + try:Outer.assembly(chain[-1],b,bridge,kk,eta=ee,beta=bb) + except AssertionError:controls.append(name) + else:raise AssertionError(name) + return {'kappa':str(k),'bootstrap':cutoffs,'outer_controls':controls,'slacks':{k:str(v) for k,v in ar['strict_constraints'].items()}} +for name,z in res['kappa'].items(): + b=Q(z['complex_lower']);result=assembly(c,b,20161,6464);assert result['kappa']==z['kappa'] and result['bootstrap']==z['bootstrap'] and result['outer_controls']==z['outer_controls'];outer[name]=result +report={'status':'PASS_INDEPENDENT_PR493_PINNED_SOURCE_INVOICE_AND_EXACT_ASSEMBLY','head':'c3a9a436b84fe44fdc223a5784d84736d1c2d3c7','manifest_sha256':sha(PKG/'MANIFEST.sha256'),'manifest_files':len(manifest),'git_blob_files':blobs,'result_sha256':sha(O/'RESULT.json'),'native_columns_sha256':sha(O/'cout/columns.json'),'native_eleven_columns_sha256':sha(O/'cout/columns_k5.json'),'bit_lower':str(c),'actual_bit_profile':dict(sorted(p.items())),'rank_mass':sum(k*v for k,v in p.items()),'paid_calls':E,'invoice_parts':{k:str(v) for k,v in parts.items()},'prefix_bits':2119,'charged_prefix_bits':2176,'three_level_coefficient_bits':6411,'charged_coefficient_bits':6464,'row_coefficient':row,'retained_row_allowance':20161,'exact_moment_intervals':intervals,'outer':outer,'scope':'This audit independently checks pinned sources and the supplied fresh bit output. Supplier verifier execution and native compiler provenance are bound by the enclosing root verifier. The complex b values here remain cited arithmetic; the enclosing composition must bind its chosen b to a fresh complex replay. PR448 remains information-only disputed split. Inherited all-size compiler, mutable-label, restored-row and analytic contracts remain conditional.'} +REPORT.write_text(json.dumps(report,indent=2)+'\n');print(json.dumps({k:v for k,v in report.items() if k not in ['exact_moment_intervals','outer','invoice_parts','GL_sharp_screen']},indent=2)) diff --git a/research/r489-pooled-retimed-complex/code/audit493/review_local.py b/research/r489-pooled-retimed-complex/code/audit493/review_local.py new file mode 100644 index 0000000000..e341916fc4 --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/audit493/review_local.py @@ -0,0 +1,92 @@ +"""Independent PR493 actual/reflected projector and whole-owner audit, OpenAI Codex. Apache-2.0. +Usage: review_local.py PR493_PACKAGE FRESH_OUTPUT REPORT.json +""" +from pathlib import Path +from fractions import Fraction as Q +from collections import Counter,defaultdict +import gzip,hashlib,json,struct,sys +import sympy as S +if not __debug__:raise RuntimeError('assertions must remain enabled') +assert len(sys.argv)==4, 'usage: review_local.py PR493_PACKAGE FRESH_OUTPUT REPORT.json' +PKG,OUT,REPORT=map(lambda x:Path(x).resolve(),sys.argv[1:]) +read=lambda p:json.loads(gzip.decompress(p.read_bytes()) if p.suffix=='.gz' else p.read_bytes()) +w=read(PKG/'data/bit/bitE8mut-r489.json.gz');t=read(OUT/'bit/GLOBAL-TEMPLATE.json.gz');fs=read(OUT/'records/frames.json')['frames'];state=read(OUT/'records/249-states.json');records=list(struct.iter_unpack('<6i',(OUT/'records/249-records.bin').read_bytes()));v=120;n=2*v+w['R'];assert n==729 +I=S.eye(8);P={};dims={};projector_hash={} +for key,z in fs.items(): + B=S.Matrix(z['B']) if z['B'] else S.zeros(0,8);p=B.T*(B*B.T).inv()*B if B.rows else S.zeros(8);assert p==p.T and p*p==p and p.trace()==z['dim'];P[int(key)]=p;dims[int(key)]=z['dim'] + for rev in (False,True):projector_hash[rev,int(key)]=hashlib.sha256(str(I-p if rev else p).encode()).hexdigest() +results={};transitions=set() +for rev in (False,True): + ori='reverse' if rev else 'forward';cur=[state['final' if rev else 'initial'][str(i)] for i in range(n)]+[-1];rows=[1<=2*v:assert support[s]&~allowed[f]==0;checks+=1 + support[d]|=support[s] + if d=2*v: + assert support[d]&~allowed[f]==0;checks+=1;source_support_checks+=int(d=2*v) or all(not v<=s<2*v for s in ss) for phase in ['D','A','B','C'] for f,d,ss in w[phase]) +assert all(f==0 and v<=d<2*v and all(s>=2*v for s in ss) for f,d,ss in w['D']) +assert all(not v<=d<2*v for f,d,ss in w['A']) and all(v<=d<2*v for f,d,ss in w['B']) +assert w['C']==[[1,d,ss] for f,d,ss in reversed(w['A'])] +# Exact physical owner construction from every complete rational basis. +geo=read(OUT/'bit/GEOMETRY.json');idle={e['idx']:e for e in t['schedule'] if e['kind']=='idle'};bases=[] +for port in geo['ports']: + head=[[Q(x,2) for x in port['q']]]+[[Q(row[j]) for row in port['complement_columns']] for j in range(7)] + assert all(sum(x*y for x,y in zip(a,b))==int(i==j) for i,a in enumerate(head) for j,b in enumerate(head)) + cols=[tuple((i,x.numerator,x.denominator) for i,x in enumerate(col) if x) for col in head]+[((j,1,1),) for j in range(8,78)];assert len(cols)==78;bases.append(cols) +assert all(w['start'][h]==0 for h in range(240,n)) +routecount=0;stream=hashlib.sha256();unique=set();groupcount=0;occupied=defaultdict(set);pending={};mult=Counter() +for call in t['calls']: + active={fam for fam,route in call['owners'][:240]};seen=set();samefamily=defaultdict(set);counts=Counter() + for helper,(fam,route) in enumerate(call['owners'][240:]): + kind,idx,off,width=route;assert kind=='hosted' and fam not in active and width==8 + _,sub=divmod(fam,1200);pair,sp=divmod(sub,240);_,port=divmod(sp,120);child=idle[idx];assert child['pair']==pair + lo,hi=child['source_level'],child['target_level'];axes=list(range(1,8))+list(range(8,8+7*hi)) if lo==-1 else list(range(8+7*lo,8+7*hi));assert len(axes)==child['rank'];foot=axes[off:off+width];assert len(set(foot))==8 + assert not samefamily[fam]&set(foot);samefamily[fam].update(foot) + order=foot+[j for j in range(78) if j not in foot];assert set(order)==set(range(78));sigma=tuple(bases[port][j] for j in order) + # Every full sigma is orthogonal, has inverse sigma^T, and sends the full + # local8 residual to the exact8 assigned basis columns. This is a complete + # rational matrix equality, not merely an integer slot reservation. + assert tuple(sigma[:8])==tuple(bases[port][j] for j in foot) + assert (fam,sigma) not in seen;seen.add((fam,sigma));routecount+=1;counts[fam]+=1 + h=hashlib.sha256(json.dumps(sigma,separators=(',',':')).encode()).hexdigest();unique.add(h);stream.update(json.dumps([call['stage'],call['replica'],helper,fam,h],separators=(',',':')).encode()+b'\n') + key=(idx,fam);assert not occupied[key]&set(foot);occupied[key].update(foot);pending[key]=set(axes) + assert len(seen)==489;groupcount+=len(samefamily) + for count in counts.values():mult[count]+=1 +assert routecount==43032 +for key,foot in occupied.items():assert foot<=pending[key] and foot|(pending[key]-foot)==pending[key] +report={'status':'PASS_INDEPENDENT_PR493_MUTABLE_SOURCE_LEDGER_AND_ACTUAL_OWNER_AUDIT','head':'c3a9a436b84fe44fdc223a5784d84736d1c2d3c7','source_frames':len(P),'exact_oriented_projector_transitions':len(transitions),'orientations':results,'source_support_checks':checks,'mutable_source_destination_support_checks':source_support_checks,'no_targets_feed_sources_or_helpers':True,'literal_source_helper_inverse_cleanup':True,'actual_owner_routes':routecount,'actual_unique_sigma_matrices':len(unique),'cross_idle_call_family_groups':groupcount,'idle_family_completion_groups':len(occupied),'maximum_helpers_per_family':max(mult),'actual_sigma_stream_sha256':stream.hexdigest(),'modular_distinctness':'All routes for a physical family are one dyadic orthogonal port basis times distinct column permutations; equality is impossible over every odd field. Cross-idle assigned footprints are pairwise disjoint.','scope':'Exact native-frame local source/helper restoration and actual complete owner matrices. This does not unconditionally establish inherited all-size mutable-basis compiler, row or analytic contracts.'} +REPORT.write_text(json.dumps(report,indent=2)+'\n');print(json.dumps(report,indent=2)) diff --git a/research/r489-pooled-retimed-complex/code/audit_pooled.py b/research/r489-pooled-retimed-complex/code/audit_pooled.py new file mode 100644 index 0000000000..1e2621684b --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/audit_pooled.py @@ -0,0 +1,103 @@ +"""OpenAI Codex independent serialized cross-replica controller/spectator audit. +Imports no emitter, optimizer, expander, edge-coloring, or source hosting code. +CLI: VERIFIED_VARIANT POOLED_HOSTED OUT.json +""" +import sys,json,gzip,hashlib,copy +from pathlib import Path +from collections import Counter,defaultdict +BASE,OUT,REPORT=map(lambda p:Path(p).resolve(),sys.argv[1:4]);read=lambda p:json.loads(gzip.decompress(p.read_bytes())if p.suffix=='.gz'else p.read_bytes()) +parent=read(BASE/'split-centres/GLOBAL-TEMPLATE.json.gz');canon=read(BASE/'split-centres/CANONICAL-WORD.json.gz');checks=read(BASE/'split-centres/LOCAL-CHECKS.json');ph=read(BASE/'work/complex-nine-native/DATA-PHASES.json');ct=read(OUT/'GLOBAL-TEMPLATE.json.gz');summary=read(OUT/'HOSTED.json');width=[9-len(canon['frames'][canon['start'][240+h]])for h in range(560)];prank={e['child']:e['rank']for e in parent['idle_children']};M=73;T=8;DATA=7680 + +def orthobasis(port): + q=canon['ports'][port];z=next(i for i in range(9)if(q>>i)&1==0);a=q^(1<>i&1 else 0)for i in order]+[1<last.get(e['pair'],-1)and p!=e['pair']} + used=defaultdict(set);roles={};paid=Counter();sigmas={};digest=hashlib.sha256();entering=0;cross=0;touches=defaultdict(list) + for call,old in zip(t['calls'],parent['calls']): + assert {k:v for k,v in call.items()if k!='owners'}=={k:v for k,v in old.items()if k!='owners'} + s,rep,pair=call['stage'],call['replica'],call['pair'];own=call['owners'];assert len(own)==800 and len({f for f,rt in own})==800 and all(0<=f=0 and off+w<=rank[i] + B=OH.idle_basis(canon['ports'][port]);pending=list(map(int,ph['recipes'][port]['idle_children'][i]['orthogonal_axes']));assert len(pending)==rank[i] + occ=[B.index(v)for v in pending[off:off+w]];sp=OH.spectators(canon['ports'][port],pending,off,w)if w<9 else[] + order=occ+sp+[j for j in range(M)if j not in occ and j not in sp];assert len(order)==len(set(order))==M + sigma=[B[j]for j in order];sigmahash=hashlib.sha256(json.dumps(sigma,separators=(',',':')).encode()).hexdigest();sigmas[sigmahash]=sigma + route=[4,i,off,w,sp]if w<9 else[3,i,off];bycall[s,rep][h]=[f,route];entering+=w<9 + cells=set(range(off,off+w));assert not used[i,orp,port]&cells;used[i,orp,port]|=cells + digest.update(json.dumps([s,rep,h,f,sigmahash],separators=(',',':')).encode()+b'\n') +for c in t['calls']: + k=(c['stage'],c['replica']);assert set(bycall[k])==set(range(R)) + c['owners']=c['owners'][:240]+[bycall[k][h]for h in range(R)];assert len({f for f,r in c['owners']})==800 and all(f>1) + return([ar[idx(x)][:]for x in range(N)],[ai[idx(x)][:]for x in range(N)],d) +def run(back=False,mut=None): + a=[identity(f)for f in range(F)];sign=-1 if back else 1 + def call(rep,begin=True,end=True): + src=2*rep;dst=src+1;h=perm(a[4],rep) + private=copy.deepcopy(a[src]) # literal COPY of arbitrary source array + if begin:a[dst]=add(a[dst],h,-1);h=add(h,private,sign) + if end: + a[dst]=add(a[dst],h) + if mut!='omit-dirty-restoration':h=add(h,private,-sign) + assert equal(private,a[src]);private=None # ERASE unchanged copy + h=C(h,0) + if mut=='touch-borrowed-spectator':h=C(h,1) + a[4]=perm(h,rep if mut!='wrong-owner-chart'else 0) + if mut=='interleave-invocations': + call(0,end=False);call(1);call(0,begin=False) + else: + for rep in range(2): + before=copy.deepcopy(a);call(rep) + want=copy.deepcopy(before);want[2*rep+1]=add(want[2*rep+1],want[2*rep],sign);want[4]=C(want[4],rep) + if not all(equal(x,y)for x,y in zip(a,want)):return False + if mut!='omit-idle-remainder':a[4]=C(a[4],2) + expected=[identity(f)for f in range(F)] + for rep in range(2):expected[2*rep+1]=add(expected[2*rep+1],expected[2*rep],sign) + for axis in range(3):expected[4]=C(expected[4],axis) + return all(equal(x,y)for x,y in zip(a,expected)) +controls=['interleave-invocations','omit-dirty-restoration','touch-borrowed-spectator','wrong-owner-chart','omit-idle-remainder'] +for back in(False,True): + assert run(back) + for mut in controls:assert not run(back,mut),(back,mut) +out=dict(status='PASS_EXACT_GAUSSIAN_DYADIC_SERIAL_POOLING_OPERATOR',address_axes=3,addresses_per_array=8,physical_families=5,invocations=2,shared_whole_helper_families=1,all_independent_input_columns=40,scalar_field='Q(i), exact integer Gaussian numerators with explicit powers-of-two denominators',actual_C_definition='C_q=(1+i)I/2+(1-i)X_q/2',complete_scalar_add_copy_erase=True,both_shear_orientations=True,actual_owner_chart_permutations=True,borrowed_spectator_identity_checked=True,commuting_idle_completion=True,mutations_rejected=controls,scope='Finite regression of serial reuse of complete normalized local invocations on one helper family. The candidate serialized residual wrappers and local800column identity are separately admitted source484evidence; this is not a replacement local-word proof or enormouscover enumeration.') +Path(sys.argv[1]).write_text(json.dumps(out,indent=2)+'\n');print(json.dumps(out,indent=2)) diff --git a/research/r489-pooled-retimed-complex/code/guarded_lemma.py b/research/r489-pooled-retimed-complex/code/guarded_lemma.py new file mode 100644 index 0000000000..0388744e39 --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/guarded_lemma.py @@ -0,0 +1,43 @@ +"""Guard PR484 dyadic int64 expansions before executing exact arithmetic. +OpenAI Codex. Upstream simulator is unchanged; inherited identity checked fresh. +Usage: guarded_lemma.py COMPLEX_PACKAGE SCRIPT [script arguments...] +""" +import sys,runpy,json +from pathlib import Path +SRC=Path(sys.argv[1]).resolve()/'code/lemmaG';script=sys.argv[2];args=sys.argv[3:] +sys.path.insert(0,str(SRC));import gd +stats=dict(add_calls=0,scale_calls=0,primitive_calls=0,maximum_proved_numerator_bits=0) +def maxabs(a):return max(abs(int(a.min())),abs(int(a.max())))if a.size else 0 +def record_bound(x,op): + stats['maximum_proved_numerator_bits']=max(stats['maximum_proved_numerator_bits'],x.bit_length());assert x<1<<63,(op,'mathematical int64 overflow',x) +oldadd=gd.GD.add_scaled +def add(self,src,num,den): + assert den>0 and den&(den-1)==0 + e=den.bit_length()-1;D=max(self.d,src.d+e);sa=D-self.d;sb=D-src.d-e + for a,b in((self.re,src.re),(self.im,src.im)):record_bound((maxabs(a)< 0 and type(n) is int and n > 0 for r, n in profile.items()) +assert live == host['live'] == owner['live'] and physical == host['physical'] == owner['physical'] +assert profile == {int(r): count for r, count in host['global_profile'].items()} +mass = sum(r * n for r, n in profile.items()) +assert mass == owner['rank_mass'] == host['rank_mass'] and m * live - mass == owner['deficit'] == host['deficit'] == 2496 +assert max(profile) == host['maxchild'] and owner['hosted_residuals'] == host['hosted_residuals'] +assert assembly['owner_audit_sha256'] == sha(owner_path) and assembly['invoice_sha256'] == sha(invoice_path) +assert assembly['bit_result_sha256'] == sha(bit_path) and assembly['bit_template_sha256'] == bit['bit_template_sha256'] + +# Independently rebuild the stock-sensitive finite invoice. The scalar audit +# separately reconstructs the complete local primitive and wrapper charge. +old_inv = integration['finite_invoice'] +pervertex = old_inv['pervertex'] +rebased = pervertex - 65 * integration['physical'] + 65 * physical - integration['live'] + live +used = max(pervertex, rebased) +compiler = 64 * (m + 1) ** 3 +assert invoice['unhosted_pervertex'] == pervertex +assert invoice['hosted_rebased_pervertex'] == rebased +assert invoice['conservative_pervertex_used'] == used +assert invoice['compiler'] == old_inv['compiler'] == compiler +for field in ['local_adapters', 'local_primitive_bound']: + assert invoice[field] == old_inv[field], field +group = 2 ** ((m // 2) ** 2) * math.prod(2 ** (2 * i) - 1 for i in range(1, m // 2 + 1)) +stock, paid_mass = group * physical, group * mass +logical = group * used + 64 +router = compiler * (logical + 1) * (stock + 1) ** 2 +G, E, C0 = 1 << 30000, 1 << 100000, 1 << 210000 +B = paid_mass + E +literal = 2 * G * stock ** 2 + 8 * paid_mass + 4 * stock + 4 + 32 * m +complex_row = 2 * stock.bit_length() + 9909 + 252 +finite = dict( + physical_stock_bits=stock.bit_length(), router_bits=router.bit_length(), + literal_bits=literal.bit_length(), physical_row_coefficient=complex_row, + retained_row_coefficient=20161, required_C0_bits=(32 * m * B * B).bit_length(), + halving_integer_inequality=[m * m, 2 * max(profile) ** 2], + G_exponent=30000, E_exponent=100000, C0_exponent=210000, +) +assert invoice['finite'] == finite +strict = dict( + local_primitive_bound=invoice['local_primitive_bound'] < 1 << 48, + logical=logical < 1 << 6050, router=router < G, literal=literal < E, + mass=B < 1 << 100001, precision=32 * m * B * B < C0, + tape=2 * B + 18 < C0, row=complex_row < 20161, + halving=m * m > 2 * max(profile) ** 2, +) +assert all(strict.values()) and invoice['strict_checks'] == strict + + +def load_engine(name): + path = changed / 'work/pr361/code/engines' / (name + '.py') + spec = importlib.util.spec_from_file_location('composition_review_' + name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +M, Other, Outer = map(load_engine, ['moment', 'base_two_moment', 'outer']) +b = Q(assembly['complex_lower']) +step = Q(1, 10 ** 24) +assert b > 0 and (b / step).denominator == 1 +assert Q(assembly['complex_decimal']) == b and Q(assembly['next_b_rejected']) == b + step +fallback = 32 * m * m * sum(profile.values()) +moments = [] +for endpoint, accept in [(b, True), (b + step, False)]: + ml, mh = M.moment(profile, m, live, endpoint, True) + bl, bh = Other.moment(m, live, list(profile.items()), endpoint) + fl, fh = Other.moment(m, live, [(1, fallback)], endpoint) + bl, bh = bl + fl / 10 ** 16, bh + fh / 10 ** 16 + assert (mh < 1 and bh < 1) if accept else (ml > 1 and bl > 1) + moments.append(dict(endpoint=str(endpoint), mercator=[str(ml - 1), str(mh - 1)], base_two=[str(bl - 1), str(bh - 1)], accept=accept)) +assert assembly['exact_moment_receipts'] == moments + +# The historical two-level field is deliberately absent: use fresh depth-three +# invoice fields directly, even though the complex supplier binds numerically. +c = Q(bit['bit_lower']) +charge = bit['bit']['charged_three_level_coefficient_bits'] +row = max(20161, bit['bit']['row_coefficient'], complex_row) +assert charge == 6464 and bit['bit']['row_coefficient'] == 19431 + + +def check_bit_binding(candidate): + assert Q(candidate['bit_lower']) == c + assert candidate['bit_charged_three_level_coefficient_bits'] == charge + assert candidate['bit_prefix_bits'] == bit['bit']['charged_prefix_bits'] + assert candidate['external_row_allowance'] == row + + +check_bit_binding(assembly) +binding_controls = [] +for field, value in [ + ('bit_charged_three_level_coefficient_bits', bit['bit']['charged_prefix_bits']), + ('bit_charged_three_level_coefficient_bits', charge - 64), + ('external_row_allowance', row - 1), + ('bit_lower', str(c + step)), +]: + bad = deepcopy(assembly) + bad[field] = value + try: + check_bit_binding(bad) + except AssertionError: + binding_controls.append(dict(field=field, rejected_value=value)) + else: + raise AssertionError('binding mutation accepted: ' + field) + +eta = beta = grid = Q(1, 10 ** 18) +saving = min(c, (1 - beta) * b) - step +assert 0 < saving < c and saving < (1 - beta) * b +chain, cutoffs = [Q(384599, 10 ** 10)], [] +for _ in range(6): + old = chain[-1] + new = (1 - saving) * saving + saving * old + gap = min(saving - new, 1 - new - saving, 1 - new - saving * (1 - old), 1 - saving) + assert old < new < saving < 1 - new and gap > 0 + cutoff = max(math.ceil(36 / gap ** 2), math.ceil(2 * (4 + charge) / gap)) + assert cutoff * gap ** 2 >= 36 and cutoff * gap >= 2 * (4 + charge) + cutoffs.append(dict(gap=str(gap), cutoff_log2=str(cutoff))) + chain.append(new) +q = chain[-1] * (1 - 2 * eta) +ticks = ((1 - eta) * q / (1 + q)) / grid +kappa = grid * ((ticks.numerator - 1) // ticks.denominator) +assert assembly['kappa'] == str(kappa) and assembly['bootstrap'] == cutoffs +assert assembly['binding_component'] == ('bit' if c < (1 - beta) * b else 'complex') +bridge = {'semantic': {'C0': {'base': 2, 'exponent': 210000}, 'strict_literal_gap': 1}, 'rows': {'degree_gap': Q(10 ** 6) - Q(51 * row, 25)}} +outer = Outer.assembly(chain[-1], b, bridge, kappa, eta=eta, beta=beta) +slacks = outer['strict_constraints'] +assert len(slacks) == 47 and all(value > 0 for value in slacks.values()) +assert assembly['strict_outer_constraints'] == {name: str(value) for name, value in slacks.items()} +controls = [] +for name, k, e, be in [ + ('next_grid', kappa + grid, eta, beta), ('zero_eta', kappa, Q(0), beta), + ('zero_beta', kappa, eta, Q(0)), ('unit_beta', kappa, eta, Q(1)), +]: + try: + Outer.assembly(chain[-1], b, bridge, k, eta=e, beta=be) + except AssertionError: + controls.append(name) + else: + raise AssertionError(name) +assert assembly['outer_controls'] == controls + +report = dict( + status='PASS_INDEPENDENT_FRESH_SUPPLIER_COMPOSITION_GATE', + bit_result_sha256=sha(bit_path), assembly_sha256=sha(assembly_path), + owner_audit_sha256=sha(owner_path), invoice_sha256=sha(invoice_path), + fresh_complex_integration_sha256=sha(split / 'INTEGRATION.json'), + fresh_base_template_sha256=base['template_sha256'], + changed_template_sha256=host['template_sha256'], + preserved_local_program_sha256=object_sha(new_template['local_programs']), + preserved_fields=preserved_fields, live=live, physical=physical, + profile=profile, rank_mass=mass, finite=finite, + bit_lower=str(c), complex_lower=str(b), kappa=str(kappa), + bit_charged_three_level_coefficient_bits=charge, + bit_row_coefficient=bit['bit']['row_coefficient'], external_row_allowance=row, + strict_outer_constraints=47, outer_controls=controls, + binding_mutations_rejected=binding_controls, + scope='Arithmetic and fresh-output binding gate. Enclosing fresh root execution must bind both complete pinned supplier replays, physical owner/controller admission, scalar invoice and compiler provenance. Inherited Lemma A spectator borrowing, all-size compiler/common-label/restored-row/precision/tape and analytic-transfer contracts remain conditional.', +) +report_path.write_text(json.dumps(report, indent=2) + '\n') +print(report['status'], 'live', live, 'kappa', str(kappa), flush=True) diff --git a/research/r489-pooled-retimed-complex/code/review_frames.py b/research/r489-pooled-retimed-complex/code/review_frames.py new file mode 100644 index 0000000000..3b75db5a64 --- /dev/null +++ b/research/r489-pooled-retimed-complex/code/review_frames.py @@ -0,0 +1,295 @@ +"""Independent finite common-frame retiming review (no supplier imports). + +Checks actual GF(2) subspaces, fixed scalar payloads/boundaries, raw-to-canonical +transport, and every event in both emitted label ledgers. Does not discharge +Gaussian identities, exact scalar arithmetic, global invoices or asymptotics. +""" +import argparse +import copy +import gzip +import hashlib +import json +from collections import Counter +from functools import lru_cache +from pathlib import Path + +if not __debug__: + raise RuntimeError('This verifier requires Python assertions enabled.') + +def read(p): + return json.load(gzip.open(p)) + +def sha(p): + return hashlib.sha256(Path(p).read_bytes()).hexdigest() + +def digest(x): + return hashlib.sha256(json.dumps(x,sort_keys=True,separators=(',', ':')).encode()).hexdigest() + +@lru_cache(None) +def span(vectors): + s={0} + for v in vectors: + assert type(v) is int and 0 <= v < 512 + s |= {u ^ v for u in tuple(s)} + return frozenset(s) + +def sub(vectors): + return span(tuple(vectors)) + +ZERO=sub([]) +FULL=sub([1 << i for i in range(9)]) + +def rank(s): + n=len(s) + assert n and n & (n-1)==0 + return n.bit_length()-1 + +def perp(p): + return frozenset(q for q in range(512) if (p&q).bit_count()%2==0) + +def tau(q): + return q ^ (43 if (q&43).bit_count()%2 else 0) + +def transported(s): + return frozenset(map(tau,s)) + +def regs(e): + assert e[0] in ('add','scale') + return e[1:3] if e[0]=='add' else e[1:2] + +def raw_ledger(w): + v=len(w['ports']); n=2*v+w['report']['R'] + cur=[sub([p]) for p in w['ports']]+[ZERO]*v+[sub(w['start_extra'].get(str(r),[])) for r in range(2*v,n)] + initial=cur[:] + final=[FULL]*v+[perp(p) for p in w['ports']]+[FULL]*w['report']['R'] + paid=Counter(); mass=[0]*n; center_mass=0; climbs=0 + def climb(r,f): + nonlocal climbs + assert 0 <= r < n and cur[r] <= f, ('non-nested raw climb',r,cur[r],f) + if cur[r] != f: + d=rank(f)-rank(cur[r]); assert d>0 + paid[d]+=1; mass[r]+=d; climbs+=1;cur[r]=f + for part in ('A','B'): + if part=='B': + for t in range(v): + assert cur[v+t]==sub(w['target_levels'].get(str(t),[])), ('target cut',t) + for r,frame in zip(w['centers'],w['center_frames']): + assert cur[r]==sub(frame), ('center cut',r) + served={sub(w['target_levels'].get(str(e[1]-v),[])) for e in w['cut'] if e[2]==r} + old=cur[r] + for f in sorted(served,key=rank,reverse=True): + assert f <= old + if f!=old: + d=rank(old)-rank(f);paid[d]+=1;center_mass+=d;old=f + assert old==ZERO, ('center bottom',r) + for e in w[part]: + f=sub(e[-1]); assert len(f)==2**len(e[-1]),'dependent raw frame' + for r in regs(e):climb(r,f) + assert all(cur[r]==f for r in regs(e)) + for r,f in enumerate(final):climb(r,f) + assert mass==[rank(f)-rank(i) for i,f in zip(initial,final)] + assert dict(paid)=={int(k):v for k,v in w['report']['local_profile'].items()} + return dict(profile=dict(sorted(paid.items())),rank_mass=sum(k*v for k,v in paid.items()),child_count=sum(paid.values()),climbs=climbs,center_rank_mass=center_mass,per_register_telescoping=True) + +def invariants(old,new): + assert set(old)==set(new) + changed={} + for k in old: + if k in ('A','B'): + assert [e[:-1] for e in old[k]]==[e[:-1] for e in new[k]], ('scalar payload/order changed',k) + changed[k]=sum(sub(a[-1])!=sub(b[-1]) for a,b in zip(old[k],new[k])) + elif k=='report': + for key in set(old[k])|set(new[k]): + if key not in ('local_profile','global_profile'): + assert old[k].get(key)==new[k].get(key),('report field changed',key) + else: + assert old[k]==new[k],('fixed raw field changed',k) + assert old['A'][:531]==new['A'][:531], 'compensation and kernel prelude changed' + return dict(changed_gate_frames=changed,unchanged_scalar_gates=len(new['A'])+len(new['B']),unchanged_initial_A_events_including_frames=531,fixed_fields=sorted(set(old)-{'A','B','report'})) + +def canonical_binding(w,c,base_c): + v=len(w['ports']); n=2*v+w['report']['R'];f=[sub(x) for x in c['frames']] + assert (v,n,c['h'],c['R'])==(c['v'],len(c['start']),9,w['report']['R']) + assert f[0]==ZERO and f[1]==FULL and len(set(f))==len(f) + assert all(len(s)==2**len(b) for s,b in zip(f,c['frames'])) + assert all(tau(tau(x))==x for x in range(512)) + assert all(tau(x^y)==tau(x)^tau(y) and (x&y).bit_count()%2==(tau(x)&tau(y)).bit_count()%2 for x in range(512) for y in range(512)) + assert len(set(c['ports']))==v and set(map(tau,w['ports']))==set(c['ports']) + mapping={r:c['ports'].index(tau(p)) for r,p in enumerate(w['ports'])} + mapping.update({r+v:mapping[r]+v for r in range(v)}) + mapping.update({r:r for r in range(2*v,n)}) + assert set(mapping)==set(range(n)) and len(set(mapping.values()))==n + for k in ('A','B','cut','cleanup','precondition'): + assert len(w[k])==len(c[k]) + for raw,can in zip(w[k],c[k]): + x=copy.deepcopy(raw) + for j in range(1,3 if x[0]=='add' else 2):x[j]=mapping[x[j]] + assert x[:-1]==can[:-1],('canonical payload',k) + assert (can[-1] is None) if raw[-1] is None else f[can[-1]]==transported(sub(raw[-1])), ('canonical frame',k) + starts=[sub([p]) for p in w['ports']]+[ZERO]*v+[sub(w['start_extra'].get(str(r),[])) for r in range(2*v,n)] + finals=[FULL]*v+[perp(p) for p in w['ports']]+[FULL]*w['report']['R'] + for r in range(n): + assert f[c['start'][mapping[r]]]==transported(starts[r]), ('canonical start',r) + assert f[c['final'][mapping[r]]]==transported(finals[r]), ('canonical final',r) + assert c['centers']==[mapping[r] for r in w['centers']] + assert [f[i] for i in c['center_frames']]==[transported(sub(x)) for x in w['center_frames']] + assert {str(mapping[v+int(t)]-v):transported(sub(x)) for t,x in w['target_levels'].items()}=={str(t):f[x] for t,x in c['target_levels'].items()} + assert c['local_profile']==w['report']['local_profile'] + bf=[sub(x) for x in base_c['frames']] + for k in ('compensation','precondition','cleanup','cut'): + assert [e[:-1] for e in c[k]]==[e[:-1] for e in base_c[k]], ('baseline canonical payload',k) + assert [None if e[-1] is None else f[e[-1]] for e in c[k]]==[None if e[-1] is None else bf[e[-1]] for e in base_c[k]], ('baseline canonical frame',k) + for k in ('start','final','center_frames'): + assert [f[i] for i in c[k]]==[bf[i] for i in base_c[k]], ('baseline canonical boundary',k) + assert c['ports']==base_c['ports'] and c['centers']==base_c['centers'] + return dict(transport_vector=43,transport_exhaustively_orthogonal_and_linear=True,register_permutation_bijective=True,all_raw_canonical_incidences_bound=True,fixed_compensation_operations=len(c['compensation']),actual_frame_count=len(f)) + +def scalar(e,back): + x=copy.deepcopy(e[:-1]) + if back: + if x[0]=='add':x[1],x[2]=x[2],x[1];x[3]=-x[3] + else:x[2],x[3]=x[3],x[2] + for j in range(1,3 if x[0]=='add' else 2):x[j]=['L',x[j]] + return x + +def ledger(c,events,back): + v=c['v'];n=2*v+c['R'];f=[sub(x) for x in c['frames']] + cur=[f[i] for i in c['start']]; initial=cur[:] + phases=['zero_frame_precondition','entry_adapters','A','centers','B','final','exit_adapters','full_frame_cleanup','done'] + phases_seen=[];phase=None;scalars={p:[] for p in phases}; center_events=[] + paid=Counter();mass=[0]*n;wrappers=Counter();adapters=Counter();touched=set();active=None;private={};private_life=Counter();center_mass=Counter();event_counts=Counter();actual_edges=set() + entering={r for r in range(2*v,n) if cur[r]!=ZERO} + for index,e in enumerate(events): + tag=e[0];event_counts[tag]+=1 + if tag=='phase': + assert active is None + if phase=='centers': + assert set(private)==set(range(len(c['centers']))) + phase=e[1];phases_seen.append(phase) + assert phases_seen==phases[:len(phases_seen)] + if phase=='centers': + assert all(cur[v+t]==f[c.get('target_levels',{}).get(str(t),0)] for t in range(v)) + assert all(cur[r]==f[q] for r,q in zip(c['centers'],c['center_frames'])) + if phase=='exit_adapters':assert cur==[f[i] for i in c['final']] + continue + assert phase in phases + if tag=='climb': + _,part,r,a,b,d=e + assert phase==part and phase in ('A','B','final') and active is None + assert cur[r]==f[a] and f[a] < f[b] and d==rank(f[b])-rank(f[a]),('emitted climb',back,index) + assert r not in entering or wrappers['pre',r]==1 + actual_edges.add((a,b)) + cur[r]=f[b];paid[d]+=1;mass[r]+=d;touched.add(r) + elif tag=='center': + _,k,a,b,d=e + assert phase=='centers' and active==k and private[k]==f[a] + assert f[a]0 + actual_edges.add((a,b)) + private[k]=f[b];paid[d]+=1;center_mass[k]+=d;center_events.append(e) + elif tag=='adapter': + _,kind,r,q=e + assert 0<=r E1)", + "violates": "G2 (monotone nested chain; selection condition (b))", + "checker_flags": [ + "ACC", + "G2" + ], + "rejected": true, + "first_messages": [ + "forward: G2 climb at 13505 of 200 4->2 not ascending nested", + "forward: ACC paid profile {2: 265, 1: 2384, -1: 1, 3: 530, 4: 84, 5: 270, 6: 92, 8: 17, 7: 1} != word {'1': 2385, '2': 264, '3': 530, '4': 84, '5': 270, '6': 92, '7': 1, '8': 17}", + "backward: G2 climb at 13505 of 200 4->2 not ascending nested" + ], + "physics": { + "forward": "PASS", + "backward": "PASS" + }, + "seconds": 1.1 + }, + { + "mutant": "M3b entering helper leaves the nested chain (E_j -> X -> F, X not containing E_j)", + "violates": "G2 (monotone nested chain; selection condition (a))", + "checker_flags": [ + "ACC", + "G2" + ], + "rejected": true, + "first_messages": [ + "forward: G2 climb at 14058 of 374 2->8 not ascending nested", + "forward: ACC paid profile {1: 2385, 2: 264, 0: 1, 3: 530, 4: 84, 5: 270, 6: 92, 8: 17, 7: 1} != word {'1': 2385, '2': 264, '3': 530, '4': 84, '5': 270, '6': 92, '7': 1, '8': 17}", + "backward: G2 climb at 14058 of 374 2->8 not ascending nested" + ], + "physics": { + "forward": "PASS", + "backward": "PASS" + }, + "seconds": 1.0 + }, + { + "mutant": "M4 scatter into a level-L1 target after the copy descended below L1", + "violates": "G3 (scatter meets the target at its level)", + "checker_flags": [ + "G0" + ], + "rejected": true, + "first_messages": [ + "forward: G0 add at 18384 ('L', 194)<-('C', 1) frame 5 but labels 5,4 (centers)" + ], + "physics": { + "forward": "FAIL (registers [129, 194])" + }, + "seconds": 0.5 + }, + { + "mutant": "M5 last centre descent step skipped (level-0 targets scattered at L_last)", + "violates": "G3 (chain reaches every served level; bottom 0)", + "checker_flags": [ + "ACC", + "G0" + ], + "rejected": true, + "first_messages": [ + "forward: G0 add at 18398 ('L', 127)<-('C', 1) frame 0 but labels 0,2 (centers)", + "forward: G0 add at 18399 ('L', 185)<-('C', 1) frame 0 but labels 0,2 (centers)" + ], + "physics": { + "forward": "FAIL (registers [121, 122, 123, 127])" + }, + "seconds": 0.5 + }, + { + "mutant": "M6 centre copy taken at the wrong label (after the first descent)", + "violates": "G3 (copy at the centre label c_k)", + "checker_flags": [ + "G3" + ], + "rejected": true, + "first_messages": [ + "forward: G3 centre step at 18380 on a dead copy 1", + "forward: G3 copy at 18381 from ('L', 64) at label 481 but frame 5" + ], + "physics": { + "forward": "FAIL (registers [121, 122, 123, 124])" + }, + "seconds": 0.4 + }, + { + "mutant": "M7 a child of another register runs while a centre copy is live", + "violates": "G3 (copy lifetime)", + "checker_flags": [ + "G3" + ], + "rejected": true, + "first_messages": [ + "forward: G3 climb at 18382 of 503 while centre copy [1] live" + ], + "physics": { + "forward": "PASS" + }, + "seconds": 0.5 + }, + { + "mutant": "M8 centre chain leaves the centre frame (c_k -> X -> L1, X not inside c_k)", + "violates": "G3 (nested chain inside c_k; selection condition (c))", + "checker_flags": [ + "ACC", + "G3" + ], + "rejected": true, + "first_messages": [ + "forward: G3 centre step at 18381 481->506 not a strict nested descent", + "forward: ACC paid profile {1: 2385, 2: 266, 3: 530, 4: 83, 5: 270, 6: 92, 8: 17, 7: 1} != word {'1': 2385, '2': 264, '3': 530, '4': 84, '5': 270, '6': 92, '7': 1, '8': 17}" + ], + "physics": { + "forward": "PASS" + }, + "seconds": 0.5 + }, + { + "mutant": "M9 compensation coefficient doubled", + "violates": "S (scalar identity)", + "checker_flags": [ + "S" + ], + "rejected": true, + "first_messages": [ + "forward: S column mismatch at register 186", + "forward: S column mismatch at register 200", + "backward: S column mismatch at register 374" + ], + "physics": { + "forward": "FAIL (registers [186, 200])", + "backward": "FAIL (registers [374])" + }, + "seconds": 1.2 + }, + { + "mutant": "M10 compensation moved after the helper started climbing", + "violates": "G0 + S (compensation reads the entrance value)", + "checker_flags": [ + "G0" + ], + "rejected": true, + "first_messages": [ + "forward: G0 add at 14058 ('L', 200)<-('L', 374) frame 2 but labels 4,148 (A)", + "backward: G0 add at 14058 ('L', 374)<-('L', 200) frame 2 but labels 148,4 (A)" + ], + "physics": { + "forward": "FAIL (registers [186, 200])", + "backward": "FAIL (registers [374])" + }, + "seconds": 1.2 + }, + { + "mutant": "M11 kernel donor update with the donor still at label 0", + "violates": "G0 (common label at a nonzero-frame kernel update; inherited #471)", + "checker_flags": [ + "ACC", + "G0" + ], + "rejected": true, + "first_messages": [ + "forward: G0 add at 13547 ('L', 368)<-('L', 396) frame 6 but labels 0,6 (A)", + "forward: ACC paid profile {1: 2384, 2: 263, 3: 531, 4: 84, 5: 270, 6: 92, 8: 17, 7: 1} != word {'1': 2385, '2': 264, '3': 530, '4': 84, '5': 270, '6': 92, '7': 1, '8': 17}", + "backward: G0 add at 13547 ('L', 396)<-('L', 368) frame 6 but labels 6,0 (A)" + ], + "physics": { + "forward": "FAIL (registers [130, 188, 206, 221])", + "backward": "FAIL (registers [396])" + }, + "seconds": 1.1 + }, + { + "mutant": "M12 R_E^-1 wrapper after the first gate on the helper", + "violates": "G1 (wrapper surrounds the whole invocation)", + "checker_flags": [ + "G1" + ], + "rejected": true, + "first_messages": [ + "forward: G1 pre wrapper of 374 not the first event touching it", + "forward: G1 pre wrapper of 374 outside entry adapters", + "backward: G1 pre wrapper of 374 not the first event touching it" + ], + "physics": { + "forward": "FAIL (registers [186, 200])", + "backward": "FAIL (registers [374])" + }, + "seconds": 1.2 + }, + { + "mutant": "M13 L_E^-1 wrapper dropped", + "violates": "G1 (wrapper surrounds the whole invocation)", + "checker_flags": [ + "G1" + ], + "rejected": true, + "first_messages": [ + "forward: G1 entering helper 374 without post wrapper", + "backward: G1 entering helper 374 without post wrapper" + ], + "physics": { + "forward": "FAIL (registers [374])", + "backward": "FAIL (registers [374])" + }, + "seconds": 1.0 + } + ] +} diff --git a/research/r489-pooled-retimed-complex/provenance/NOMINATION.json b/research/r489-pooled-retimed-complex/provenance/NOMINATION.json new file mode 100644 index 0000000000..3ad6a028ce --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/NOMINATION.json @@ -0,0 +1,847 @@ +{ + "histogram": { + "1": 148282, + "2": 66816, + "3": 7408, + "4": 19728, + "5": 24368, + "6": 1744, + "7": 1800, + "8": 4376 + }, + "live": 7746, + "banks": 66, + "unhosted_per_replica": { + "(6, 9)": 66 + }, + "deficit": 2496, + "status": "NOMINATION_ONLY", + "scipy_status": 0, + "message": "Optimization terminated successfully. (HiGHS Status 7: Optimal)", + "mip_gap": 0.0, + "objective": 30445.167647508395, + "old_objective": 30429.840815766052, + "b": 0.001326789535340266, + "patterns": [ + [ + 0, + [ + [ + 0, + 9 + ] + ], + 2 + ], + [ + 0, + [ + [ + 0, + 9 + ], + [ + 1, + 7 + ] + ], + 14 + ], + [ + 0, + [ + [ + 0, + 8 + ], + [ + 1, + 8 + ] + ], + 104 + ], + [ + 1, + [], + 120 + ], + [ + 2, + [ + [ + 0, + 9 + ] + ], + 66 + ], + [ + 2, + [ + [ + 0, + 7 + ], + [ + 1, + 9 + ] + ], + 14 + ], + [ + 2, + [ + [ + 1, + 9 + ] + ], + 40 + ], + [ + 3, + [], + 16 + ], + [ + 3, + [ + [ + 2, + 8 + ] + ], + 104 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ] + ], + 78 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 7 + ], + [ + 3, + 7 + ] + ], + 14 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 5 + ], + [ + 3, + 9 + ] + ], + 4 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 3, + 8 + ] + ], + 24 + ], + [ + 5, + [], + 16 + ], + [ + 5, + [ + [ + 4, + 8 + ] + ], + 104 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ] + ], + 16 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 5 + ] + ], + 4 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 1, + 5 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ] + ], + 4 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ] + ], + 16 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 8 + ] + ], + 76 + ], + [ + 6, + [ + [ + 0, + 5 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ] + ], + 4 + ], + [ + 7, + [], + 106 + ], + [ + 7, + [ + [ + 4, + 7 + ] + ], + 14 + ], + [ + 8, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ], + [ + 4, + 9 + ] + ], + 54 + ], + [ + 8, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ] + ], + 66 + ], + [ + 9, + [], + 16 + ], + [ + 9, + [ + [ + 6, + 8 + ] + ], + 104 + ], + [ + 10, + [ + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ] + ], + 120 + ], + [ + 11, + [], + 120 + ], + [ + 12, + [ + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 90 + ], + [ + 12, + [ + [ + 3, + 9 + ], + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 30 + ], + [ + 13, + [ + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ] + ], + 2 + ], + [ + 13, + [ + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 106 + ], + [ + 13, + [ + [ + 3, + 9 + ], + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 8 + ], + [ + 13, + [ + [ + 3, + 8 + ], + [ + 4, + 5 + ], + [ + 5, + 8 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 14, + [ + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ] + ], + 110 + ], + [ + 14, + [ + [ + 5, + 7 + ], + [ + 6, + 7 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 6 + ], + [ + 14, + [ + [ + 5, + 5 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 15, + [ + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 5 + ] + ], + 4 + ], + [ + 15, + [ + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 5 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 15, + [ + [ + 5, + 9 + ], + [ + 6, + 5 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 15, + [ + [ + 5, + 8 + ], + [ + 6, + 9 + ], + [ + 8, + 9 + ] + ], + 100 + ], + [ + 15, + [ + [ + 5, + 7 + ], + [ + 6, + 7 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 8 + ], + [ + 16, + [ + [ + 7, + 9 + ] + ], + 46 + ], + [ + 16, + [ + [ + 7, + 9 + ], + [ + 8, + 7 + ] + ], + 14 + ], + [ + 16, + [ + [ + 8, + 9 + ] + ], + 60 + ], + [ + 17, + [ + [ + 7, + 9 + ] + ], + 2 + ], + [ + 17, + [ + [ + 7, + 8 + ], + [ + 8, + 8 + ] + ], + 104 + ], + [ + 17, + [ + [ + 7, + 7 + ], + [ + 8, + 9 + ] + ], + 14 + ] + ] +} diff --git a/research/r489-pooled-retimed-complex/provenance/POOLED-ALLOCATION.json b/research/r489-pooled-retimed-complex/provenance/POOLED-ALLOCATION.json new file mode 100644 index 0000000000..0540952b13 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/POOLED-ALLOCATION.json @@ -0,0 +1,1406 @@ +{ + "status": "EXACT_INTEGER_ALL_HOSTED_ALLOCATION_PROFILE_ONLY_COLORING_PENDING", + "T": 8, + "ambient": 73, + "live": 7680, + "banked_residuals": 0, + "profile": { + "1": 148440, + "2": 66816, + "3": 7472, + "4": 19728, + "5": 25664, + "6": 144, + "7": 1800, + "8": 4120 + }, + "root_float": 0.0013338541562084585, + "patterns": [ + [ + 0, + [ + 8, + 8 + ], + 832 + ], + [ + 0, + [ + 9 + ], + 128 + ], + [ + 2, + [ + 9 + ], + 736 + ], + [ + 2, + [ + 9, + 7 + ], + 224 + ], + [ + 1, + [], + 848 + ], + [ + 1, + [ + 7 + ], + 112 + ], + [ + 3, + [], + 128 + ], + [ + 3, + [ + 8 + ], + 832 + ], + [ + 4, + [ + 9, + 9, + 9 + ], + 928 + ], + [ + 4, + [ + 9, + 9, + 9, + 5 + ], + 32 + ], + [ + 6, + [ + 8, + 8, + 8, + 8 + ], + 152 + ], + [ + 6, + [ + 9, + 8, + 8, + 7 + ], + 112 + ], + [ + 6, + [ + 9, + 9, + 9 + ], + 600 + ], + [ + 6, + [ + 9, + 9, + 9, + 5 + ], + 96 + ], + [ + 5, + [ + 5 + ], + 16 + ], + [ + 5, + [ + 7 + ], + 112 + ], + [ + 5, + [ + 8 + ], + 832 + ], + [ + 7, + [], + 944 + ], + [ + 7, + [ + 5 + ], + 16 + ], + [ + 8, + [ + 9, + 9, + 9, + 9, + 9 + ], + 960 + ], + [ + 10, + [ + 9, + 9, + 9, + 9, + 9 + ], + 960 + ], + [ + 9, + [], + 960 + ], + [ + 11, + [], + 16 + ], + [ + 11, + [ + 7 + ], + 112 + ], + [ + 11, + [ + 8 + ], + 832 + ], + [ + 12, + [ + 9, + 9, + 9, + 9, + 9 + ], + 960 + ], + [ + 13, + [ + 9, + 9, + 9, + 9, + 9 + ], + 960 + ], + [ + 14, + [ + 8, + 8, + 8, + 8 + ], + 208 + ], + [ + 14, + [ + 9, + 9, + 7, + 7 + ], + 56 + ], + [ + 14, + [ + 9, + 9, + 9 + ], + 632 + ], + [ + 14, + [ + 9, + 9, + 9, + 5 + ], + 64 + ], + [ + 15, + [ + 9, + 9, + 9 + ], + 896 + ], + [ + 15, + [ + 9, + 9, + 9, + 5 + ], + 64 + ], + [ + 16, + [ + 8, + 8 + ], + 416 + ], + [ + 16, + [ + 9 + ], + 432 + ], + [ + 16, + [ + 9, + 7 + ], + 112 + ], + [ + 17, + [ + 8, + 8 + ], + 416 + ], + [ + 17, + [ + 9 + ], + 432 + ], + [ + 17, + [ + 9, + 7 + ], + 112 + ] + ], + "stage_assignments": [ + [ + 0, + 9, + 1, + 128 + ], + [ + 0, + 8, + 0, + 832 + ], + [ + 0, + 8, + 1, + 832 + ], + [ + 2, + 9, + 0, + 960 + ], + [ + 2, + 7, + 0, + 112 + ], + [ + 2, + 7, + 1, + 112 + ], + [ + 1, + 7, + 2, + 112 + ], + [ + 3, + 8, + 2, + 832 + ], + [ + 4, + 9, + 2, + 1128 + ], + [ + 4, + 9, + 3, + 1752 + ], + [ + 4, + 5, + 0, + 32 + ], + [ + 6, + 9, + 0, + 2200 + ], + [ + 6, + 8, + 3, + 832 + ], + [ + 6, + 7, + 3, + 112 + ], + [ + 6, + 5, + 1, + 32 + ], + [ + 6, + 5, + 2, + 32 + ], + [ + 6, + 5, + 3, + 32 + ], + [ + 5, + 8, + 4, + 832 + ], + [ + 5, + 7, + 4, + 112 + ], + [ + 5, + 5, + 4, + 16 + ], + [ + 7, + 5, + 4, + 16 + ], + [ + 8, + 9, + 1, + 2424 + ], + [ + 8, + 9, + 2, + 2376 + ], + [ + 10, + 9, + 0, + 344 + ], + [ + 10, + 9, + 1, + 952 + ], + [ + 10, + 9, + 4, + 3504 + ], + [ + 11, + 8, + 6, + 832 + ], + [ + 11, + 7, + 6, + 112 + ], + [ + 12, + 9, + 3, + 1752 + ], + [ + 12, + 9, + 6, + 3048 + ], + [ + 13, + 9, + 7, + 2416 + ], + [ + 13, + 9, + 8, + 2384 + ], + [ + 14, + 9, + 5, + 1744 + ], + [ + 14, + 9, + 6, + 456 + ], + [ + 14, + 8, + 5, + 832 + ], + [ + 14, + 7, + 5, + 112 + ], + [ + 14, + 5, + 5, + 32 + ], + [ + 14, + 5, + 7, + 32 + ], + [ + 15, + 9, + 8, + 1120 + ], + [ + 15, + 9, + 5, + 1760 + ], + [ + 15, + 5, + 8, + 32 + ], + [ + 15, + 5, + 6, + 32 + ], + [ + 16, + 9, + 7, + 544 + ], + [ + 16, + 8, + 7, + 832 + ], + [ + 16, + 7, + 7, + 112 + ], + [ + 17, + 9, + 7, + 544 + ], + [ + 17, + 8, + 8, + 832 + ], + [ + 17, + 7, + 8, + 112 + ] + ], + "windows": { + "0": [ + 1, + 16, + [ + 0, + 1 + ] + ], + "2": [ + 1, + 16, + [ + 0, + 1 + ] + ], + "1": [ + 1, + 8, + [ + 2 + ] + ], + "3": [ + 1, + 8, + [ + 2 + ] + ], + "4": [ + 2, + 32, + [ + 0, + 1, + 2, + 3 + ] + ], + "6": [ + 2, + 32, + [ + 0, + 1, + 2, + 3 + ] + ], + "5": [ + 2, + 8, + [ + 4 + ] + ], + "7": [ + 2, + 8, + [ + 4 + ] + ], + "8": [ + 3, + 48, + [ + 0, + 1, + 2, + 3, + 4, + 5 + ] + ], + "10": [ + 3, + 48, + [ + 0, + 1, + 2, + 3, + 4, + 5 + ] + ], + "9": [ + 3, + 8, + [ + 6 + ] + ], + "11": [ + 3, + 8, + [ + 6 + ] + ], + "12": [ + 0, + 48, + [ + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "13": [ + 0, + 48, + [ + 3, + 4, + 5, + 6, + 7, + 8 + ] + ], + "14": [ + 1, + 32, + [ + 5, + 6, + 7, + 8 + ] + ], + "15": [ + 1, + 32, + [ + 5, + 6, + 7, + 8 + ] + ], + "16": [ + 2, + 16, + [ + 7, + 8 + ] + ], + "17": [ + 2, + 16, + [ + 7, + 8 + ] + ] + }, + "sides": { + "0": 0, + "2": 1, + "1": 0, + "3": 1, + "4": 0, + "6": 1, + "5": 0, + "7": 1, + "8": 0, + "10": 1, + "9": 0, + "11": 1, + "12": 0, + "13": 1, + "14": 0, + "15": 1, + "16": 0, + "17": 1 + }, + "pairs": { + "0": 1, + "2": 1, + "1": 1, + "3": 1, + "4": 2, + "6": 2, + "5": 2, + "7": 2, + "8": 3, + "10": 3, + "9": 3, + "11": 3, + "12": 0, + "13": 0, + "14": 1, + "15": 1, + "16": 2, + "17": 2 + }, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 8, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 5, + 5, + 5, + 5, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "local_paid": { + "1": 2057, + "2": 928, + "3": 50, + "4": 274, + "5": 314, + "6": 2, + "7": 1, + "8": 17 + }, + "solver_message": " message: Optimization terminated successfully. (HiGHS Status 7: Optimal)\n success: True\n status: 0\n fun: 859.005692015194\n x: [ 0.000e+00 0.000e+00 ... 0.000e+00 0.000e+00]\n mip_node_count: 1\n mip_dual_bound: 859.005692015194\n mip_gap: 0.0", + "seconds": 0.03242441697511822, + "gap": 0.0 +} diff --git a/research/r489-pooled-retimed-complex/provenance/POOLED-COLORING.json b/research/r489-pooled-retimed-complex/provenance/POOLED-COLORING.json new file mode 100644 index 0000000000..a9b673baab --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/POOLED-COLORING.json @@ -0,0 +1,91 @@ +{ + "status": "PASS_EXPLICIT_CROSS_REPLICA_WHOLE_OWNER_COLORING", + "roles": 40320, + "invocations": 72, + "one_helper_per_physical_family_per_complete_invocation": true, + "all_active_owners_disjoint": true, + "all_helpers_assigned_once_each_invocation": true, + "all_idle_footprints_disjoint": true, + "live": 7680, + "banks": 0, + "rank_mass": 558144, + "deficit": 2496, + "profile": { + "1": 148440, + "2": 66816, + "3": 7472, + "4": 19728, + "5": 25664, + "6": 144, + "7": 1800, + "8": 4120 + }, + "cross_replica_helper_roles": 35280, + "perstage": [ + { + "stage": 0, + "physical_families": 2285, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + }, + { + "stage": 1, + "physical_families": 1365, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + }, + { + "stage": 2, + "physical_families": 1828, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + }, + { + "stage": 3, + "physical_families": 1231, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + }, + { + "stage": 4, + "physical_families": 1677, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + }, + { + "stage": 5, + "physical_families": 1395, + "maximum_slots_per_family": 4, + "roles": 4480, + "colors": 8 + }, + { + "stage": 6, + "physical_families": 1738, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + }, + { + "stage": 7, + "physical_families": 2020, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + }, + { + "stage": 8, + "physical_families": 1411, + "maximum_slots_per_family": 5, + "roles": 4480, + "colors": 8 + } + ], + "owner_raw_sha256": "afc95cc383004b0fada477bbc841e571bb5a10cf2bad851bd5a17bb6ee792ee8", + "scope": "Exact emitted combinatorial assignment and complete paid profile. Actual spectator routes and generalized cross-replica physical controller/compiler normalization remain to be replayed before supplier admission." +} diff --git a/research/r489-pooled-retimed-complex/provenance/POOLING-PROOF.txt b/research/r489-pooled-retimed-complex/provenance/POOLING-PROOF.txt new file mode 100644 index 0000000000..c479eb29a2 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/POOLING-PROOF.txt @@ -0,0 +1,26 @@ +OpenAI Codex — complex484 cross-replica whole-owner derivative. + +UNCHANGED LOCAL OPERATOR +The source canonical word, both serialized local instruction streams, frame/phase recipes, residual adapters, local paid profile, and source data routes are unchanged. Each complete invocation has240active data owners and560helper owners, with all800physical families distinct. An entering helper uses the source paid pre/post wrappers around the whole invocation. Its residual and borrowed spectator coordinates lie in one physical owner family. Replica labels only name storage; they do not enter the local arbitrary-dirt theorem or normalized residual identity. For a fixed invocation each family has only one route sigma, so two distinct cover classes d produce distinct physical cover classes d*sigma^-1. Each complete cover sweep therefore consists of disjoint whole-owner instances of the same local theorem. A later invocation may reuse the family after that sweep has completed; its arbitrary dirty input includes the earlier invocation output. + +GLOBAL ORDER +For each recipe phase, invocation replicas run in increasing order and each complete cover sweep/complete local invocation finishes before the next. All source bridge, terminal and translation phases are retained. A helper's owner family belongs to an idle pair whose last data invocation or bridge touch precedes the helper's stage; its idle child follows the stage. Thus no data or bridge operation touches that family in the relevant interval. Spectators are restored identically at the end of each complete invocation, so later invocations may borrow them again. + +WHOLE-OWNER ASSIGNMENT +The discovery LP/MILP uses a multiset of complete residual widths per physical idle copy, with at most8slots. Aggregate stage-width demands equal8copies of each actual helper width. The finite allocation is expanded before replica assignment. At each stage, form a bipartite multigraph whose left vertices are physical families and whose right vertices are actual helper IDs; width classes are split into560right vertices, each with degree8. Every left degree is at most8. Dummy right vertices make an8regular bipartite multigraph. Eight explicit perfect matchings color every real edge by invocation replica. Each helper occurs exactly once per invocation and each physical family is used at most once per invocation. The frozen40320role map is the result; no optimizer or matching code runs in the portable emitter. + +ACTUAL CHARTS AND IDLE COMPLETION +The actual73-column orthogonal port basis is independently reconstructed. For a widthw residual, its firstwcolumns are the assigned pending axes; its next9-wcolumns are the first unused basis columns, serving as spectators; the remaining columns complete the full orthogonal map. Every helper is transported whole through this one chart. All occupied residual coordinates are disjoint within each physical idle child across all stages and replicas. Its emitted remainder is exactly the unused suffix. Completed normalized helper residual factors and this paid remainder commute and yield the original idle child. No helper residual is split and no scalar-coordinate reindexing is used. + +STOCK AND PRICE +All40320helper residuals are hosted, eliminating all66banks. Live stock7680, physical stock8258, rank mass558144, deficit2496. Complete paid profile: +1:148440,2:66816,3:7472,4:19728,5:25664,6:144,7:1800,8:4120. +Two exact rational moment engines enclose the inherited-envelope complex root in +[1333854156208409156010,1333854156208409156011]/10^24. +No all-size coefficient invoice or final kappa is claimed by this scratch profile receipt. The complete compiler/invoice must account for reuse across replicas without assuming independent physical histories. + +EVIDENCE +COLORING.json and COLORED-OWNERS.json.gz: explicit matching construction and exact integer ownership checks. +hosted/GLOBAL-TEMPLATE.json.gz and HOSTED.json: portable emitted physical controller. +HOSTING-AUDIT.json: independent source-bound read-back,40320window/owner checks,72complete invocations,3960actual orthogonal charts,8784entering spectator routes,18rejected mutations. +EXACT-MOMENT.json: two exact rational moment engines. diff --git a/research/r489-pooled-retimed-complex/provenance/PR484-INDEPENDENT.json b/research/r489-pooled-retimed-complex/provenance/PR484-INDEPENDENT.json new file mode 100644 index 0000000000..68b7a075b5 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/PR484-INDEPENDENT.json @@ -0,0 +1,411 @@ +{ + "status": "PASS_INDEPENDENT_PINNED_PR484_FINITE_SUPPLIER_ADMISSION", + "source": { + "pr": 484, + "commit": "035845ce95f31d0a2dcfb42b8c8e13411271fa5f", + "archive_sha256": "540c286751302f3cad9be2fb5da0fc5f8ddddf88990c4716aa6ed97a4defbbd2", + "package_manifest_sha256": "56199b350a49a6d9c114eec1620e889eedb89170af2b872bf8b8f42df8a961a2", + "dependencies": { + "e8-early-reset-kernel": "95a9570287b64d22de30e6ae3acf931d5f6daef1a163f0c99532e1a24639fbc2", + "e8-early-reset-reuse": "4d23bafa43634a59e25f875333408b67cbecb1c912929824b5d45dea4de51da7", + "idle-axis-hosting": "f68b82604363329618529313ac9c3796dc1e88b176eaee4a7b0dec9be428e987", + "split-centres-global": "3129eb4321f706542470f8443f66a6b4351a12a9ceec85e7f76aa19db1e1e32f" + } + }, + "complex_lower": "663394767670133/500000000000000000", + "complex_decimal": "0.001326789535340266", + "complex_cap_kappa": "662515748707749/500000000000000000", + "hosted_template_sha256": "18450983dd5a5dab0534e5ecf3e5a9e0d5c2e10500d26fe720482972ba8c7759", + "paid_profile": { + "1": 148216, + "2": 66816, + "3": 7408, + "4": 19728, + "5": 24896, + "6": 1216, + "7": 1800, + "8": 4376, + "9": 66 + }, + "live": 7746, + "physical": 8324, + "rank_mass": 562962, + "deficit": 2496, + "all_800_owners_per_call_distinct": true, + "actual_owner_charts": 40320, + "owner_charts_sha256": "c9242a516985dd8da4889aaf302d2eded847335baf33a35b773d4f39c835e1c6", + "scalar_and_prefix": { + "backward": { + "events": 25082, + "macros": 19708, + "real_component_primitives": 221516, + "prefix_l1": "1039266", + "prefix_bits": 20, + "coefficient_work_primitive_count": 109970, + "all_exact_columns": 800, + "all_560_dirty_helper_columns_restored": true, + "private_centres_and_coefficient_work_cleared": true + }, + "forward": { + "events": 25082, + "macros": 19708, + "real_component_primitives": 221420, + "prefix_l1": "32209", + "prefix_bits": 15, + "coefficient_work_primitive_count": 109906, + "all_exact_columns": 800, + "all_560_dirty_helper_columns_restored": true, + "private_centres_and_coefficient_work_cleared": true + } + }, + "finite_invoice": { + "status": "PASS_INDEPENDENT_SCALAR_PREFIX_AND_HOSTED_FINITE_INVOICE", + "local": { + "backward": { + "events": 25082, + "macros": 19708, + "real_component_primitives": 221516, + "prefix_l1": "1039266", + "prefix_bits": 20, + "coefficient_work_primitive_count": 109970, + "all_exact_columns": 800, + "all_560_dirty_helper_columns_restored": true, + "private_centres_and_coefficient_work_cleared": true + }, + "forward": { + "events": 25082, + "macros": 19708, + "real_component_primitives": 221420, + "prefix_l1": "32209", + "prefix_bits": 15, + "coefficient_work_primitive_count": 109906, + "all_exact_columns": 800, + "all_560_dirty_helper_columns_restored": true, + "private_centres_and_coefficient_work_cleared": true + } + }, + "entering_helpers": 122, + "entrance_rank": 148, + "local_adapters": 391344, + "local_primitive_bound": 10149247009100, + "wrapper_elementary_factors_charged": 2529792, + "compiler": 25934336, + "unhosted_pervertex": 1299225185815824, + "hosted_rebased_pervertex": 1299225185487540, + "conservative_pervertex_used": 1299225185815824, + "finite": { + "physical_stock_bits": 2641, + "router_bits": 7984, + "literal_bits": 35282, + "physical_row_coefficient": 15443, + "retained_row_coefficient": 20161, + "required_C0_bits": 200012, + "halving_integer_inequality": [ + 5329, + 162 + ], + "G_exponent": 30000, + "E_exponent": 100000, + "C0_exponent": 210000 + }, + "strict_checks": { + "local_primitive_bound": true, + "logical": true, + "router": true, + "literal": true, + "mass": true, + "precision": true, + "tape": true, + "row": true, + "halving": true + }, + "scope": "Exact finite recount conditional on inherited all-size compiler/precision/tape and analytic-transfer contracts. Signed accumulation uses the supplier scalar primitive convention." + }, + "operator_instances": { + "variant": "gauge80-kernel42", + "I-tr": { + "transitions": 2945, + "columns_each": 512, + "failures": [] + }, + "I-comp": { + "compensation_gates": 420, + "targets": 50, + "entering_helpers_compensating": 80, + "input_registers": 130, + "columns_each": 512, + "target_levels_after_segment": [ + 2, + 4, + 5 + ], + "failures": [] + }, + "I-centre": { + "centres": 16, + "detail": [ + { + "centre": 0, + "register": 99, + "frame": 480, + "path_dims": [ + 8, + 0 + ], + "targets": 28 + }, + { + "centre": 1, + "register": 64, + "frame": 481, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 2, + "register": 365, + "frame": 482, + "path_dims": [ + 8, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 3, + "register": 30, + "frame": 483, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 4, + "register": 393, + "frame": 484, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 5, + "register": 98, + "frame": 485, + "path_dims": [ + 8, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 6, + "register": 421, + "frame": 486, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 7, + "register": 96, + "frame": 487, + "path_dims": [ + 8, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 8, + "register": 35, + "frame": 967, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 9, + "register": 0, + "frame": 964, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 10, + "register": 13, + "frame": 965, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 11, + "register": 54, + "frame": 970, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 12, + "register": 40, + "frame": 968, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 13, + "register": 119, + "frame": 971, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 14, + "register": 22, + "frame": 966, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 15, + "register": 51, + "frame": 969, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + } + ], + "failures": [] + }, + "I-helper": { + "entering_helpers": 122, + "widths": { + "8": 104, + "7": 14, + "5": 4 + }, + "columns_each": 512, + "failures": [] + }, + "seconds": 98.3 + }, + "end_to_end_sample": { + "variant": "gauge80-kernel42", + "seed": 2026, + "columns": 806, + "kinds": { + "centre": 16, + "port": 240, + "entering": 244, + "target_level": 50, + "random": 256 + }, + "batches": 26, + "failures": [], + "dense": 8, + "seconds": 65.0, + "status": "PASS" + }, + "integer_safety": { + "PREOP-GUARDS-lg_e2e": { + "add_calls": 251154, + "scale_calls": 8858, + "primitive_calls": 856399, + "maximum_proved_numerator_bits": 29 + }, + "PREOP-GUARDS-lg_instances": { + "add_calls": 1116, + "scale_calls": 884, + "primitive_calls": 100842, + "maximum_proved_numerator_bits": 14 + } + }, + "observed_process_exits": [ + { + "session_id": 41628, + "action": "full pinned source verify.py --discover-check", + "exit_code": 0 + }, + { + "session_id": 81200, + "action": "fresh independent data route phases and exact match", + "exit_code": 0 + }, + { + "session_id": 46476, + "action": "actual owner charts and complete paid profile", + "exit_code": 0 + }, + { + "session_id": 33480, + "action": "guarded exact physical e2e both orientations", + "exit_code": 0 + }, + { + "session_id": 79938, + "action": "guarded exhaustive operator instances", + "exit_code": 0 + }, + { + "session_id": 81647, + "action": "all scalar columns, explicit coefficient lowering, prefix, finite invoice", + "exit_code": 0 + } + ], + "proof_admission": { + "common_frame_invariant": "At label F write physical h=T_F*l. Serialized transition T_B*T_A^-1 preserves l; additions/copies at a common label, scales, and clears act exactly as their scalar events. Fresh both-orientation label checks and exact 800-column scalar identity therefore imply the full local physical identity on all external slices, not just the sampled e2e inputs.", + "gauge_schedule": "Targets climb through nested entrance chains; centre private copies descend through served target levels (backward gather ascends), with paid child ranks at every transition, no unrelated climb while a copy is live, and explicit private clearing. All emitted common labels/endpoints and rank telescopes checked.", + "normalization_and_owners": "Each of122entering helper complete chains is normalized by the two paid monomial wrappers to C_[w] tensor identity on all512basis columns. Complete-call all800owner injectivity ensures no other register touches its physical family during normalization. The residual and spectators extend to an explicit orthogonal73axis chart of the same owner. Disjoint residual slots across calls and untouched spectators permit the inherited whole-residual schedule.", + "scope": "Finite witness under inherited all-size compiler, precision/tape/common-grid and analytic-transfer contracts. This audit does not discharge those contracts and does not claim an unconditional integer multiplication theorem.", + "e2e_scope": "806basis and8dense inputs are direct program spot checks, not an exhaustive409600-column physical program matrix. Exhaustive local transition/normalizer identities plus all800scalar columns and the common-label proof give the all-input implication.", + "overflow_scope": "Vendored post-operation int64 guards alone do not prove no wraparound. Independent Python-integer pre-operation bounds cover all expanding arithmetic in the executed operator/e2e audits, with maxima14and29bits.", + "provenance": "PR484 author DreamingOfClouds with Claude Opus5.5, extending cited PR425/433/442/458/471. Independent audit prepared by OpenAI Codex. All public source heads remain unchanged." + } +} diff --git a/research/r489-pooled-retimed-complex/provenance/PR493-INVOICE.json b/research/r489-pooled-retimed-complex/provenance/PR493-INVOICE.json new file mode 100644 index 0000000000..5b25e02313 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/PR493-INVOICE.json @@ -0,0 +1,431 @@ +{ + "status": "PASS_INDEPENDENT_PR493_PINNED_SOURCE_INVOICE_AND_EXACT_ASSEMBLY", + "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7", + "manifest_sha256": "7f25c41d0400ef5adf763eae6e166003a9b59e5a655b860c04b052f6731c7297", + "manifest_files": 93, + "git_blob_files": 94, + "full_verifier_observed_exit": 0, + "full_verifier_log_sha256": "a045a112024011d84dffd84eaa1b566d152bec2c49023e1f596afbabc86be0c8", + "boost_cpp_int_header": { + "path": "/private/tmp/balanced-coarse-openmp-env/boost_1_88_0/boost/multiprecision/cpp_int.hpp", + "sha256": "4099045e8ac3e3507779c08980272b261a86498a23a4d0bb0786849f5424595a" + }, + "result_sha256": "888053031873aeb7b8b90a57603983935877a211d4b3d0b8f3cec926a097a9c9", + "native_columns_sha256": "e86d290225bcb4bfdd00f2fa4eb397f93f31d8e3dbeb97685b66378c131c1f5b", + "native_eleven_columns_sha256": "3ef1fcd596b5246a622f353882966ecd01b99cf12ea10c35006a8c5252973e1e", + "bit_lower": "391360506745414227149/250000000000000000000000", + "actual_bit_profile": { + "1": 105600, + "2": 130560, + "4": 19680, + "6": 14400, + "7": 7680, + "8": 1584, + "48": 2, + "56": 2628 + }, + "rank_mass": 745536, + "paid_calls": 282134, + "invoice_parts": { + "local_dispatch": "3014160", + "high_routes": "401472278438400", + "route_stock": "6511673376", + "children": "137114282346352", + "fixed": "7593624", + "selectors": "2539200400", + "prefix": "66373732221337597552469934545939372516278749651185797136086609883642693545424899717784554520808632722221244884703980115117609601480159478352587716532455545421925053325357387274889255141046585273941336207489494200729211582783863262441944067528524628395439990459047009309017313552583961518212164275423439329481199911934032765061875022560139107478868540579186448602819729691740721954870327575692267248554215382148740178916746058459531411725026797177268277239270813996417970965847651454554965524574421221703591269967323174197929455340239966004038995589958193601232168837785498658003625941450065240231350919781390937077370557284383908026022131", + "one": "1" + }, + "prefix_bits": 2119, + "charged_prefix_bits": 2176, + "three_level_coefficient_bits": 6411, + "charged_coefficient_bits": 6464, + "row_coefficient": 19431, + "retained_row_allowance": 20161, + "exact_moment_intervals": { + "391360506745414227149/250000000000000000000000": { + "mercator": [ + "13479973333575319897333478455659963242050950604381206890507305414367/13479973333575319897333507543509815336818572211270286240551805124608", + "421249166674228746791671201739373851314092206386912715328353294199/421249166674228746791672110734681729275580381602196445017243910144" + ], + "base_two": [ + "9999999999999999999999978421424878418597113453/10000000000000000000000000000000000000000000000", + "999999999999999999999997842143487841859711357/1000000000000000000000000000000000000000000000" + ] + }, + "1565442026981656908597/1000000000000000000000000": { + "mercator": [ + "26959946667150639794667032184033602735769420219441408903824017543587/26959946667150639794667015087019630673637144422540572481103610249216", + "26959946667150639794667032184033602735769420219441408903824017543589/26959946667150639794667015087019630673637144422540572481103610249216" + ], + "base_two": [ + "10000000000000000000000006341634878740369872307/10000000000000000000000000000000000000000000000", + "10000000000000000000000006341644878740369872423/10000000000000000000000000000000000000000000000" + ] + } + }, + "outer": { + "pr484": { + "kappa": "662515748707749/500000000000000000", + "bootstrap": [ + { + "gap": "427335569559551465285668270564668661049905787161779873237100237689/250000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "12320956716195" + }, + { + "gap": "283492180885142603889639544206899680081729101869392670861258397954258511930123407151819032953757363/125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "6999070319883749351" + }, + { + "gap": "188067229474598496934035012150457161314006714316372703962317536585017196299947505205093104765496012564747284225408989706180296060721/62500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "3975907591517492699653606" + }, + { + "gap": "124762816003666858856748636182886224040736703655819284863749197866868114307527699180333043981943234582196440913449541548744768401202277466550177281004893512933854107/31250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "2258562988198265309176868041595" + }, + { + "gap": "82766999336624127071050550259737149212852112682736739199097884331907509175179089101169445347572709837014359036671093627713822293934627171380882169762478408196651890955053266805546136718339476713769/15625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1283004359191388493404376798428985262" + }, + { + "gap": "54907194295673814856379330585942307005649262055663806296626605067848318014467193065199083150106157388806274586814705945205707239871870756963620124971136825540514367912384131824750784074452593339064102406877980519739415504548838723/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "728826335287313423793325277497466743815803" + } + ], + "outer_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "slacks": { + "bit_positive": "10365543244845828059719449959480357018620669414057692994350737944336193703373394932151681985532806934800916849893842611193725413185294054794292760128129243036379875028863174459485632087615868175249215925547406660935897593122019480260584495451161277/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "65280550040519642981379330585942307005649262055663806296626605067848318014467193065199083150106157388806274586814705945205707239871870756963620124971136825540514367912384131824750784074452593339064102406877980519739415504548838723/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "14961605232329867/500000000000000000", + "beta_positive": "1/1000000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "leaf_saving_above_bit": "54915006795673814856379330585942307005649262055663806296626605067848318014467193065199083150106157388806274586814705945205707239871870756963620124971136825540514367912384131824750784074452593339064102406877980519739415504548838723/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "5182771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "10365543244845828059719449959480357018620669414057692994350737944336193703373394932151681985532806934800916849893842611193725413185294054794292760128129243036379875028863174459485632087615868175249215925547406660935897593122019480260584495451161277/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "37823046642682735487909115252451510521445300441889596142664040478260352710606991464751223560585885629204054143301195583796579033121229433276102822613697655806637058985055240371861024124842164844781267128986396920805605345396438841760584495451161277/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "5182771622422914996056681734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "3901067228377577085003943318265105649550409115252451510521445300441889596142664040478260352710606991464751223560585885629204054143301195583796579033121229433276102822613697655806637058985055240371861024124842164844781267128986396920805605345396438841760584495451161277/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000", + "lambda_above_tau": "10365543244845828059719449959480357018620669414057692994350737944336193703373394932151681985532806934800916849893842611193725413185294054794292760128129243036379875028863174459485632087615868175249215925547406660935897593122019480260584495451161277/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "75646093285365471041098780545422664024269931469721499290977343012184511717840587997350765135638964323607191436708548556399432653057164811757912885099266068576894242941247306284236416162068461514313318332425387180675313097670858203260584495451161277/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "10365543244845828059719449959480357018620669414057692994350737944336193703373394932151681985532806934800916849893842611193725413185294054794292760128129243036379875028863174459485632087615868175249215925547406660935897593122019480260584495451161277/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "10365543244845828059719449959480357018620669414057692994350737944336193703373394932151681985532806934800916849893842611193725413185294054794292760128129243036379875028863174459485632087615868175249215925547406660935897593122019480260584495451161277/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "37823046642682735487909115252451510521445300441889596142664040478260352710606991464751223560585885629204054143301195583796579033121229433276102822613697655806637058985055240371861024124842164844781267128986396920805605345396438841760584495451161277/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000", + "lambda_prime_below_one": "5182771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "3906249999999999996093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723", + "epsilon_below_one": "5182771622422917925744181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723", + "guard_width": "5182771622422917925744181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723", + "K_geometry": "2934870271622422914996056681734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723000000000000000000", + "K_dominates_log": "5182771622422914990873910112471435453534203012654139028963814810561914378781259963629243432057049013509129150021105835547169417284690045407475110179966150520476210507531777469465763628642415434776034860213075527079756995855767923975661783589958079045020849945277564760584495451161277/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723000000000000000000", + "record_suffix": "5182771622422917925744181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723", + "phase_local": "41462172979383339494520682256731889577232896245493565378846711717334741380132976615806774457808108760250564225919906431118790414176320958831421878331360117587756452211648186823006350733255732831748865986317921613610887092950989478336424365814886186720929381787148625760584495451161277/31291462172979383312155953453879154803596727077980387915828437596464883230858687676173917178315144068281990211515312914966367566853590435329627367735030164533791177419090418753546903528119558077025111807001262681241749862968108824633555157236828489265915324036390709784000000000000000000", + "phase_boundary": "8292434595876664769757919153408046699851233861183232716096634545428156693182835676673031805692854134658395013669574458024736931303972695129527690307228490554814516939313183985483528237609271211659420385307776620210996718463929771492298576352094773988670152674580798560584495451161277/6258292434595876662431190690775830960719345415596077583165687519292976646171737535234783435663028813656398042303062582993273513370718087065925473547006032906758235483818083750709380705623911615405022361400252536248349972593621764926711031447365697853183064807278141956800000000000000000", + "gamma_sublinear": "1/2000000000000000000", + "cell_above_band": "7812499999999999988276067228377577085980505818265105649550409115252451510521445300441889596142664040478260352710606991464751223560585885629204054143301195583796579033121229433276102822613697655806637058985055240371861024124842164844781267128986396920805605345396438841760584495451161277/15645731086489691656077976726939577401798363538990193957914218798232441615429343838086958589157572034140995105757656457483183783426795217664813683867515082266895588709545209376773451764059779038512555903500631340620874931484054412316777578618414244632957662018195354892000000000000000000", + "prime_interval_packing": "5182771622422917925744181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723", + "alpha_positive": "10365543244845831940055591847365786879687587760202628507518514368672318236117219485368890721450057548757905589435220206343115273983494461610896077058736717244373387893834121662828704643587175062915010735370910682298489866869371003170056438193519237284436354494116287760584495451161277/7822865543244845828038988363469788700899181769495096978957109399116220807714671919043479294578786017070497552878828228741591891713397608832406841933757541133447794354772604688386725882029889519256277951750315670310437465742027206158388789309207122316478831009097677446000000000000000000", + "alpha_below_one": "7812499999999999996098932771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723/7822865543244845828038988363469788700899181769495096978957109399116220807714671919043479294578786017070497552878828228741591891713397608832406841933757541133447794354772604688386725882029889519256277951750315670310437465742027206158388789309207122316478831009097677446000000000000000000", + "alpha_below_one_fourth": "1945350842566365625069691499020081388345107854613571616231758835410382883692550760275500932923246446718866482630271836979054857654365907746490814406380648566117575200799317050433852765863885204751154477202208006895310876568637430536427140889108261341835271397780303073739415504548838723/7822865543244845828038988363469788700899181769495096978957109399116220807714671919043479294578786017070497552878828228741591891713397608832406841933757541133447794354772604688386725882029889519256277951750315670310437465742027206158388789309207122316478831009097677446000000000000000000", + "delta_positive": "1/8000000000000000000", + "delta_below_one_eighth": "999999999999999999/8000000000000000000", + "short_record_fallback": "30477033999456440569135151849796924432301061141507378092637525081353395676351709927441925286595227981187599605912008258703476629796613760789061753474232853120162434592578970904987178831570725692856230457545465564499457908013363903193044315911464397679787442062705826067855487215716018063883965165095954628967344349519276341275687762283944174599833819907786124149041019471163257530736175554404036831226415736831059001043072114431478858998635084817947070390231414258449684598172151279595769566168752847764746727864270729/30558068528300179015777298294803862112887428787090222574051208590297737530135437183763590994448382879181631065932922768521843327005459409501589226303740395052530446698330487064010647976679255934594835749024670587150146350554793774056206208239090321548745433629287802523437500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000", + "artificial_boundary": "219081697383835066540231925945900507170832299169047786377976273425961711315305165508065668638093160424821140633990682345336686864146965825749406779450337729518939682253359661728546919757115371648780983279054935728818415831370344102534097456507668723364905776254936361746718246513646516169/31291462172979383312155953453879154803596727077980387915828437596464883230858687676173917178315144068281990211515312914966367566853590435329627367735030164533791177419090418753546903528119558077025111807001262681241749862968108824633555157236828489265915324036390709784000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "3639735127798079050768877667790835393361515002286438587534932301662140354911995764172479266879820400180457628602892967438999071048550591156468727639055371725810766073104169875379325385103446977697796778917921878871864282743124081945533092003742157602126971354138635473/1955716385811211457009747090867447175224795442373774244739277349779055201928667979760869823644696504267624388219707057185397972928349402208101710483439385283361948588693151172096681470507472379814069487937578917577609366435506801539597197327301780579119707752274419361500000000000000000", + "coordinate_movement_above_kappa": "13734671287249934719449959480357018620669414057692994350737944336193703373394932151681985532806934800916849893842611193725413185294054794292760128129243036379875028863174459485632087615868175249215925547406660935897593122019480260584495451161277/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "3368037483973735187518261153846776436273439119825328685591309903766170305966655568823218886470247791825666480766371820507202196240402377896734034311231972884897634968822037406565287829191949195767454581960685922588509832615234560811871789352880754046014527203728432223/3911432771622422914019494181734894350449590884747548489478554699558110403857335959521739647289393008535248776439414114370795945856698804416203420966878770566723897177386302344193362941014944759628138975875157835155218732871013603079194394654603561158239415504548838723000000000000000000", + "bulk_exposure_above_kappa": "13734671287249934719449959480357018620669414057692994350737944336193703373394932151681985532806934800916849893842611193725413185294054794292760128129243036379875028863174459485632087615868175249215925547406660935897593122019480260584495451161277/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "38678598186657150242204571775978894541536285612845274953166143328803693659305252429150970033630161360211078175449216907170005407493315436422482537390492094779352771282735206285102391456580427845024053583310960886173734859534917295732557498786856715842834464143473973953/31291462172979383312155953453879154803596727077980387915828437596464883230858687676173917178315144068281990211515312914966367566853590435329627367735030164533791177419090418753546903528119558077025111807001262681241749862968108824633555157236828489265915324036390709784000000000000000000", + "scalar_work_above_kappa": "10864865854629368379656509700583694388666929830367093782216072425407227054946919253447585724557546678870414656241374672930637838184022130817459244251601435409249671998456083132375168644128041376707321897362318445358921958203794341609867015481054192095158425232333865769/6258292434595876662431190690775830960719345415596077583165687519292976646171737535234783435663028813656398042303062582993273513370718087065925473547006032906758235483818083750709380705623911615405022361400252536248349972593621764926711031447365697853183064807278141956800000000000000000", + "dimension_above_kappa": "1950533614188788542723738036930631875544082225417061148622237652507383385606264321901270531267299259904854878660113342995059655674543565230897360565111205873106779050362220553714084602596697495565255897165868060120187412482415077332267085415822301366413384251467738240626971354138635473/1955716385811211457009747090867447175224795442373774244739277349779055201928667979760869823644696504267624388219707057185397972928349402208101710483439385283361948588693151172096681470507472379814069487937578917577609366435506801539597197327301780579119707752274419361500000000000000000" + } + }, + "pr471": { + "kappa": "260706019542937/200000000000000000", + "bootstrap": [ + { + "gap": "1653430211745663517455165443469236854975746861404099625915696943281/1000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "13168331866613" + }, + { + "gap": "2158109205785134323488734089560975071908122337643737009768916197810198064611624200740055528064493929/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "7729575901820446356" + }, + { + "gap": "2816832129356885383125751209945213695426577510264496522414328615837087326128730923710995148535320979740614890507497631184166931044961/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "4537123169980686383932420" + }, + { + "gap": "3676618043103433242733914680461326209397431447217091001942470452525892496622760535337039905785092220338055800956162196256040611306010398747599426630540026013481841049/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "2663210365102613299633809323590" + }, + { + "gap": "4798837706370496979153627496096856129109531806890873403278883258882651411424251043614926257501843369515214046399395544483198776622970067399520454555224388690624974253396827177780561361938490877857041/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1563256976517167590231669350803729110" + }, + { + "gap": "6263594167819675340486134473716161138837337360969320756854649839331875160175911646308735363624643931682009518358644171396407881220178497650075387053041737805966562283105002476145484630959075057780347602970585244078052569369610541769/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "917603958985582384762323575374167703666079" + } + ], + "outer_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "slacks": { + "bit_positive": "1305231506267590992430174325912733659513865526283838861162662639030679243145350160668124839824088353691264636375356068317990481641355828603592118779821502349924612946958262194033437716894997523854515369040924942219652397029414755921947430630389458231/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "7569825674087266340486134473716161138837337360969320756854649839331875160175911646308735363624643931682009518358644171396407881220178497650075387053041737805966562283105002476145484630959075057780347602970585244078052569369610541769/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "29944768493732409/1000000000000000000", + "beta_positive": "1/1000000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "leaf_saving_above_bit": "6264594167819675340486134473716161138837337360969320756854649839331875160175911646308735363624643931682009518358644171396407881220178497650075387053041737805966562283105002476145484630959075057780347602970585244078052569369610541769/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "1305231506267590992430174325912733659513865526283838861162662639030679243145350160668124839824088353691264636375356068317990481641355828603592118779821502349924612946958262194033437716894997523854515369040924942219652397029414755921947430630389458231/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "4437528590177428662673241562770814228932534206768499239589987558696616823233305983822492521636410319532269395554678154016194422251445077428629812306342371252907894088510763432106180032374535052744689170526217564258678681714220026806447430630389458231/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "652615753133795619909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "499347384246866204380090144343311224162673241562770814228932534206768499239589987558696616823233305983822492521636410319532269395554678154016194422251445077428629812306342371252907894088510763432106180032374535052744689170526217564258678681714220026806447430630389458231/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000", + "lambda_above_tau": "1305231506267590992430174325912733659513865526283838861162662639030679243145350160668124839824088353691264636375356068317990481641355828603592118779821502349924612946958262194033437716894997523854515369040924942219652397029414755921947430630389458231/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "8875057180354857332916308799628894798351202887253159618017312478362554403321261806976860203448732285373274154734000239714398362861534326253667505832863240155891175230063264670178922347854072581634862972011510186297704966399025297690947430630389458231/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "1305231506267590992430174325912733659513865526283838861162662639030679243145350160668124839824088353691264636375356068317990481641355828603592118779821502349924612946958262194033437716894997523854515369040924942219652397029414755921947430630389458231/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "1305231506267590992430174325912733659513865526283838861162662639030679243145350160668124839824088353691264636375356068317990481641355828603592118779821502349924612946958262194033437716894997523854515369040924942219652397029414755921947430630389458231/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "4437528590177428662673241562770814228932534206768499239589987558696616823233305983822492521636410319532269395554678154016194422251445077428629812306342371252907894088510763432106180032374535052744689170526217564258678681714220026806447430630389458231/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000", + "lambda_prime_below_one": "652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "499999999999999999500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769", + "epsilon_below_one": "652615753133795994909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769", + "guard_width": "652615753133795994909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769", + "K_geometry": "375652615753133795619909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769000000000000000000", + "K_dominates_log": "652615753133795619257239903554980217416902780540409933740707356002314989342546648071882416356681574874124301596895664290223126081732165516074973303233076587564609945102706175721918217831607820801714056136228379361490861848317488486010488811997537452231251083830568575447430630389458231/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769000000000000000000", + "record_suffix": "652615753133795994909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769", + "phase_local": "5220926025070367458626229500376411203704211841144710331212967908622820312212633737195564653723539688116676650142023427564337357198985087402714017543117534587155923800706107405366659598256263796058453829514483010148666668164794538675259716812457349807099236671104360958447430630389458231/4005220926025070363959278845253510206698614067497833486168539726345852006083280099530427065414133552129420059826908717443741844835562574767870444621988439380570961501549261029976736847291913892543150559741003719578042486635790259485930570546286239785548420554956884334152000000000000000000", + "phase_boundary": "1044185205014073091203153297568245844812957842877921396381186831941215445588554112853912322416697984580628788615049472570861488748925273106358319952366030130386722561297283423977181764725149761538006036711507347714677359532586949930803279783465521368362792705596893636847430630389458231/801044185205014072791855769050702041339722813499566697233707945269170401216656019906085413082826710425884011965381743488748368967112514953574088924397687876114192300309852205995347369458382778508630111948200743915608497327158051897186114109257247957109684110991376866830400000000000000000", + "gamma_sublinear": "1/2000000000000000000", + "cell_above_band": "999999999999999998499347384246866204505090144343311224162673241562770814228932534206768499239589987558696616823233305983822492521636410319532269395554678154016194422251445077428629812306342371252907894088510763432106180032374535052744689170526217564258678681714220026806447430630389458231/2002610463012535181979639422626755103349307033748916743084269863172926003041640049765213532707066776064710029913454358721870922417781287383935222310994219690285480750774630514988368423645956946271575279870501859789021243317895129742965285273143119892774210277478442167076000000000000000000", + "prime_interval_packing": "652615753133795994909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769", + "alpha_positive": "1305231506267591489167095560243756179743661217769595704808173149233815749752559089375265593123375591051631779960485344757953730527054011499880551051787999158934797638760334922814024129320844388695534023761693326616801691322099924227331807097777510645783820453441110344447430630389458231/1001305231506267590989819711313377551674653516874458371542134931586463001520820024882606766353533388032355014956727179360935461208890643691967611155497109845142740375387315257494184211822978473135787639935250929894510621658947564871482642636571559946387105138739221083538000000000000000000", + "alpha_below_one": "999999999999999999500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769/1001305231506267590989819711313377551674653516874458371542134931586463001520820024882606766353533388032355014956727179360935461208890643691967611155497109845142740375387315257494184211822978473135787639935250929894510621658947564871482642636571559946387105138739221083538000000000000000000", + "alpha_below_one_fourth": "249021076370299306258287832268100631738919718000844997180725559747381934630452447131276425995259971417037121959221309495475911571695606911492022237822489462126750296208068479450732028826423773895251375960051039147010853723414791293643328852045112475950992464231364160540052569369610541769/1001305231506267590989819711313377551674653516874458371542134931586463001520820024882606766353533388032355014956727179360935461208890643691967611155497109845142740375387315257494184211822978473135787639935250929894510621658947564871482642636571559946387105138739221083538000000000000000000", + "delta_positive": "1/8000000000000000000", + "delta_below_one_eighth": "999999999999999999/8000000000000000000", + "short_record_fallback": "499346532432223727221574538992823718239681541565258346278897077657824349617752375881558416336902955287541565010886207593024326745281254445886720253499588924352522686003195144680021018150534698426624427050562790735812968196725063167395157514984657759716494061515359332516933433232990704592184251611300824362111487983701101367703344991416255626159263616936362870716801815114508591205624921561762274130073685676837385103482400909058228258006213030164643197490994353331021688868454478212814696342485132213035961708773693649361/500652615753133795494909855656688775837326758437229185771067465793231500760410012441303383176766694016177507478363589680467730604445321845983805577748554922571370187693657628747092105911489236567893819967625464947255310829473782435741321318285779973193552569369610541769000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000", + "artificial_boundary": "28041767408200562917176188609287483040073642106952734216860298086078503605979443193623111025594298454359270628145569821598467281119591367184366748789243480582519108745639753007528005341416284026586480795662497466328021352989198470729210496858711265591611328394512414592796657708108831625307/4005220926025070363959278845253510206698614067497833486168539726345852006083280099530427065414133552129420059826908717443741844835562574767870444621988439380570961501549261029976736847291913892543150559741003719578042486635790259485930570546286239785548420554956884334152000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "171144973844581015333694143202764701793554872811823942033697980789781009228229248450194908557551629668615621604494870857383935216751973254328441535209726497461882955449560276641644532940872168078669876521769728832768748013448151791265003169545788747998519142553672564447/100130523150626759098981971131337755167465351687445837154213493158646300152082002488260676635353338803235501495672717936093546120889064369196761115549710984514274037538731525749418421182297847313578763993525092989451062165894756487148264263657155994638710513873922108353800000000000000000", + "coordinate_movement_above_kappa": "1701408552905992430174325912733659513865526283838861162662639030679243145350160668124839824088353691264636375356068317990481641355828603592118779821502349924612946958262194033437716894997523854515369040924942219652397029414755921947430630389458231/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "177536126734885640586780430178567366565223802810945262198711219077836772690368114904835579805495727163450300272055382303225972739657272212829201049150038782369022294777071877230565279396435801912727781320611589608294214618883488260291847264721581883399521571699376140233/250326307876566897747454927828344387918663379218614592885533732896615750380205006220651691588383347008088753739181794840233865302222660922991902788874277461285685093846828814373546052955744618283946909983812732473627655414736891217870660659142889986596776284684805270884500000000000000000", + "bulk_exposure_above_kappa": "1701408552905992430174325912733659513865526283838861162662639030679243145350160668124839824088353691264636375356068317990481641355828603592118779821502349924612946958262194033437716894997523854515369040924942219652397029414755921947430630389458231/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "868507175003514327174643289965428838511112224057362350498516380525016573065423975160255885283646343332747465357595377178603751129570464188643726703929257057123693455902824584386064157615488108061465192206532365714894673278111431894378704038080530010794600571059769973807/801044185205014072791855769050702041339722813499566697233707945269170401216656019906085413082826710425884011965381743488748368967112514953574088924397687876114192300309852205995347369458382778508630111948200743915608497327158051897186114109257247957109684110991376866830400000000000000000", + "scalar_work_above_kappa": "6345146338030106817852855872453899295904868154035728495576851765798008868368759925566492959125298492728447356701431244614889678065633608327153855830640504975903948030288753436918689211723397486578901240903163688363494609708452289214858805463545769946747213132777292036111/4005220926025070363959278845253510206698614067497833486168539726345852006083280099530427065414133552129420059826908717443741844835562574767870444621988439380570961501549261029976736847291913892543150559741003719578042486635790259485930570546286239785548420554956884334152000000000000000000", + "dimension_above_kappa": "99869476849373240872163002713243260166228791515318864639341379653177641881615978301520332592875909646959407061878911732522075483605806488187174101202262269814167497670994971712464534267262429328065768947347075089218814355874972345620483749790995796626292655671866639644719142553672564447/100130523150626759098981971131337755167465351687445837154213493158646300152082002488260676635353338803235501495672717936093546120889064369196761115549710984514274037538731525749418421182297847313578763993525092989451062165894756487148264263657155994638710513873922108353800000000000000000" + } + }, + "pr458": { + "kappa": "323880830669511/250000000000000000", + "bootstrap": [ + { + "gap": "1632847576212894403360856767382571185673116249809121944997489866495412464335729/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "13502407443073" + }, + { + "gap": "2118136212225667786614916012537813516700352798255874980967753468787080841710533300608213906447020351125448965441287817/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "8024070403938492939" + }, + { + "gap": "2747654514052901957495237487140632685669593829243271153206134381236181061216488244089975103850074892726242461599852981845427515849737708263827958365225961441/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "4768461188778236548646263" + }, + { + "gap": "3564268098066465759489330571875066597518410502814250255860967899175945825235653092608151354397582390868874247973170160350367497702828985233185688696818489508782687189180603985277622471789205513593/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "2833751570490164486746628377157" + }, + { + "gap": "4623582408166525631936194665766910798514901284084473974150618091392829437396912535598016175439918862882021595706318707952939744262491820618844673446995034587899732988078140631422351719328154260473471260306546625016959014253747432625489/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1684012440355614704970425115745436073" + }, + { + "gap": "5997729041960615391576851221514337755604968541668520427387559025104653701120830687908008387927287231699894605353296221602618545412076104902051335832828067439587585174751495656073962345656472441207243451816591049467533621131973610961980401296611640976474455460811801025064297/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1000757416000985939987924890040738850982191" + } + ], + "outer_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "slacks": { + "bit_positive": "1297203880559577920231067077479806680896148778485662244395031458331479572612440974895346298879169312091991612072712768300105394646703778397381454587923895097948664167171932560412414825248504343926037654343527558792756548183408950532466378868026389038019598703388359023525544539188198974935703/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "7295932922520193319103851221514337755604968541668520427387559025104653701120830687908008387927287231699894605353296221602618545412076104902051335832828067439587585174751495656073962345656472441207243451816591049467533621131973610961980401296611640976474455460811801025064297/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "29952796119440422072473/1000000000000000000000000", + "beta_positive": "1/1000000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "leaf_saving_above_bit": "5998729041960615391576851221514337755604968541668520427387559025104653701120830687908008387927287231699894605353296221602618545412076104902051335832828067439587585174751495656073962345656472441207243451816591049467533621131973610961980401296611640976474455460811801025064297/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "1297203880559577920231067077479806680896148778485662244395031458331479572612440974895346298879169312091991612072712768300105394646703778397381454587923895097948664167171932560412414825248504343926037654343527558792756548183408950532466378868026389038019598703388359023525544539188198974935703/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "4296568401539885616019492688236975558698633049319922458088810970883806423172856318849350492842812927941938914749360879101414667352741830848407122504337928817742456754547680388449395998076740564529659380251823083526523358749395756013456579516332209526256826433794259536057693039188198974935703/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "648601940279789083818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "499351398059720210916181670341819674579782992688236975558698633049319922458088810970883806423172856318849350492842812927941938914749360879101414667352741830848407122504337928817742456754547680388449395998076740564529659380251823083526523358749395756013456579516332209526256826433794259536057693039188198974935703/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000", + "lambda_above_tau": "1297203880559577920231067077479806680896148778485662244395031458331479572612440974895346298879169312091991612072712768300105394646703778397381454587923895097948664167171932560412414825248504343926037654343527558792756548183408950532466378868026389038019598703388359023525544539188198974935703/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "8593136803079771239334918298994144436501117320154182671782590483436133273733271662803354686806456543791886217426008989902723940058779883299432790420751962537536249341923428216486377170904976785133281106160118608260290169315382561494446780164638030014494054164200160048589841539188198974935703/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "1297203880559577920231067077479806680896148778485662244395031458331479572612440974895346298879169312091991612072712768300105394646703778397381454587923895097948664167171932560412414825248504343926037654343527558792756548183408950532466378868026389038019598703388359023525544539188198974935703/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "1297203880559577920231067077479806680896148778485662244395031458331479572612440974895346298879169312091991612072712768300105394646703778397381454587923895097948664167171932560412414825248504343926037654343527558792756548183408950532466378868026389038019598703388359023525544539188198974935703/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "4296568401539885616019492688236975558698633049319922458088810970883806423172856318849350492842812927941938914749360879101414667352741830848407122504337928817742456754547680388449395998076740564529659380251823083526523358749395756013456579516332209526256826433794259536057693039188198974935703/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000", + "lambda_prime_below_one": "648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "499999999999999999500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297", + "epsilon_below_one": "648601940279789458818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297", + "guard_width": "648601940279789458818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297", + "K_geometry": "375648601940279789083818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297000000000000000000", + "K_dominates_log": "648601940279789083169727717900536336398677653582699021084359638917053100609822078436116034915954652034455930330043390907411578093452048840524247396619048253007544848403902030664665749790248429293060756470939823919736617824917481003136021502427327513066779233063546487199753082537949990199133394606060561121990039188198974935703/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297000000000000000000", + "record_suffix": "648601940279789458818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297", + "phase_local": "5188815522238315169898035325162814402917728835923870110193928293677595893988145282249471072705960420089002480430352895313839174847925895130621575927426232314157687318038400306467468467956485710147288769933755872212120956062155896317472510256657035418870722618738079803401968045978133237795282120288667736572069039188198974935703/4005188815522238311670546637265442603361736058494104195530410935605440620335289512232929548614617149449205196057257496576464488682005112967188682661178065353212743019965296569458060345963618556892404832015386075483762724957985415331787813130004833951892347363869342323789945388529645923711538455686494408200514376000000000000000000", + "phase_boundary": "1037763104447662633460725512808731713528882040640513685865179809325099625756535495905832181012240860724845634624355634142248229243835521379675446984973949743963271345801144740019191697061640196223423157624895485201940989673823630887222006252789873904992831523264220771445657222261394268564517571093141176160568239188198974935703/801037763104447662334109327453088520672347211698820839106082187121088124067057902446585909722923429889841039211451499315292897736401022593437736532235613070642548603993059313891612069192723711378480966403077215096752544991597083066357562626000966790378469472773868464757989077705929184742307691137298881640102875200000000000000000", + "gamma_sublinear": "1/2000000000000000000", + "cell_above_band": "999999999999999998499351398059720211041181670341819674579782992688236975558698633049319922458088810970883806423172856318849350492842812927941938914749360879101414667352741830848407122504337928817742456754547680388449395998076740564529659380251823083526523358749395756013456579516332209526256826433794259536057693039188198974935703/2002594407761119155835273318632721301680868029247052097765205467802720310167644756116464774307308574724602598028628748288232244341002556483594341330589032676606371509982648284729030172981809278446202416007693037741881362478992707665893906565002416975946173681934671161894972694264822961855769227843247204100257188000000000000000000", + "prime_interval_packing": "648601940279789458818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297", + "alpha_positive": "1297203880559578416988057376080861881615684965345723462385726589597130642521011107552309611743098333185105437487230462965472663344091169739109580043877217404600422344065973212922208995242568040843664758394199259390077237573094397476612662753031571499610199716731336960942926648743690454141440355417861586186287039188198974935703/1001297203880559577917636659316360650840434014623526048882602733901360155083822378058232387153654287362301299014314374144116122170501278241797170665294516338303185754991324142364515086490904639223101208003846518870940681239496353832946953282501208487973086840967335580947486347132411480927884613921623602050128594000000000000000000", + "alpha_below_one": "999999999999999999500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297/1001297203880559577917636659316360650840434014623526048882602733901360155083822378058232387153654287362301299014314374144116122170501278241797170665294516338303185754991324142364515086490904639223101208003846518870940681239496353832946953282501208487973086840967335580947486347132411480927884613921623602050128594000000000000000000", + "alpha_below_one_fourth": "249027097089580316062421107453009300828492818690535788758264956885742908128434583407005787176670473507390219316091363073063557879281228390710183086279751867171196016403765062378206562627483591764931637242567430458345093072300994060760125657872270550493661510525102558275928660134359179777829713124988038926345861460811801025064297/1001297203880559577917636659316360650840434014623526048882602733901360155083822378058232387153654287362301299014314374144116122170501278241797170665294516338303185754991324142364515086490904639223101208003846518870940681239496353832946953282501208487973086840967335580947486347132411480927884613921623602050128594000000000000000000", + "delta_positive": "1/8000000000000000000", + "delta_below_one_eighth": "999999999999999999/8000000000000000000", + "short_record_fallback": "499350556690766341126036706564733983358168079148490718774218778590349240088370782079982239460499982741683467387787199484814786573383528313605726988468704603242363949478633909571019333677877229422945786902447977197951147414065475979849781893259739852456849785936886569772215226571154176326657150476097577561395176054921418229479916701007641298027923007744841548530744922239279585516432690724548268897004028122694464534224864236189000760034520135754943576804026261539608409431721489213895067752229002421250605160457376362779855823036833666506908319885913935521578456956268874934870977977614183366012984104209/500648601940279788958818329658180325420217007311763024441301366950680077541911189029116193576827143681150649507157187072058061085250639120898585332647258169151592877495662071182257543245452319611550604001923259435470340619748176916473476641250604243986543420483667790473743173566205740463942306960811801025064297000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000", + "artificial_boundary": "28041510524177906498866318903944380193770343456927374540503938506778814036006220198715476621542670762680990149188541403655167857977512464953683644545176440188397700157664147063119261400195934668686011285859445562704753611669653100960713526899283202364559208834706551322279193369688170761113537166190572486995941928882435403075192891/4005188815522238311670546637265442603361736058494104195530410935605440620335289512232929548614617149449205196057257496576464488682005112967188682661178065353212743019965296569458060345963618556892404832015386075483762724957985415331787813130004833951892347363869342323789945388529645923711538455686494408200514376000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "190090736836330568876259703876980091324423676990405178433410541932194848845186609864347866931278768754822965521206377437932891988349978989450203122612843282343545358948043677481850630685314221775569388046228836291969006668349572129236531637631063983621021450453222112074935866549248613274800641504968181667451233/125162150485069947239704582414545081355054251827940756110325341737670019385477797257279048394206785920287662376789296768014515271312659780224646333161814542287898219373915517795564385811363079902887651000480814858867585154937044229118369160312651060996635855120916947618435793391551435115985576740202950256266074250000000000000000", + "coordinate_movement_above_kappa": "1680557881533920231067077479806680896148778485662244395031458331479572612440974895346298879169312091991612072712768300105394646703778397381454587923895097948664167171932560412414825248504343926037654343527558792756548183408950532466378868026389038019598703388359023525544539188198974935703/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "51942869081008497309244097169948007975495540129971537858468160155619863567767050085655054829657586267628242515533664535934701373629855367380445431560822992044517711659302527749028995899160913498145389636598417146481137210730022320094529981854730338099508476265844131565200058526157742527052051811812185128948127/100129720388055957791763665931636065084043401462352604888260273390136015508382237805823238715365428736230129901431437414411612217050127824179717066529451633830318575499132414236451508649090463922310120800384651887094068123949635383294695328250120848797308684096733558094748634713241148092788461392162360205012859400000000000000000", + "bulk_exposure_above_kappa": "1680557881533920231067077479806680896148778485662244395031458331479572612440974895346298879169312091991612072712768300105394646703778397381454587923895097948664167171932560412414825248504343926037654343527558792756548183408950532466378868026389038019598703388359023525544539188198974935703/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "3579660569061179259246218875772461295280472627134150587662630507076834775336415570513550773916784881748581649142818142653562238200946132057913573260374694189235487098859087323507932465702793498760467397469706464165656510288445423553201629197941026255939969312084768634029231861744926922473908993354922808233117971/4005188815522238311670546637265442603361736058494104195530410935605440620335289512232929548614617149449205196057257496576464488682005112967188682661178065353212743019965296569458060345963618556892404832015386075483762724957985415331787813130004833951892347363869342323789945388529645923711538455686494408200514376000000000000000000", + "scalar_work_above_kappa": "5582254976822298415081492194405182596961340656381202685427835974879555085504060326630015548224093456473184247171446890941794482541948688541507914590963726865841858608841735608236962638684602777206669813477399501907537872767438131219095535762943443231886142994019439795924204556009749884329678221198170012333375159/4005188815522238311670546637265442603361736058494104195530410935605440620335289512232929548614617149449205196057257496576464488682005112967188682661178065353212743019965296569458060345963618556892404832015386075483762724957985415331787813130004833951892347363869342323789945388529645923711538455686494408200514376000000000000000000", + "dimension_above_kappa": "124837849514930052700386154421785487521205452049039335214098335252735159047932744674915800450979823944060204554489471986808450249893717657708245655188164447162304903238927764547980973136680597578962979684833406916701802891291792062850637508036921068239895782510147036002585657061670676958950289809045663018534567254968181667451233/125162150485069947239704582414545081355054251827940756110325341737670019385477797257279048394206785920287662376789296768014515271312659780224646333161814542287898219373915517795564385811363079902887651000480814858867585154937044229118369160312651060996635855120916947618435793391551435115985576740202950256266074250000000000000000" + } + }, + "pr448": { + "kappa": "358867191156973/250000000000000000", + "bootstrap": [ + { + "gap": "502802939372483697817821674469757406723076709643758894956308541489/250000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "8899936383294" + }, + { + "gap": "361397732272430524424602436248698524094967778525958274701943169284002886643694615736422289773394263/125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "4306770014037738053" + }, + { + "gap": "259760456163321742486680237761569532873466481426534871853861706284770903361506594661394254277653990848056504299949532856818434337121/62500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "2084089947949909245542517" + }, + { + "gap": "186707022653125848995743156960485777129238251401573229941384931817897807568153139397470394293798881333835717169825323870961338023264782598158575963009509966490077607/31250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "1008512387935418585971494239534" + }, + { + "gap": "134198687601923848803357932683364667167350106000026420057334314766521655074689884759345164248020261624013835008917755396753221141305855383397598055301969988263863412089469255076558513994700041313169/15625000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "488029433479924828254115373346363408" + }, + { + "gap": "96457473844127192134618105428115482293656808710486042569970969685322397150931913696076271791825814584456619372612252764553761009522999267503816568121766824481729794895784134155979160869068378800486017268172876347222038940589336823/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "cutoff_log2": "236162421792669220044376325903858135165162" + } + ], + "outer_controls": [ + "next_grid", + "zero_eta", + "zero_beta", + "unit_beta" + ], + "slacks": { + "bit_positive": "11230721072959890517303992582912917240381894571884517706343191289513957430029030314677602849068086303923728208174185415543380627387747235446238990477000732496183431878233175518270205104215865844020839130931621199513982731827123652777961059410663177/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_above_bit": "107696007417087082759618105428115482293656808710486042569970969685322397150931913696076271791825814584456619372612252764553761009522999267503816568121766824481729794895784134155979160869068378800486017268172876347222038940589336823/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "complex_below_one_over32": "14906233851330567/500000000000000000", + "beta_positive": "1/1000000000000000000", + "beta_below_one": "999999999999999999/1000000000000000000", + "leaf_saving_above_bit": "96465286344127192134618105428115482293656808710486042569970969685322397150931913696076271791825814584456619372612252764553761009522999267503816568121766824481729794895784134155979160869068378800486017268172876347222038940589336823/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_positive": "5615360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_internal": "11230721072959890517303992582912917240381894571884517706343191289513957430029030314677602849068086303923728208174185415543380627387747235446238990477000732496183431878233175518270205104215865844020839130931621199513982731827123652777961059410663177/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_leaf": "59463364245023486584613045296970658387210298927127538991328676132175156005494987162715738744980993596152037894480311797820261132149246869198147274537884144737048329326125242596259785538750055244263847765018059373125002202121792064277961059410663177/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_positive": "5615360536479946223983775218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "c_below_one": "3900634639463520053776016224781503431897113045296970658387210298927127538991328676132175156005494987162715738744980993596152037894480311797820261132149246869198147274537884144737048329326125242596259785538750055244263847765018059373125002202121792064277961059410663177/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "q_below_reservations": "1/4000000000000000000", + "lambda_above_tau": "11230721072959890517303992582912917240381894571884517706343191289513957430029030314677602849068086303923728208174185415543380627387747235446238990477000732496183431878233175518270205104215865844020839130931621199513982731827123652777961059410663177/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_sigma": "118926728490046973276922098011028399534038703282370560276314160974836354580960944010753874640893900888380347580786438180097141636910746502950055558598767556977913226774017309674249365973284244644506856399104497546736021672416460475777961059410663177/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_above_internal": "11230721072959890517303992582912917240381894571884517706343191289513957430029030314677602849068086303923728208174185415543380627387747235446238990477000732496183431878233175518270205104215865844020839130931621199513982731827123652777961059410663177/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "lambda_prime_above_lambda": "11230721072959890517303992582912917240381894571884517706343191289513957430029030314677602849068086303923728208174185415543380627387747235446238990477000732496183431878233175518270205104215865844020839130931621199513982731827123652777961059410663177/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_leaf": "59463364245023486584613045296970658387210298927127538991328676132175156005494987162715738744980993596152037894480311797820261132149246869198147274537884144737048329326125242596259785538750055244263847765018059373125002202121792064277961059410663177/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_reservations": "1/4000000000000000000", + "lambda_prime_below_one": "5615360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3906250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "epsilon_positive": "3906249999999999996093750000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823", + "epsilon_below_one": "5615360536479949153671275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823", + "guard_width": "5615360536479949153671275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823", + "K_geometry": "2935302860536479946223983775218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823000000000000000000", + "K_dominates_log": "5615360536479946218368414682016621878903179484532773509902746369843119395881622794952382985833688969459417260513993566563700850500681798331776762331064928622113857611362724461098945211758902140788543787375187351995937773731995871138845562896267308847041142711128887277961059410663177/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823000000000000000000", + "record_suffix": "5615360536479949153671275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823", + "phase_local": "44922884291839589317504841211492599575674362405738164799430653879950346456580889869726290947368778830449246045647038393499435589138499213589948837286336844235082935846173711301760639928882203966970045016124800642149003418605580259263830148043722858901313726836486648277961059410663177/31294922884291839561979370201747972544823095637624234732902317608582979688069370590942598751956040102698274090040152051230783696844157505617437910942806025046414821803696926842103613365390998059229921715689999558045889217879855525014999982383025663485776311524714694584000000000000000000", + "phase_boundary": "8984576858367914734008679813114563717197852306350378477576567013566596001084417115647289382536696671829974013525397408872478113812494719639620083041516807103225492888632237618869947616083756583032672464125154205437629114721160247263844241623192070280264507064730981077961059410663177/6258984576858367912395874040349594508964619127524846946580463521716595937613874118188519750391208020539654818008030410246156739368831501123487582188561205009282964360739385368420722673078199611845984343137999911609177843575971105002999996476605132697155262304942938916800000000000000000", + "gamma_sublinear": "1/2000000000000000000", + "cell_above_band": "7812499999999999988275634639463520054752578724781503431897113045296970658387210298927127538991328676132175156005494987162715738744980993596152037894480311797820261132149246869198147274537884144737048329326125242596259785538750055244263847765018059373125002202121792064277961059410663177/15647461442145919780989685100873986272411547818812117366451158804291489844034685295471299375978020051349137045020076025615391848422078752808718955471403012523207410901848463421051806682695499029614960857844999779022944608939927762507499991191512831742888155762357347292000000000000000000", + "prime_interval_packing": "5615360536479949153671275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823", + "alpha_positive": "11230721072959894395477189900513190958352634187562115122692447442715580404552946662777226980338701806743678515532999970411662956020370000511515630181818059423966583073478579724050615885633659544528758248625132107732090008713936498013843360774475244569080083300465710277961059410663177/7823730721072959890494842550436993136205773909406058683225579402145744922017342647735649687989010025674568522510038012807695924211039376404359477735701506261603705450924231710525903341347749514807480428922499889511472304469963881253749995595756415871444077881178673646000000000000000000", + "alpha_below_one": "7812499999999999996099365360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823/7823730721072959890494842550436993136205773909406058683225579402145744922017342647735649687989010025674568522510038012807695924211039376404359477735701506261603705450924231710525903341347749514807480428922499889511472304469963881253749995595756415871444077881178673646000000000000000000", + "alpha_below_one_fourth": "1944701959195280078228233447708735093093090843163952555683702403093720650099782715271135195016913804611898452111976503231512318096739474100578353803743558505976959779657579347907425219451303719157341348981999840270135986108777033815423655538164628723291939386994202701222038940589336823/7823730721072959890494842550436993136205773909406058683225579402145744922017342647735649687989010025674568522510038012807695924211039376404359477735701506261603705450924231710525903341347749514807480428922499889511472304469963881253749995595756415871444077881178673646000000000000000000", + "delta_positive": "1/8000000000000000000", + "delta_below_one_eighth": "999999999999999999/8000000000000000000", + "short_record_fallback": "30473645056260841084472077323443781785514227471894705789154421548367624597498942664237124489885722330665646012837991219906598934339891270910480719347011741836759031125412939315666946546628682999914221022701731094787722882911097244165689891001883360301456131922929110641593691177674557001386776093370583273067168435691658750789916516420083413590866677226642444461342514956118633167996771672236737092848917764127289417944311063756698183300702723248928346140008832599981789618841784251567943007891819544811093130943733329/30561448129191249572245478712644504438303804333617416731349919539631816101630244717717381593707070412791283291054835987530062203949372564079529209905084008834389474417672780119241809927139646542216720425478515193404188689335796411147460920295923499497828429223354193929687500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "small_field_exposure": "1/1000000000000000000", + "artificial_boundary": "219109383074334716538820557695593220194327028926649367567527201732772925529393333830759407398674334793189667252304731448358122358518317064151047173859007264977857791033127674129234465099514332039628228737541620736578334386422594034387208315769151129766835485591352180479166116821768010469/31294922884291839561979370201747972544823095637624234732902317608582979688069370590942598751956040102698274090040152051230783696844157505617437910942806025046414821803696926842103613365390998059229921715689999558045889217879855525014999982383025663485776311524714694584000000000000000000", + "literal_scalar_guard": "1", + "row_product_gap": "23971789/25", + "balanced_prefix_above_kappa": "1236199550065147518791248642373547700550241665393679379388037880053495599277860427906692380735469545773140246498135808528289032891981908402567874728629145320893969174923897007527059076769361102530226016057077626644725472219735673796659176922541638198941155995837883221/977966340134119986311855318804624142025721738675757335403197425268218115252167830966956210998626253209321065313754751600961990526379922050544934716962688282700463181365528963815737917668468689350935053615312486188934038058745485156718749449469551983930509735147334205750000000000000000", + "coordinate_movement_above_kappa": "16121349304484267303992582912917240381894571884517706343191289513957430029030314677602849068086303923728208174185415543380627387747235446238990477000732496183431878233175518270205104215865844020839130931621199513982731827123652777961059410663177/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "compact_phase_layer_above_kappa": "1032932839724110129917573294275694234098079706871688175939361819141109936102770387758944678947373170255276724737524227709308169462407945408091760046665828152774023974233472174845284636403569652717163849767060561823165736643960754559761709892288344860042585042762196061/3911865360536479945247421275218496568102886954703029341612789701072872461008671323867824843994505012837284261255019006403847962105519688202179738867850753130801852725462115855262951670673874757403740214461249944755736152234981940626874997797878207935722038940589336823000000000000000000", + "bulk_exposure_above_kappa": "16121349304484267303992582912917240381894571884517706343191289513957430029030314677602849068086303923728208174185415543380627387747235446238990477000732496183431878233175518270205104215865844020839130931621199513982731827123652777961059410663177/7812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "Gaussian_arithmetic_above_kappa": "19999058799402320875082850179861043577093298519082593432353263656347496871848177073675031963562500400554066581665250840886009242015822627871273296976878884614597749970254124964551132103250181493948531441520234328852534349856631858358718672531941382687506797163865578957/31294922884291839561979370201747972544823095637624234732902317608582979688069370590942598751956040102698274090040152051230783696844157505617437910942806025046414821803696926842103613365390998059229921715689999558045889217879855525014999982383025663485776311524714694584000000000000000000", + "scalar_work_above_kappa": "35646520241548240656072535280735029849504846337894710798804422460638986715882862369146331339540520451903203626685326866501401090437901380679992252448281897137805160872102588385602938785945680523563492299365234107875478958796559620866218663723454214430394952926222926249/31294922884291839561979370201747972544823095637624234732902317608582979688069370590942598751956040102698274090040152051230783696844157505617437910942806025046414821803696926842103613365390998059229921715689999558045889217879855525014999982383025663485776311524714694584000000000000000000", + "dimension_above_kappa": "975158659865880012971219231260523376765526903697790365147044240125461264135870049086539388279234174697371315421714794172178255971755886477744098175019220119867411547263616357078231257255428318176124023154048616341291977998332141488006722770266121812728667187394303993191155995837883221/977966340134119986311855318804624142025721738675757335403197425268218115252167830966956210998626253209321065313754751600961990526379922050544934716962688282700463181365528963815737917668468689350935053615312486188934038058745485156718749449469551983930509735147334205750000000000000000" + } + } + }, + "fresh_pr471_source_receipt": "/private/tmp/r715-response-gl-v3-source-proof/ASSEMBLY.json", + "fresh_pr471_receipt_sha256": "c8c4cdc7f2a469d76b6bd0b6a4594a317c3582b24c26484c4ddfc94d020b1c4e", + "GL_sharp_screen": { + "bit_lower": "1565442029626940232571/1000000000000000000000000", + "full_row_allowance": 28416, + "coefficient_bits": 6464, + "bit_endpoint_intervals": { + "1565442029626940232571/1000000000000000000000000": [ + "21267647932558653966460869784290506457515974292442225510115455532033/21267647932558653966460912964485513216000000000000000000000000000000", + "21267647932558653966460869784311774105448532946408686423079946265321/21267647932558653966460912964485513216000000000000000000000000000000" + ], + "391360507406735058143/250000000000000000000000": [ + "2658455991569831745807616145498610889991127716330056871710165046221/2658455991569831745807614120560689152000000000000000000000000000000", + "1329227995784915872903808072750634672991348774037932242915363193941/1329227995784915872903807060280344576000000000000000000000000000000" + ] + }, + "kappas_unchanged": true, + "kappas": { + "pr484": "662515748707749/500000000000000000", + "pr471": "260706019542937/200000000000000000", + "pr458": "323880830669511/250000000000000000", + "pr448": "358867191156973/250000000000000000" + }, + "scope": "Exact arithmetic plus reviewed dyadic full owner premises; does not claim a newly packaged GL all-size source replay." + }, + "scope": "Finite construction passes from pinned source with real Boost. Both reflected actual projectors, dirty/source restoration and whole owner matrices reviewed separately. PR471 b bound to fresh source replay. PR484 and PR458 retained as cited arithmetic only; PR448 remains information-only disputed split. All all-size compiler, mutable-label, restored-row and analytic contracts remain conditional." +} diff --git a/research/r489-pooled-retimed-complex/provenance/PR493-LOCAL.json b/research/r489-pooled-retimed-complex/provenance/PR493-LOCAL.json new file mode 100644 index 0000000000..dc4dd38e11 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/PR493-LOCAL.json @@ -0,0 +1,60 @@ +{ + "status": "PASS_INDEPENDENT_PR493_MUTABLE_SOURCE_LEDGER_AND_ACTUAL_OWNER_AUDIT", + "head": "c3a9a436b84fe44fdc223a5784d84736d1c2d3c7", + "source_frames": 672, + "exact_oriented_projector_transitions": 4702, + "orientations": { + "forward": { + "formal_columns": 729, + "dirty_helpers_restored": 489, + "source_registers_restored": 120, + "instructions": 36957, + "adds": 33990, + "copies": 9, + "source_write_actual_frame_dimensions": { + "4": 577, + "8": 577 + }, + "paid_profile": { + "1": 1200, + "2": 1440, + "4": 180, + "6": 120, + "8": 18 + }, + "actual_projector_ledger_sha256": "00c2ee2d60e22b4c1c612fd1e503cfe6da2b22e4a0f864bb2411ea89710c43ea" + }, + "reverse": { + "formal_columns": 729, + "dirty_helpers_restored": 489, + "source_registers_restored": 120, + "instructions": 36957, + "adds": 33990, + "copies": 9, + "source_write_actual_frame_dimensions": { + "0": 577, + "4": 577 + }, + "paid_profile": { + "1": 1200, + "2": 1440, + "4": 180, + "6": 120, + "8": 18 + }, + "actual_projector_ledger_sha256": "1158fb6b9a98f319fd70d01c3283f6525f7eb888b690317b0a4bfa8e2dd74172" + } + }, + "source_support_checks": 38838, + "mutable_source_destination_support_checks": 1154, + "no_targets_feed_sources_or_helpers": true, + "literal_source_helper_inverse_cleanup": true, + "actual_owner_routes": 43032, + "actual_unique_sigma_matrices": 2520, + "cross_idle_call_family_groups": 12780, + "idle_family_completion_groups": 12732, + "maximum_helpers_per_family": 7, + "actual_sigma_stream_sha256": "52210e222e19aa9f7e247f584b477402593e87a9713682e5f8224643d11f8103", + "modular_distinctness": "All routes for a physical family are one dyadic orthogonal port basis times distinct column permutations; equality is impossible over every odd field. Cross-idle assigned footprints are pairwise disjoint.", + "scope": "Exact native-frame local source/helper restoration and actual complete owner matrices. This does not unconditionally establish inherited all-size mutable-basis compiler, row or analytic contracts." +} diff --git a/research/r489-pooled-retimed-complex/provenance/RETIME-FINITE-ADMISSION.json b/research/r489-pooled-retimed-complex/provenance/RETIME-FINITE-ADMISSION.json new file mode 100644 index 0000000000..8dc82c9f53 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/RETIME-FINITE-ADMISSION.json @@ -0,0 +1,82 @@ +{ + "status": "PASS_COMPLETE_POOLED_COMPLEX_FINITE_ADMISSION", + "complex_template_sha256": "25718162bc14a8fb620b0dc3ff2ea57672fe9fff3766c4530e09b24ee54e9215", + "complex_profile": { + "1": 172056, + "2": 19008, + "3": 42032, + "4": 6048, + "5": 22496, + "6": 6624, + "7": 1800, + "8": 4120 + }, + "complex_live": 7680, + "physical": 8258, + "rank_mass": 558144, + "deficit": 2496, + "complex_hosted_residuals": 40320, + "one_owner_per_complete_invocation": true, + "actual_73column_sigmas": 3960, + "cross_replica_helper_roles": 35280, + "global_prefix_bits": 142, + "retained_payload_bits": 192, + "source_artifacts": { + "split-centres/CANONICAL-WORD.json.gz": "dfdebff4de27cbf5fd3458de6e3d41678ecdd30bc679c438b5fb1b65460a36e3", + "split-centres/LOCAL-PROGRAMS.json.gz": "e44d520a3414ca8863623aa6ea6489d3f730fbd025d69f050236deb4d0bb9137", + "split-centres/LOCAL-CHECKS.json": "a708c222fc1d69cef6a230e1d503be4f032b8cff66f411370ec78cd47d8c111e", + "split-centres/RESIDUAL-ADAPTERS.json": "546196e37830b9ccbc544834cb6f37ba4ad841faf96f025fe5155f5ba3924e07", + "work/complex-nine-native/DATA-PHASES.json": "f621f6d4296cb215f334830356c5f79fe10d6d04d15b3ccda76ba0885ab67d0a" + }, + "controller_audit_sha256": "505e5ed4eecf9ec8ed4d3d1b455b7329670e3aeb0782a6596a5b55d39f3e454f", + "controller_mutations_rejected": [ + "alias two whole owners", + "helper on active data family", + "owner in private namespace", + "unbound change of owner replica", + "omit complete invocation", + "reorder invocation replicas", + "interleave local invocations", + "change local instruction stream", + "wrong residual width", + "wrong spectator coordinate", + "omit spectator route", + "overlap residual footprint", + "omit idle remainder", + "underpay idle remainder", + "omit bridge touch", + "remove one-owner rule", + "duplicate frozen role", + "understate physical reserve" + ], + "bit_result_sha256": "dabd498ba5292da8cbc30496cfdd4e2543aaf26294142006790f54bf91062e86", + "complex_lower": "1345325487149526878087/1000000000000000000000000", + "kappa": "1343518018117309/1000000000000000000", + "kappa_decimal": "0.001343518018117309", + "observed_stages": [ + { + "stage": "owners", + "observed_exit": 0 + }, + { + "stage": "scalar-invoice", + "observed_exit": 0 + }, + { + "stage": "global-prefix", + "observed_exit": 0 + }, + { + "stage": "two-moments-outer", + "observed_exit": 0 + } + ], + "files": { + "OWNERS-AND-PROFILE.json": "436116960f1b1528931e58c028048a15aabf4d16f03c81c8f17ae06895f00767", + "PREFIX-AND-INVOICE.json": "a7db4e041ba35ca82537b2088a1c7ec96601a2c9a529bc70986f81d0214c3800", + "OBSERVED-EXITS.json": "4b563f11d8e00dd70af2205d7e077bc7c6124ff30fa995168a8c565ebe75f8fa", + "GLOBAL-PREFIX.json": "81a417104dcae71a7340c8fe608f7d0736c761f35c02cc4a1e455c0c822ee46e", + "EXACT-ASSEMBLY.json": "10c167b951899e468ba72850bb8695b78ec009523c1750f4e1ee731341745438" + }, + "scope": "Exact finite program, complete-invocation normalization, whole physical owners, both scalar orientations, full paid profile, cross-replica-safe global prefix and strict arithmetic assembly. Retains inherited all-size compiler/precision/tape/common-grid and analytic-transfer contracts. PR484 source remains unchanged; independent audit by OpenAI Codex." +} diff --git a/research/r489-pooled-retimed-complex/provenance/RETIME-FRAME-REVIEW.json b/research/r489-pooled-retimed-complex/provenance/RETIME-FRAME-REVIEW.json new file mode 100644 index 0000000000..85ad0ab6bf --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/RETIME-FRAME-REVIEW.json @@ -0,0 +1,150 @@ +{ + "status": "PASS_INDEPENDENT_FIXED_SCALAR_RETIMING_AND_BOTH_ACTUAL_FRAME_LEDGERS", + "bindings": { + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/FULL-WORD.json.gz": "b544a68e2d8d1fea28b2ae4a867c4585767396062bad3b322c0800e1670baa0b", + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/CANONICAL-WORD.json.gz": "dfdebff4de27cbf5fd3458de6e3d41678ecdd30bc679c438b5fb1b65460a36e3", + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/LOCAL-PROGRAMS.json.gz": "e44d520a3414ca8863623aa6ea6489d3f730fbd025d69f050236deb4d0bb9137", + "/private/tmp/pr484-independent-full-proof/gauge80-kernel42/split-centres/FULL-WORD.json.gz": "7e0a0d7fad7c1061de6fe849c30156a82e455d2a0e9ab92b88f3b92340e6b95d", + "/private/tmp/pr484-independent-full-proof/gauge80-kernel42/split-centres/CANONICAL-WORD.json.gz": "c85d1438f69e8bb43494256047fafd7d866e0dbed19984448b5e5372d345bc35" + }, + "reviewer_sha256": "d5f194f22e08da34f50e85c99fdc150b6b6860767c8f523c5093067f8c9af1ce", + "invariants": { + "changed_gate_frames": { + "A": 411, + "B": 504 + }, + "unchanged_scalar_gates": 4107, + "unchanged_initial_A_events_including_frames": 531, + "fixed_fields": [ + "center_frames", + "centers", + "cleanup", + "cut", + "ports", + "precondition", + "root_lines", + "scatter", + "start_extra", + "target_levels" + ] + }, + "original_raw_ledger": { + "profile": { + "1": 2057, + "2": 928, + "3": 50, + "4": 274, + "5": 314, + "6": 2, + "7": 1, + "8": 17 + }, + "rank_mass": 6884, + "child_count": 3643, + "climbs": 3610, + "center_rank_mass": 72, + "per_register_telescoping": true + }, + "retimed_raw_ledger": { + "profile": { + "1": 2385, + "2": 264, + "3": 530, + "4": 84, + "5": 270, + "6": 92, + "7": 1, + "8": 17 + }, + "rank_mass": 6884, + "child_count": 3643, + "climbs": 3610, + "center_rank_mass": 72, + "per_register_telescoping": true + }, + "canonical_binding": { + "transport_vector": 43, + "transport_exhaustively_orthogonal_and_linear": true, + "register_permutation_bijective": true, + "all_raw_canonical_incidences_bound": true, + "fixed_compensation_operations": 12082, + "actual_frame_count": 972 + }, + "emitted_ledgers": { + "forward": { + "events": 25082, + "event_counts": { + "phase": 9, + "scalar": 19708, + "adapter": 1478, + "residual_adapter": 244, + "climb": 3610, + "center": 33 + }, + "event_sha256": "4e70f6a476709990516458f87463b7986c377c858045bba57be305b3a90bef05", + "profile": { + "1": 2385, + "2": 264, + "3": 530, + "4": 84, + "5": 270, + "6": 92, + "7": 1, + "8": 17 + }, + "rank_mass": 6884, + "per_register_telescoping": true, + "private_center_paths": 16, + "entering_helpers": 122, + "scalar_operations": 19708, + "all_actual_labels_checked": true, + "actual_directed_edges": 2930, + "all_actual_edges_covered_by_canonical_phase_interface": true + }, + "backward": { + "events": 25082, + "event_counts": { + "phase": 9, + "scalar": 19708, + "adapter": 1478, + "residual_adapter": 244, + "climb": 3610, + "center": 33 + }, + "event_sha256": "376b830d7c256b14c37f1f829cf163b4bec41a0f84e2f9c84e124e6906a587fb", + "profile": { + "1": 2385, + "2": 264, + "3": 530, + "4": 84, + "5": 270, + "6": 92, + "7": 1, + "8": 17 + }, + "rank_mass": 6884, + "per_register_telescoping": true, + "private_center_paths": 16, + "entering_helpers": 122, + "scalar_operations": 19708, + "all_actual_labels_checked": true, + "actual_directed_edges": 2926, + "all_actual_edges_covered_by_canonical_phase_interface": true + } + }, + "negative_controls_rejected": [ + "raw_scalar_payload_change", + "changed_helper_entrance", + "downward_raw_retiming", + "canonical_frame_mismatch", + "missing_forward_climb", + "wrong_forward_climb_rank", + "wrong_backward_dual_sign", + "wrong_center_label", + "missing_entering_pre_wrapper", + "missing_entering_post_wrapper", + "wrong_exit_frame", + "wrong_center_rank" + ], + "scope": "Finite source and emitted-label retiming check only. Gaussian phase identities, exact all-column scalar arithmetic, complete global paid invoice, and inherited all-size/analytic interfaces are separate obligations." +} diff --git a/research/r489-pooled-retimed-complex/provenance/RETIME-FROZEN.json b/research/r489-pooled-retimed-complex/provenance/RETIME-FROZEN.json new file mode 100644 index 0000000000..a6b37a75b1 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/RETIME-FROZEN.json @@ -0,0 +1,40 @@ +{ + "status": "FROZEN_ACTUAL_RETIMED_WORD_GAUSSIAN_AND_GLOBAL_REPLAY_RUNNING", + "source_word": "/private/tmp/pr484-independent-full-proof/gauge80-kernel42/split-centres/FULL-WORD.json.gz", + "source_word_sha256": "7e0a0d7fad7c1061de6fe849c30156a82e455d2a0e9ab92b88f3b92340e6b95d", + "frozen_word": "/private/tmp/complex484-pooling-frontier/retiming/neutral-continue.json.gz", + "frozen_word_sha256": "b544a68e2d8d1fea28b2ae4a867c4585767396062bad3b322c0800e1670baa0b", + "variant": "/private/tmp/complex484-pooling-frontier/variant-final", + "changed_gate_frames": { + "A": 411, + "B": 504 + }, + "unchanged_prelude_A_gates": 531, + "local_profile": { + "1": 2385, + "2": 264, + "3": 530, + "4": 84, + "5": 270, + "6": 92, + "7": 1, + "8": 17 + }, + "pooled_profile": { + "1": 172056, + "2": 19008, + "3": 42032, + "4": 6048, + "5": 22496, + "6": 6624, + "7": 1800, + "8": 4120 + }, + "local_rank_mass": 6884, + "local_child_count": 3643, + "pooled_rank_mass": 558144, + "pooled_child_count": 274184, + "prospective_pooled_b": "0.00134532548714952687808771963307994282156374067364875908209549", + "discovery": "500 zero-cost/strict-descent component moves from original, then1500 continuation moves with no further cost improvement after the first100. No global retiming optimality claim.", + "scope": "Actual scalar word and source scalar/frame+emitted both-orientation audits; exact Gaussian phases/global admission pending. Frozen PR496 unchanged." +} diff --git a/research/r489-pooled-retimed-complex/provenance/RETIME-GAUSSIAN-ADMISSION.json b/research/r489-pooled-retimed-complex/provenance/RETIME-GAUSSIAN-ADMISSION.json new file mode 100644 index 0000000000..77c26df42f --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/RETIME-GAUSSIAN-ADMISSION.json @@ -0,0 +1,289 @@ +{ + "status": "PASS_FROZEN_RETIMED_GAUSSIAN_NORMALIZATION_AND_BOTH_PHYSICAL_ORIENTATIONS", + "word_sha256": "b544a68e2d8d1fea28b2ae4a867c4585767396062bad3b322c0800e1670baa0b", + "input_files": { + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/FULL-WORD.json.gz": "b544a68e2d8d1fea28b2ae4a867c4585767396062bad3b322c0800e1670baa0b", + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/CANONICAL-WORD.json.gz": "dfdebff4de27cbf5fd3458de6e3d41678ecdd30bc679c438b5fb1b65460a36e3", + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/LOCAL-PROGRAMS.json.gz": "e44d520a3414ca8863623aa6ea6489d3f730fbd025d69f050236deb4d0bb9137", + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/CLIFFORD-RECIPES.json": "0193454a8fce6e5b1962728c6c92acc56e88d227b3fdcac1c9e5e2e912bd9dbf", + "/private/tmp/complex484-pooling-frontier/variant-final/split-centres/RESIDUAL-ADAPTERS.json": "546196e37830b9ccbc544834cb6f37ba4ad841faf96f025fe5155f5ba3924e07" + }, + "pinned_checker_files": { + "code/lemmaG/lg_phys.py": "0ca37829b596d83d0b94c5f0b6b278a100f22e626b2ab3b5210a38f9657c8a27", + "code/lemmaG/check.py": "f572b7129a546e1b1193fdd5baee4f731a5b9b8a4e8dc7ac170bcad7758e5b9a", + "code/lemmaG/lg_mutants.py": "cf0d1f8e90a0780244b6de38d6aad08dd42f4c439397a6d5a61fccd23fe7e798", + "code/lemmaG/lg_lib.py": "00068882bf2f2ebadd3f87c94204f226c7938966124bafb9ce6da89bfaf91b45", + "code/lemmaG/gd.py": "64cdb2cfefc9ec3ed80c277a18848778427c3d3dbda9b7be13f740522478e1de", + "code/lemmaG/lg_e2e.py": "8fe3719e8ec5ec49af480b40c15f07612a356f5071ea30e17ae2d8931b3f20ce", + "code/lemmaG/run_labels.py": "5f053e553b1c26e553a844e2891a73b6cc6b79404a7bb5d4722529f7db0d592c", + "code/lemmaG/lg_instances.py": "47dcf2e9ae2d99699424d684abebc3d1d2d25b7aa6d440761e19835d140f5fbb" + }, + "guard_sha256": "e572010d33bbb39f4756c785270b5fc9cb82ee6ee4d4cd75d0a1ca49d773a587", + "observed_steps": [ + { + "stage": "lg_instances.py", + "arguments": [ + "variant-final" + ], + "exit": 0, + "seconds": 99.07321712496923 + }, + { + "stage": "lg_e2e.py", + "arguments": [ + "variant-final", + "256", + "20261111" + ], + "exit": 0, + "seconds": 64.44702758302446 + } + ], + "instances": { + "variant": "variant-final", + "I-tr": { + "transitions": 2945, + "columns_each": 512, + "failures": [] + }, + "I-comp": { + "compensation_gates": 420, + "targets": 50, + "entering_helpers_compensating": 80, + "input_registers": 130, + "columns_each": 512, + "target_levels_after_segment": [ + 2, + 4, + 5 + ], + "failures": [] + }, + "I-centre": { + "centres": 16, + "detail": [ + { + "centre": 0, + "register": 99, + "frame": 480, + "path_dims": [ + 8, + 0 + ], + "targets": 28 + }, + { + "centre": 1, + "register": 64, + "frame": 481, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 2, + "register": 365, + "frame": 482, + "path_dims": [ + 8, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 3, + "register": 30, + "frame": 483, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 4, + "register": 393, + "frame": 484, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 5, + "register": 98, + "frame": 485, + "path_dims": [ + 8, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 6, + "register": 421, + "frame": 486, + "path_dims": [ + 8, + 4, + 2, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 7, + "register": 96, + "frame": 487, + "path_dims": [ + 8, + 1, + 0 + ], + "targets": 28 + }, + { + "centre": 8, + "register": 35, + "frame": 967, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 9, + "register": 0, + "frame": 964, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 10, + "register": 13, + "frame": 965, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 11, + "register": 54, + "frame": 970, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 12, + "register": 40, + "frame": 968, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 13, + "register": 119, + "frame": 971, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 14, + "register": 22, + "frame": 966, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + }, + { + "centre": 15, + "register": 51, + "frame": 969, + "path_dims": [ + 1, + 0 + ], + "targets": 1 + } + ], + "failures": [] + }, + "I-helper": { + "entering_helpers": 122, + "widths": { + "8": 104, + "7": 14, + "5": 4 + }, + "columns_each": 512, + "failures": [] + }, + "seconds": 98.5 + }, + "end_to_end": { + "variant": "variant-final", + "seed": 20261111, + "columns": 806, + "kinds": { + "port": 240, + "centre": 16, + "random": 256, + "entering": 244, + "target_level": 50 + }, + "batches": 26, + "failures": [], + "dense": 8, + "seconds": 63.7, + "status": "PASS" + }, + "preoperation_bounds": { + "lg_instances.py": { + "add_calls": 1116, + "scale_calls": 884, + "primitive_calls": 102786, + "maximum_proved_numerator_bits": 14 + }, + "lg_e2e.py": { + "add_calls": 251980, + "scale_calls": 8810, + "primitive_calls": 854127, + "maximum_proved_numerator_bits": 29 + } + }, + "scope": "All used transition recipes and entering-helper complete chains checked on all512basis columns; full physical programs tested on structured and random basis columns plus dense arbitrary dirt, both orientations. Common-label universality and exact all800column scalar audits supplied independently; inherited all-size compiler/precision/tape and analytic transfer remain conditional." +} diff --git a/research/r489-pooled-retimed-complex/provenance/UNPOOLED-SELECTION.json b/research/r489-pooled-retimed-complex/provenance/UNPOOLED-SELECTION.json new file mode 100644 index 0000000000..8555dae09f --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/UNPOOLED-SELECTION.json @@ -0,0 +1,828 @@ +{ + "complex-gauge80-kernel42": { + "patterns": [ + [ + 0, + [ + [ + 0, + 8 + ], + [ + 1, + 8 + ] + ], + 104 + ], + [ + 0, + [ + [ + 0, + 9 + ] + ], + 2 + ], + [ + 0, + [ + [ + 0, + 9 + ], + [ + 1, + 7 + ] + ], + 14 + ], + [ + 1, + [], + 120 + ], + [ + 2, + [ + [ + 0, + 7 + ], + [ + 1, + 9 + ] + ], + 14 + ], + [ + 2, + [ + [ + 0, + 9 + ] + ], + 66 + ], + [ + 2, + [ + [ + 1, + 9 + ] + ], + 40 + ], + [ + 3, + [], + 16 + ], + [ + 3, + [ + [ + 2, + 8 + ] + ], + 104 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 5 + ], + [ + 3, + 9 + ] + ], + 4 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 7 + ], + [ + 3, + 7 + ] + ], + 14 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ] + ], + 78 + ], + [ + 4, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 3, + 8 + ] + ], + 24 + ], + [ + 5, + [], + 16 + ], + [ + 5, + [ + [ + 4, + 8 + ] + ], + 104 + ], + [ + 6, + [ + [ + 0, + 5 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ] + ], + 4 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 1, + 5 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ] + ], + 4 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ] + ], + 16 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 5 + ] + ], + 4 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 8 + ] + ], + 76 + ], + [ + 6, + [ + [ + 0, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ] + ], + 16 + ], + [ + 7, + [], + 106 + ], + [ + 7, + [ + [ + 4, + 7 + ] + ], + 14 + ], + [ + 8, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ], + [ + 4, + 9 + ] + ], + 54 + ], + [ + 8, + [ + [ + 0, + 9 + ], + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ] + ], + 66 + ], + [ + 9, + [], + 16 + ], + [ + 9, + [ + [ + 6, + 8 + ] + ], + 104 + ], + [ + 10, + [ + [ + 1, + 9 + ], + [ + 2, + 9 + ], + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ] + ], + 120 + ], + [ + 11, + [], + 120 + ], + [ + 12, + [ + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 90 + ], + [ + 12, + [ + [ + 3, + 9 + ], + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 30 + ], + [ + 13, + [ + [ + 3, + 8 + ], + [ + 4, + 5 + ], + [ + 5, + 8 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 13, + [ + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ] + ], + 2 + ], + [ + 13, + [ + [ + 3, + 9 + ], + [ + 4, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 106 + ], + [ + 13, + [ + [ + 3, + 9 + ], + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 8 + ], + [ + 14, + [ + [ + 5, + 5 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 14, + [ + [ + 5, + 7 + ], + [ + 6, + 7 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 6 + ], + [ + 14, + [ + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ] + ], + 110 + ], + [ + 15, + [ + [ + 5, + 7 + ], + [ + 6, + 7 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 8 + ], + [ + 15, + [ + [ + 5, + 8 + ], + [ + 6, + 9 + ], + [ + 8, + 9 + ] + ], + 100 + ], + [ + 15, + [ + [ + 5, + 9 + ], + [ + 6, + 5 + ], + [ + 7, + 9 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 15, + [ + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 5 + ], + [ + 8, + 9 + ] + ], + 4 + ], + [ + 15, + [ + [ + 5, + 9 + ], + [ + 6, + 9 + ], + [ + 7, + 9 + ], + [ + 8, + 5 + ] + ], + 4 + ], + [ + 16, + [ + [ + 7, + 9 + ] + ], + 46 + ], + [ + 16, + [ + [ + 7, + 9 + ], + [ + 8, + 7 + ] + ], + 14 + ], + [ + 16, + [ + [ + 8, + 9 + ] + ], + 60 + ], + [ + 17, + [ + [ + 7, + 7 + ], + [ + 8, + 9 + ] + ], + 14 + ], + [ + 17, + [ + [ + 7, + 8 + ], + [ + 8, + 8 + ] + ], + 104 + ], + [ + 17, + [ + [ + 7, + 9 + ] + ], + 2 + ] + ], + "proxy_saving": 30445.167647508395, + "rule": "one-helper-per-family" + } +} diff --git a/research/r489-pooled-retimed-complex/provenance/nominate.py b/research/r489-pooled-retimed-complex/provenance/nominate.py new file mode 100644 index 0000000000..a3590c7fe1 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/nominate.py @@ -0,0 +1,62 @@ +"""New nomination only: correct per-width bank padding and exact-exponent objective. +Uses PR484 frozen word. No scalar or all-size admission is implied. +Prepared by OpenAI Codex; reuses PR484 pattern enumerator with attribution. +""" +from pathlib import Path +import sys,json,gzip,math,importlib.util +from collections import Counter +import numpy as np +from scipy.optimize import milp,LinearConstraint,Bounds +from scipy.sparse import lil_matrix +ROOT=Path(__file__).resolve().parents[1]/'vendor/complex/e8-complex-gauge-kernel' +sys.path.insert(0,str(ROOT/'code')) +import onehost_gk as OH +OUT=Path(sys.argv[2]).resolve();OUT.mkdir(parents=True,exist_ok=False) +PROOF=Path(sys.argv[1]).resolve() +t=json.load(gzip.open(PROOF/'hosted/GLOBAL-TEMPLATE.json.gz')) +c=json.load(gzip.open(PROOF/'split-centres/CANONICAL-WORD.json.gz')) +widths=[9-len(c['frames'][c['start'][240+i]]) for i in range(c['R'])] +WID=Counter(widths); avail={(s,w):n for s in range(9) for w,n in WID.items()} +win={int(i):(p,r,st) for i,(p,r,st) in t['hosting']['windows'].items()} +var=[(i,pat) for i,(p,r,st) in sorted(win.items()) for pat in OH.patterns(r,sorted(st),sorted(WID))] +ids=sorted(win); aws=sorted(avail); n=len(var) +A=lil_matrix((len(ids)+len(aws),n)); idx={i:j for j,i in enumerate(ids)}; ai={sw:len(ids)+j for j,sw in enumerate(aws)} +for j,(i,pat) in enumerate(var): + A[idx[i],j]=1 + for sw in pat:A[ai[sw],j]=1 +A=A.tocsr(); lo=np.r_[np.full(len(ids),120),np.zeros(len(aws))]; hi=np.r_[np.full(len(ids),120),np.array([avail[x] for x in aws])] +print('variables',n,'windows',len(win),'widths',WID,flush=True) +oldsel=json.load(open(ROOT/'data/SELECTION.json'))['complex-gauge80-kernel42']['patterns'] +local=json.load(open(PROOF/'split-centres/LOCAL-CHECKS.json')) + +def profile(sel): + H=Counter(); used=Counter();rem=[] + for call in t['calls']: + H.update({int(r):z for r,z in local[call['orientation']]['paid_profile'].items()}) + for i,pat,n in sel: + left=win[i][1]-sum(w for s,w in pat) + if left:H[left]+=8*n + used.update({(s,w):n for s,w in pat}) + banks=0; rest={} + for sw,a in avail.items(): + z=a-used[sw]; assert z>=0 + if z:rest[str(sw)]=z; banks+=z;H[73-8*sw[1]]+=z + # original excluded windows are untouched, from parent template + parent=json.load(gzip.open(PROOF/'split-centres/GLOBAL-TEMPLATE.json.gz')) + for it in parent['idle_children']: + if it['child'] not in win:H[it['rank']]+=it['replicas'] + live=7680+banks;assert 73*live-sum(r*n for r,n in H.items())==2496 + return dict(histogram=dict(sorted(H.items())),live=live,banks=banks,unhosted_per_replica=rest,deficit=2496) +assert profile(oldsel)['histogram']=={int(r):n for r,n in json.load(open(PROOF/'hosted/HOSTED.json'))['global_profile'].items()} +for label,b in [('entropy',0),('at484',.001326789535340266)]: + def cost(r):return r*math.expm1(b*math.log(73/r))/b if r and b else r*math.log(73/r) if r else 0 + def objective(i,pat):return cost(win[i][1])-cost(win[i][1]-sum(w for s,w in pat))+sum(cost(73-8*w)/8 for s,w in pat) + obj=np.array([-objective(i,pat) for i,pat in var]) + res=milp(obj,integrality=np.ones(n),bounds=Bounds(0,np.inf),constraints=LinearConstraint(A,lo,hi),options={'time_limit':90,'mip_rel_gap':1e-10}) + assert res.x is not None,res + x=np.rint(res.x).astype(int);assert abs(A@x-hi)[:len(ids)].max()==0 and np.all(A@x<=hi) and np.all(x>=0) + sel=[[i,[list(z) for z in pat],int(x[j])] for j,(i,pat) in enumerate(var) if x[j]] + result=profile(sel)|dict(status='NOMINATION_ONLY',scipy_status=int(res.status),message=res.message,mip_gap=float(res.mip_gap),objective=-float(res.fun),old_objective=sum(n*objective(i,pat) for i,pat,n in oldsel),b=b,patterns=sel) + (OUT/f'{label}.json').write_text(json.dumps(result,indent=2)+'\n') + (OUT/f'SELECTION-{label}.json').write_text(json.dumps({'complex-gauge80-kernel42':dict(rule='one-helper-per-family',patterns=sorted(sel),proxy_saving=-float(res.fun))},indent=1,sort_keys=True)+'\n') + print(label,{k:v for k,v in result.items() if k not in ['patterns','histogram']},flush=True) diff --git a/research/r489-pooled-retimed-complex/provenance/retime_continue.py b/research/r489-pooled-retimed-complex/provenance/retime_continue.py new file mode 100644 index 0000000000..e02c42c1b3 --- /dev/null +++ b/research/r489-pooled-retimed-complex/provenance/retime_continue.py @@ -0,0 +1,69 @@ +"""OpenAI Codex fixed-gate frame-component retiming search. +All local scalar operations and selected entrance gauges/kernel remain fixed. +""" +exec(open('/private/tmp/complex484-pooling-frontier/retime_word.py').read().split('out=[finish')[0]) +import math,time,random +random.seed(484) +alpha=133385415620840915601/10**23 +cost=lambda r:r/73*math.expm1(alpha*math.log(73/r))+32*73/10**16*73**alpha if r else 0. +def optimize(word,tag): + z=copy.deepcopy(word);labels=[];fixed=[];eventnodes={};seq=[[]for _ in range(n)] + def node(F,pin,rs,key=None): + i=len(labels);labels.append(basis(F));fixed.append(pin) + for r in rs:seq[r].append(i) + if key:eventnodes[key]=i + return i + for r,F in enumerate(start):node(F,True,[r]) + for part in ['A','B']: + if part=='B': + for r,F in zip(z['centers'],z['center_frames']):node(F,True,[r]) + for t in range(V):node(z.get('target_levels',{}).get(str(t),[]),True,[V+t]) + for j,e in enumerate(z[part]):node(e[-1],False,registers(e),(part,j)) + for r,F in enumerate(final):node(F,True,[r]) + edges=[(a,b,r)for r,ss in enumerate(seq)for a,b in zip(ss,ss[1:])] + def total():return sum(cost(len(labels[b])-len(labels[a]))for a,b,r in edges) + startcost=total();moves=[];t0=time.monotonic();tabu=set();bestcost=startcost;bestlabels=labels.copy() + for iteration in range(1500): + par=list(range(len(labels))) + def root(i): + while par[i]!=i:par[i]=par[par[i]];i=par[i] + return i + for a,b,r in edges: + assert span(labels[a])<=span(labels[b]) + if labels[a]==labels[b]:par[root(a)]=root(b) + comps={};pins={};incoming={};outgoing={} + for i in range(len(labels)): + c=root(i);comps.setdefault(c,[]).append(i);pins[c]=pins.get(c,False)or fixed[i] + for a,b,r in edges: + ca,cb=root(a),root(b) + if ca!=cb:outgoing.setdefault(ca,[]).append((a,b,r));incoming.setdefault(cb,[]).append((a,b,r)) + best=None;neutral=[];state=hash(tuple(labels)) + for c,ns in comps.items(): + if pins[c]:continue + ins=incoming.get(c,[]);outs=outgoing.get(c,[]) + low=basis([v for a,b,r in ins for v in labels[a]]);up=basis(set.intersection(*(span(labels[b])for a,b,r in outs))) + cf=labels[ns[0]];old=sum(cost(len(cf)-len(labels[a]))for a,b,r in ins)+sum(cost(len(labels[b])-len(cf))for a,b,r in outs) + for nf in {low,up}: + if nf==cf:continue + new=sum(cost(len(nf)-len(labels[a]))for a,b,r in ins)+sum(cost(len(labels[b])-len(nf))for a,b,r in outs);delta=new-old + if delta<-1e-13 and(best is None or delta 104; nine fresh total registers give R = 489 at 100 bits. + +## Scope + +Conditional on every interface #472's eleven-stage composition retains: the all-size bit/Gaussian compiler, +mutable-basis and target-label realization, whole-call correlated-helper hosting (#442), compressed windows, +restored work, common grid and tape, precision, row and analytic contracts. Complex savings are cited from their +PRs' receipts, not rebuilt; the primary κ also rests on #484's Lemmas A and G. The hosting selection is a frozen nomination of #442's integer programme +(`discovery/host_select.py`) and the plan a CP-SAT nomination (`discovery/plan.py`); neither is claimed optimal. +No unconditional multiplication theorem, Lean proof or κ = 1 result is claimed. + +## Credits + +Zhihao Chen (#425: the mutable-basis interface lemma; #386: nine-stage geometry); DreamingOfClouds (#463: the +carrier bound; #315: moment engines; #484: the primary complex supplier); DaysSky (#442: idle-axis hosting; #381: `columns_k`); chafreaky (#445, #451, +#472: eleven-stage geometry, row bound, pooled whole hosting, emitter, audit and invoice; #443's bank routes; +#458's complex supplier); Dylan Crow (#370: bitE8/1 format, independent checker, generalised official checkers); +icekylinx (#433: source rows written on the bit side); Dugongue (#471: complex supplier; #483: current +whole-residual frontier); higherbeing (#448, information only); eumemic (#436: R740 and the provenance tooling); Jacob Sussman (the E8 unit). Details in +`NOTICE.md`. + +Prepared by eumemic with substantial Anthropic Claude assistance. Apache-2.0 (`LICENSE`). diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr370.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr370.json new file mode 100644 index 0000000000..1b30f277af --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr370.json @@ -0,0 +1,69 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/370", + "head_repository": "utcorvusvolat-dotcom/e8-bit-kappa-8.7548e-4", + "commit": "b7fe9cdf2da009c947ff6b334c562bc190b30373", + "note": "PR #370 (Dylan Crow / utcorvusvolat-dotcom, with Anthropic Claude assistance): independent checker and its word-level controls, record exporter and record-level controls, PR #266's official cohort checkers as generalised there (NCOPY), Gram/prime-witness checker, PR #315's engines (DreamingOfClouds) as vendored there, the E8 label table (via its R865 word), LICENSE. Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "LICENSE": { + "source_path": "research/e8-bit/LICENSE", + "blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64" + }, + "code/bit/independent/checkword.py": { + "source_path": "research/e8-bit/code/bit/independent/checkword.py", + "blob": "da4e0fe05067184d4dab1e130ae1384c1fa983f5" + }, + "code/bit/independent/mutate.py": { + "source_path": "research/e8-bit/code/bit/independent/mutate.py", + "blob": "eba592fd468e0d7e7e5100fe99da6eb548c5906b" + }, + "code/bit/export_records.py": { + "source_path": "research/e8-bit/code/bit/export_records.py", + "blob": "3632d370486a02f5456f7643ced03f8c925b2350" + }, + "code/bit/mutate_records.py": { + "source_path": "research/e8-bit/code/bit/mutate_records.py", + "blob": "6794516f665d36eac189894e350a5ad01113cb4c" + }, + "code/bit/regression/stage_cohort.py": { + "source_path": "research/e8-bit/code/bit/regression/stage_cohort.py", + "blob": "f6d7afe3e623208c4207b6a683a1e3e49249e31c" + }, + "code/bit/checkers/legality_h.cpp": { + "source_path": "research/e8-bit/code/bit/checkers/legality_h.cpp", + "blob": "cb1233c7e96b1aa8bbf4d2e4165d75ab0dca64b9" + }, + "code/bit/checkers/columns_h.cpp": { + "source_path": "research/e8-bit/code/bit/checkers/columns_h.cpp", + "blob": "00c5a3a5d81d083582f60f33dd2e7bea5049c37f" + }, + "code/bit/checkers/json.hpp": { + "source_path": "research/e8-bit/code/bit/checkers/json.hpp", + "blob": "82d69f7c5d044c9887c96b90c97f5639083ecd14" + }, + "code/bit/checkers/gram_frames.py": { + "source_path": "research/e8-bit/code/bit/checkers/gram_frames.py", + "blob": "b740d47295c02692260d7cc01874a49fe48f78ab" + }, + "code/pricing/moment.py": { + "source_path": "research/e8-bit/code/pricing/moment.py", + "blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd" + }, + "code/pricing/base_two_moment.py": { + "source_path": "research/e8-bit/code/pricing/base_two_moment.py", + "blob": "14a90fa0e788217856f070382c9e61bd7c603c61" + }, + "code/pricing/outer.py": { + "source_path": "research/e8-bit/code/pricing/outer.py", + "blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2" + }, + "code/pricing/prime_witnesses.py": { + "source_path": "research/e8-bit/code/pricing/prime_witnesses.py", + "blob": "7f16d930302ae879c562dd58e085d9747fcac077" + }, + "data/bit/bitE8-r865.json.gz": { + "source_path": "research/e8-bit/data/bit/bitE8-r865.json.gz", + "blob": "8bec1751f7e33c3a1e4673ef5dbc34d6f205321e" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr381.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr381.json new file mode 100644 index 0000000000..fb0b0edd13 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr381.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/381", + "head_repository": "DaysSky/integer-mult-bounds", + "commit": "00765b291d0f924f337298eb1e2930cb0878b95e", + "note": "PR #381 (DaysSky, assisted with Claude): the B_K formal-columns checker columns_k.cpp (KPAIRS). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "code/bit/checkers/columns_k.cpp": { + "source_path": "research/e8-nine-stage-kappa/code/bit/checkers/columns_k.cpp", + "blob": "42bb232fbec4de703e70cc13dc2f39a3b43a3a01" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr386.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr386.json new file mode 100644 index 0000000000..3744861904 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr386.json @@ -0,0 +1,17 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/386", + "head_repository": "jacklightChen/integer-mult-bounds", + "commit": "dd11cf8069554f0333afde398f12a56c3a7c29dd", + "note": "PR #386 (Zhihao Chen / jacklightChen, with OpenAI Codex assistance): compressed nine-stage bit geometry (used here only as the parent geometry of the eleven-stage audit) and the portable bits/stdc++.h. Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "portable-include/bits/stdc++.h": { + "source_path": "research/e8-bit-complex-nine/portable-include/bits/stdc++.h", + "blob": "fc5664e929d9a81d9b4926bee049a93330be86ec" + }, + "code/nine/geometry.py": { + "source_path": "research/e8-bit-complex-nine/geometry.py", + "blob": "91594e0223e8fac49162b5aef834ffaa8e94a254" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr436.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr436.json new file mode 100644 index 0000000000..f190527ae1 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr436.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/436", + "head_repository": "eumemic/integer-mult-bounds", + "commit": "8f6b8297b08ad863940d5168a2db5402fad3690f", + "note": "PR #436 (eumemic, with Anthropic Claude assistance): the provenance checker. Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "code/provenance.py": { + "source_path": "research/e8-bit-elimination-reuse/code/provenance.py", + "blob": "9bfcb106230e454d9405ce5eb42dd2218d905ea6" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr445.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr445.json new file mode 100644 index 0000000000..ae29de391a --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr445.json @@ -0,0 +1,25 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/445", + "head_repository": "chafreaky/integer-mult-bounds", + "commit": "40ab91daf2b5e87fc4071dedae1699d5d7e7cecc", + "note": "PR #445 (chafreaky, with OpenAI Codex assistance): eleven-stage compressed bit geometry, elementary orthogonal-cover row bound, and its eleven-stage emitter and frozen hosting selection (used unchanged for the PR #445 R740 control). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "code/hub/r740-hosted-eleven/code/geometry.py": { + "source_path": "research/r740-hosted-eleven/code/geometry.py", + "blob": "b4ad5074014dc00a01143910eb1cd27fafe0e15c" + }, + "code/hub/r740-hosted-eleven/code/row_bound.py": { + "source_path": "research/r740-hosted-eleven/code/row_bound.py", + "blob": "11d3c0d48e4ea5a02ac3b6689f3c7d36f2972eb8" + }, + "code/hub/r740-hosted-eleven/code/emit.py": { + "source_path": "research/r740-hosted-eleven/code/emit.py", + "blob": "5ff0de0d6f088ac95e25a2a7aed8653e8cd0333e" + }, + "code/hub/r740-hosted-eleven/data/selection.json": { + "source_path": "research/r740-hosted-eleven/data/selection.json", + "blob": "8e548e5a9204a909d539ba36b866804b256d4c2b" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr448.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr448.json new file mode 100644 index 0000000000..3648ab3692 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr448.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/448", + "head_repository": "higherbeing/integer-mult-bounds", + "commit": "359022bcd71143e45d48def0dd005bf67f339aa7", + "note": "PR #448: its EXPECTED.json receipt (cited complex b). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "data/complex/pr448/EXPECTED.json": { + "source_path": "research/cross-copy-hosting/EXPECTED.json", + "blob": "1574e6488b6fc59191ae49fcc0c089e48b196fbd" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr451.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr451.json new file mode 100644 index 0000000000..fbd9881e09 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr451.json @@ -0,0 +1,25 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/451", + "head_repository": "chafreaky/integer-mult-bounds", + "commit": "f3a38153678b55063fc005901cc968266166507d", + "note": "PR #451 (chafreaky, with OpenAI Codex assistance): its eleven-stage bit emitter (byte-identical to PR #445's), frozen hosting selection, R740 rank149 word and residual isometries, used unchanged for the PR #451 control. Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "code/hub/r740-hosted-rank149/code/emit.py": { + "source_path": "research/r740-hosted-rank149/code/emit.py", + "blob": "5ff0de0d6f088ac95e25a2a7aed8653e8cd0333e" + }, + "code/hub/r740-hosted-rank149/data/selection.json": { + "source_path": "research/r740-hosted-rank149/data/selection.json", + "blob": "c57069f7385c3b6aff4fe3c73c0a21bae727c76f" + }, + "code/hub/r740-hosted-rank149/data/word.json.gz": { + "source_path": "research/r740-hosted-rank149/data/word.json.gz", + "blob": "3c8489a29f0de2cad7dafaddc340a1ff197d5172" + }, + "code/hub/r740-hosted-rank149/data/residual-isometries.json": { + "source_path": "research/r740-hosted-rank149/data/residual-isometries.json", + "blob": "ec8b4131d203d7a288ca078ca559f922d38fe9d2" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr458.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr458.json new file mode 100644 index 0000000000..c36c74cbea --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr458.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/458", + "head_repository": "chafreaky/integer-mult-bounds", + "commit": "44e9eae8287951c1e6dbbd3c553f5743fe2240b0", + "note": "PR #458: its EXPECTED.json receipt (cited complex b). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "data/complex/pr458/EXPECTED.json": { + "source_path": "research/e8-complex-adapted-kernel/EXPECTED.json", + "blob": "e06a17c177eee0e0962c96ea61554239ef38ef4d" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr471.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr471.json new file mode 100644 index 0000000000..0dc019cfb1 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr471.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/471", + "head_repository": "Dugongue/integer-mult-bounds", + "commit": "56b3da6aa1295d37ce43f1753479bfe4737b7ac3", + "note": "PR #471: its EXPECTED.json receipt (cited complex b). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "data/complex/pr471/EXPECTED.json": { + "source_path": "research/e8-tensor-normalization/EXPECTED.json", + "blob": "ed1e72239ebebdbfad847fb817e5546f980c1d8d" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr472.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr472.json new file mode 100644 index 0000000000..31acb027ec --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr472.json @@ -0,0 +1,73 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/472", + "head_repository": "chafreaky/integer-mult-bounds", + "commit": "259c68488b7aa8a14cf3fcae7fc499381c9bf729", + "note": "PR #472 (chafreaky, with OpenAI Codex assistance) and the files its branch carries unchanged: research/e8-r715-whole-hosted (PR #472: eight-replica pooled whole-residual emitter, independent audit, local projector audit, assembly, R715 word, isometries, frozen hosting); research/e8-r740-replica32 (PR #443, chafreaky: bank routes, tiling, engine wrapper, the R740 rank138 word and its isometries; PR #315 engines by DreamingOfClouds); research/idle-axis-hosting/hosting_core.py (PR #442, DaysSky). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "code/hub/e8-r740-replica32/code/bank_routes.py": { + "source_path": "research/e8-r740-replica32/code/bank_routes.py", + "blob": "9e43a876664a26899762f3b8e9a582e684a3650a" + }, + "code/hub/e8-r740-replica32/code/tile_m.py": { + "source_path": "research/e8-r740-replica32/code/tile_m.py", + "blob": "cd5fd9b5399f5e7afe5d2a95bd3504bd543c0d60" + }, + "code/hub/e8-r740-replica32/code/e8core.py": { + "source_path": "research/e8-r740-replica32/code/e8core.py", + "blob": "78983b368715e89fe8524a6dd2c13585d2b5394e" + }, + "code/hub/e8-r740-replica32/code/engines/moment.py": { + "source_path": "research/e8-r740-replica32/code/engines/moment.py", + "blob": "7d697cb45203fe72d97037403d6da41f71f3b7fd" + }, + "code/hub/e8-r740-replica32/code/engines/base_two_moment.py": { + "source_path": "research/e8-r740-replica32/code/engines/base_two_moment.py", + "blob": "14a90fa0e788217856f070382c9e61bd7c603c61" + }, + "code/hub/e8-r740-replica32/code/engines/outer.py": { + "source_path": "research/e8-r740-replica32/code/engines/outer.py", + "blob": "43007488ad2c43187c77cc6798beff8b1cd76ad2" + }, + "code/hub/e8-r740-replica32/data/word.json.gz": { + "source_path": "research/e8-r740-replica32/data/word.json.gz", + "blob": "85390b07e4747feddbf2e16f94b5e0a8a308c191" + }, + "code/hub/e8-r740-replica32/data/residual-isometries.json": { + "source_path": "research/e8-r740-replica32/data/residual-isometries.json", + "blob": "9b8b35cb1528a978e209e1098864cae48c57fd93" + }, + "code/hub/idle-axis-hosting/hosting_core.py": { + "source_path": "research/idle-axis-hosting/hosting_core.py", + "blob": "68b536daa9e6546c0aa046934bf840aaa3c3fde3" + }, + "code/hub/e8-r715-whole-hosted/code/emit.py": { + "source_path": "research/e8-r715-whole-hosted/code/emit.py", + "blob": "df74ad698a98419e828b37d4dfd7c036fc49a890" + }, + "code/hub/e8-r715-whole-hosted/code/audit.py": { + "source_path": "research/e8-r715-whole-hosted/code/audit.py", + "blob": "155b61f2944116423a5be6ae666276e1c1827fe5" + }, + "code/hub/e8-r715-whole-hosted/code/local_audit.py": { + "source_path": "research/e8-r715-whole-hosted/code/local_audit.py", + "blob": "931f884920125b334412f70cf30d9517b084dc7a" + }, + "code/hub/e8-r715-whole-hosted/code/assemble.py": { + "source_path": "research/e8-r715-whole-hosted/code/assemble.py", + "blob": "cd60b4bcfae515fccd7f21fd1ff5a7114a132eb9" + }, + "code/hub/e8-r715-whole-hosted/data/word.json.gz": { + "source_path": "research/e8-r715-whole-hosted/data/word.json.gz", + "blob": "f7d55b8bd45d385011ced25e632a3d922bb77bba" + }, + "code/hub/e8-r715-whole-hosted/data/residual-isometries.json": { + "source_path": "research/e8-r715-whole-hosted/data/residual-isometries.json", + "blob": "5864e4d680035401d53d32adab0369046d80b171" + }, + "code/hub/e8-r715-whole-hosted/data/hosting.json": { + "source_path": "research/e8-r715-whole-hosted/data/hosting.json", + "blob": "381fb06ccbe055f4fbdc7544dcf8c0bae8f96701" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr473.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr473.json new file mode 100644 index 0000000000..821caf8f07 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr473.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/473", + "head_repository": "rohanarun/integer-mult-bounds", + "commit": "c7590f1d861f0eaae725cc79901445385aab9125", + "note": "PR #473: its EXPECTED.json receipt (cited complex b; frontier kappa). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "data/complex/pr473/EXPECTED.json": { + "source_path": "research/r715-replica84-complex79/EXPECTED.json", + "blob": "45ee9fde7fdf6b19b6303372068977201b4ef61c" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr478.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr478.json new file mode 100644 index 0000000000..608323ccbe --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr478.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/478", + "head_repository": "Dugongue/integer-mult-bounds", + "commit": "bea1d52fd330c699903f81612ee58be81697d1eb", + "note": "PR #478: its EXPECTED.json receipt (cited complex b; frontier kappa). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "data/complex/pr478/EXPECTED.json": { + "source_path": "research/tensor-r715-next/EXPECTED.json", + "blob": "77f5805cd8125602e8c50f4eaba1691440c611c2" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr483.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr483.json new file mode 100644 index 0000000000..817396d9c8 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr483.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/483", + "head_repository": "Dugongue/integer-mult-bounds", + "commit": "3738c3ce2d04d6a6c6363408ff9402286f592bc7", + "note": "PR #483: its EXPECTED.json receipt (cited complex b; frontier kappa). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "data/complex/pr483/EXPECTED.json": { + "source_path": "research/tensor-response-r715/EXPECTED.json", + "blob": "f7ff643cd54a334bf46c82989ba155eb6e69adde" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr484.json b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr484.json new file mode 100644 index 0000000000..76292df851 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/SOURCE-pr484.json @@ -0,0 +1,13 @@ +{ + "schema": "source-pins/1", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/484", + "head_repository": "DreamingOfClouds/integer-mult-bounds", + "commit": "035845ce95f31d0a2dcfb42b8c8e13411271fa5f", + "note": "PR #484: its EXPECTED.json receipt (cited complex b). Every file listed has, in this package, the git blob id it has at the commit above (git ls-tree -r -- ).", + "identical": { + "data/complex/pr484/EXPECTED.json": { + "source_path": "research/e8-complex-gauge-kernel/EXPECTED.json", + "blob": "7f93fcbb9f1c2799fd86dd308ec1e6f0ad2a3264" + } + } +} diff --git a/research/r489-pooled-retimed-complex/vendor/bit/code/bit/checkers/columns_h.cpp b/research/r489-pooled-retimed-complex/vendor/bit/code/bit/checkers/columns_h.cpp new file mode 100644 index 0000000000..00c5a3a5d8 --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/code/bit/checkers/columns_h.cpp @@ -0,0 +1,48 @@ +// Generalization (Dylan Crow, with Anthropic Claude assistance): the copied-centre count is the macro NCOPY, defaulting to +// HDIM, so the unmodified PR #346/#352 build (no -DNCOPY) is exactly the original checker. The E8 bit word has 9 +// retained totals at h = 8 (-DNCOPY=9). +#ifndef NCOPY +#define NCOPY HDIM +#endif +#include "json.hpp" +#include +#include +using boost::multiprecision::cpp_int; +#include +#include +#include +#include +#include +#include +#include +using J=nlohmann::json; +struct E{int kind,dst,src,c;}; +void need(bool x,const char*s){if(!x)throw std::runtime_error(s);} +int main(int argc,char**argv){try{ +need(argc==3,"usage RAW6_RECORDS OUTPUT");std::string pre=argv[1];int v=VPORTS,r=RHELP,loc=2*v+r,global=4*v+r,temp=global; +struct Raw{int op,a,b,c,f,z;};std::ifstream f(pre,std::ios::binary|std::ios::ate);size_t sz=f.tellg();need(sz%sizeof(Raw)==0,"stream alignment");std::vectorp(sz/sizeof(Raw));f.seekg(0);f.read((char*)p.data(),sz);std::vectore;std::mapH;for(auto q:p){if(q.op==0){if(q.f)H[q.f]++;}else if(q.op==1)e.push_back({0,q.a,q.b,q.c});else if(q.op==2){H[q.z]++;e.push_back({1,loc,q.a,0});}else if(q.op==3)e.push_back({2,loc,q.a,0});else need(false,"opcode");} +J prefix=J::array();cpp_int largestF=0,largestB=0;for(int rev=0;rev<2;rev++){std::vectornorms(loc+1,1);cpp_int maxrow=1;bool isopen=false;for(size_t z=0;zmaxrow)maxrow=norms[q.dst];}else if(k==1){need(!isopen,"boundcopy");norms[loc]=norms[q.src];isopen=true;}else {need(isopen,"bounderase");norms[loc]=0;isopen=false;}}need(!isopen,"prefix copy closure");if(rev)largestB=maxrow;else largestF=maxrow;prefix.push_back({{"reverse",bool(rev)},{"cancellation_free_signed_row_l1_upper",maxrow.convert_to()},{"bits",boost::multiprecision::msb(maxrow)+1}});} +cpp_int payload=64*largestF*largestF*largestF*largestB*largestB;need(payload<(cpp_int(1)<<104),"payloadfiniteprefix2^104"); +long long copies=0,adds=0,odd=0;bool open=false;int center=-1;long long reverseCopies=0; +for(auto q:e){need(q.kind>=0&&q.kind<=2,"kind");need(q.dst>=0&&q.dst<=loc,"local dst");if(q.kind==0){need(q.src>=0&&q.src<=loc&&q.dst!=q.src,"source distinct");need(q.dst!=loc,"copy immutable");need(q.src!=loc||open,"temp not open");if(open)need(q.dst!=center,"source changes inside copied-center block");adds++;odd+=q.c&1;} +else if(q.kind==1){need(!open&&q.dst==loc&&q.src>=0&&q.srca((size_t)(global+1)*words);auto row=[&](int i){return a.data()+(size_t)i*words;};for(int i=0;i=v&&i<2*v&&w==(size_t)(i-v)/64)want^=1ull<<((i-v)%64);need(x[w]==want,"local defining-decoder full formal column");}}} +if(stage==1||stage==2||stage==4){int b=stage==1?0:stage==2?1:2;for(auto q:bridges[b])for(int i=0;i(std::chrono::steady_clock::now()-t0).count()<<"s\n";} +for(int bank=0;bank<4;bank+=2)for(int i=0;i()},{"payload_prefix_bits",boost::multiprecision::msb(payload)+1},{"new_Q_categories",{28,29}},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])< +#include +using boost::multiprecision::cpp_int; +#include +#include +#include +#include +#include +#include +#include +using J=nlohmann::json; +struct E{int kind,dst,src,c;}; +void need(bool x,const char*s){if(!x)throw std::runtime_error(s);} +int main(int argc,char**argv){try{ +need(argc==3,"usage RAW6_RECORDS OUTPUT");std::string pre=argv[1];int v=VPORTS,r=RHELP,loc=2*v+r,global=2*KPAIRS*v+r,temp=global;const int S=2*KPAIRS+1; +struct Raw{int op,a,b,c,f,z;};std::ifstream f(pre,std::ios::binary|std::ios::ate);size_t sz=f.tellg();need(sz%sizeof(Raw)==0,"stream alignment");std::vectorp(sz/sizeof(Raw));f.seekg(0);f.read((char*)p.data(),sz);std::vectore;std::mapH;for(auto q:p){if(q.op==0){if(q.f)H[q.f]++;}else if(q.op==1)e.push_back({0,q.a,q.b,q.c});else if(q.op==2){H[q.z]++;e.push_back({1,loc,q.a,0});}else if(q.op==3)e.push_back({2,loc,q.a,0});else need(false,"opcode");} +J prefix=J::array();cpp_int largestF=0,largestB=0;for(int rev=0;rev<2;rev++){std::vectornorms(loc+1,1);cpp_int maxrow=1;bool isopen=false;for(size_t z=0;zmaxrow)maxrow=norms[q.dst];}else if(k==1){need(!isopen,"boundcopy");norms[loc]=norms[q.src];isopen=true;}else {need(isopen,"bounderase");norms[loc]=0;isopen=false;}}need(!isopen,"prefix copy closure");if(rev)largestB=maxrow;else largestF=maxrow;prefix.push_back({{"reverse",bool(rev)},{"cancellation_free_signed_row_l1_upper",maxrow.convert_to()},{"bits",boost::multiprecision::msb(maxrow)+1}});} +cpp_int payload=64*largestF*largestF*largestF*largestB*largestB;need(payload<(cpp_int(1)<<104),"payloadfiniteprefix2^104"); +long long copies=0,adds=0,odd=0;bool open=false;int center=-1;long long reverseCopies=0; +for(auto q:e){need(q.kind>=0&&q.kind<=2,"kind");need(q.dst>=0&&q.dst<=loc,"local dst");if(q.kind==0){need(q.src>=0&&q.src<=loc&&q.dst!=q.src,"source distinct");need(q.dst!=loc,"copy immutable");need(q.src!=loc||open,"temp not open");if(open)need(q.dst!=center,"source changes inside copied-center block");adds++;odd+=q.c&1;} +else if(q.kind==1){need(!open&&q.dst==loc&&q.src>=0&&q.src>active;std::vectorbackward;std::vector>>after(S); +auto X=[](int p){return 2*(p-1);};auto Y=[](int p){return 2*(p-1)+1;}; +for(int t=0;t=3&&t%2==1);backward.push_back(b);active.push_back(b?std::array{Y(p),X(p)}:std::array{X(p),Y(p)});} +for(int q=2;q<=KPAIRS;q++){after[2*q-3].push_back({X(q-1),X(q),1});after[2*q-3].push_back({Y(q),Y(q-1),-1}); + after[2*q-2].push_back({Y(q),Y(q-1),1});after[2*q-2].push_back({X(q-1),X(q),-1});} +for(int p=KPAIRS;p>=2;p--){after[S-1].push_back({Y(p-1),Y(p),-1});after[S-1].push_back({X(p),X(p-1),1});} +int nbridges=0;for(auto&a:after)nbridges+=a.size();need(nbridges==6*(KPAIRS-1),"twin bridge count"); +size_t words=(global+63)/64;std::vectora((size_t)(global+1)*words);auto row=[&](int i){return a.data()+(size_t)i*words;};for(int i=0;i=v&&i<2*v&&w==(size_t)(i-v)/64)want^=1ull<<((i-v)%64);need(x[w]==want,"local defining-decoder full formal column");}}} +for(auto q:after[stage])for(int i=0;i(std::chrono::steady_clock::now()-t0).count()<<"s\n";} +for(int bank=0;bank<2*KPAIRS;bank+=2)for(int i=0;ib(2*KPAIRS);for(int z=0;z<2*KPAIRS;z++)b[z]=1u<()},{"payload_prefix_bits",boost::multiprecision::msb(payload)+1},{"new_Q_categories",{28,29}},{"local_raw_H",H},{"negative_controls",controls},{"seconds",std::chrono::duration(std::chrono::steady_clock::now()-t0).count()}};std::ofstream(argv[2])</2 in Construction-A (Hamming) coordinates, integer Gram 2 B G B^t = B B^t +Checks per frame: rank(B) = dim, A.B = 0 and |A| + dim = h (when A given), det(integer Gram) != 0 (exact Bareiss), and +the prime witness: |det| = residual * prod p^e over PR #315's allowed primes with 0 < residual < 2^80. With --new BASE +only frames absent from BASE are checked (prime_new.py's scope); otherwise every frame. +usage: python3 gram_frames.py WORDDIR --gram {triple9,e8ham} --h H [--new BASEDIR] [--positive]""" +import json, sys, argparse, importlib.util, os, collections +ap=argparse.ArgumentParser(); ap.add_argument('word'); ap.add_argument('--gram',required=True); ap.add_argument('--h',type=int,required=True) +ap.add_argument('--new'); ap.add_argument('--positive',action='store_true'); a=ap.parse_args() +HERE=os.path.dirname(os.path.abspath(__file__)) +s=importlib.util.spec_from_file_location('pw',os.path.join(HERE,'..','..','pricing','prime_witnesses.py')); pw=importlib.util.module_from_spec(s); s.loader.exec_module(pw) +def validate_record(row, dimension, determinant, allowed_primes): # PR #315 prime_check.validate_record, verbatim logic + assert type(row['dimension']) is int and type(row['determinant']) is int and type(row['residual']) is int, 'exact integer witness fields' + assert row['dimension'] == dimension and row['determinant'] == determinant != 0, 'exact determinant mismatch or singular basis' + assert 0 < row['residual'] < 2**80, 'retained prime lower bound' + product = row['residual'] + for prime, exponent in row['factors'].items(): + q = int(prime); assert q in allowed_primes and type(exponent) is int and exponent > 0, 'factor shape'; product *= q**exponent + assert product == abs(determinant), 'factor identity' +def gram(B): + if a.gram=='triple9': + s_=list(map(sum,B)); return [[9*sum(x*y for x,y in zip(B[i],B[j]))-s_[i]*s_[j] for j in range(len(B))] for i in range(len(B))] + if a.gram=='e8ham': + return [[sum(x*y for x,y in zip(B[i],B[j])) for j in range(len(B))] for i in range(len(B))] + raise SystemExit('unknown gram') +def rank_int(B): + M=[r[:] for r in B]; r=0 + for c in range(len(M[0]) if M else 0): + p=next((i for i in range(r,len(M)) if M[i][c]!=0),None) + if p is None: continue + M[r],M[p]=M[p],M[r] + for i in range(len(M)): + if i!=r and M[i][c]!=0: x,y=M[r][c],M[i][c]; M[i]=[u*x-w*y for u,w in zip(M[i],M[r])] + r+=1 + return r +fr=json.load(open(a.word+'/frames.json'))['frames'] +old=json.load(open(a.new+'/frames.json'))['frames'] if a.new else {} +keys=[k for k in fr if k not in old] +stats=collections.Counter(); primes=set(); bits=0; nonpos=0 +for k in keys: + B=fr[k]['B']; A=fr[k].get('A',[]); d=len(B); assert fr[k]['dim']==d + assert d==0 or rank_int(B)==d,('basis rank',k) + if A: assert all(sum(x*y for x,y in zip(r,b))==0 for r in A for b in B) and len(A)+d==a.h,('annihilator',k) + M=gram(B) if d else []; det=pw.det(M); assert det!=0,('degenerate frame',k) + if a.positive: # positive-definite ambient form: every leading principal minor positive + for j in range(1,d+1): + if pw.det([r[:j] for r in M[:j]])<=0: nonpos+=1; break + powers,residual=pw.factor_witness(det); row=dict(dimension=d,determinant=det,residual=residual,factors={p:e for p,e in powers.items() if e}) + validate_record(row,d,det,pw.PRIMES); primes.update(map(int,row['factors'])); bits=max(bits,abs(det).bit_length()); stats[d]+=1 +assert nonpos==0 +print('PASS %s Gram: %d frames checked, all nondegenerate%s; prime witnesses valid; max determinant bits %d; primes %s; by dim %s'%( + a.gram,sum(stats.values()),' and positive definite' if a.positive else '',bits,sorted(primes),dict(sorted(stats.items())))) diff --git a/research/r489-pooled-retimed-complex/vendor/bit/code/bit/checkers/json.hpp b/research/r489-pooled-retimed-complex/vendor/bit/code/bit/checkers/json.hpp new file mode 100644 index 0000000000..82d69f7c5d --- /dev/null +++ b/research/r489-pooled-retimed-complex/vendor/bit/code/bit/checkers/json.hpp @@ -0,0 +1,25526 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_DIAGNOSTIC_POSITIONS + #define JSON_DIAGNOSTIC_POSITIONS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_DIAGNOSTIC_POSITIONS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#ifdef JSON_HAS_CPP_17 + #include // optional +#endif +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L) + #define JSON_HAS_CPP_23 + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1; + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows calling any std function as if (e.g., with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // char_traits +#include // tuple +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& +is_complete_type < +detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template