From 62a6d87141b01e93581bac3985f2f8702e14d081 Mon Sep 17 00:00:00 2001 From: George Lydakis Date: Sat, 10 Oct 2026 00:17:04 -0400 Subject: [PATCH 01/25] Retime PR271 target restores at the zero frame --- .../workflows/zero-frame-target-restores.yml | 48 +++ research/zero-frame-target-restores/AUDIT.md | 43 +++ .../zero-frame-target-restores/MANIFEST.json | 19 + research/zero-frame-target-restores/NOTICE.md | 11 + research/zero-frame-target-restores/PROOF.md | 13 + research/zero-frame-target-restores/README.md | 37 ++ .../zero-frame-target-restores/SOURCE.json | 37 ++ .../code/independent_word_audit.py | 109 ++++++ .../code/plateau_retiming.py | 63 +++ .../code/verify_cleanup_endpoints.py | 22 ++ .../code/verify_frames.py | 48 +++ .../code/verify_plateau_spans.py | 42 ++ .../code/verify_target_roles.py | 21 + .../zero-frame-target-restores/evidence.json | 197 ++++++++++ .../zero-frame-target-restores/expected.json | 13 + .../zero-frame-target-restores/selection.json | 360 ++++++++++++++++++ research/zero-frame-target-restores/verify.py | 53 +++ 17 files changed, 1136 insertions(+) create mode 100644 .github/workflows/zero-frame-target-restores.yml create mode 100644 research/zero-frame-target-restores/AUDIT.md create mode 100644 research/zero-frame-target-restores/MANIFEST.json create mode 100644 research/zero-frame-target-restores/NOTICE.md create mode 100644 research/zero-frame-target-restores/PROOF.md create mode 100644 research/zero-frame-target-restores/README.md create mode 100644 research/zero-frame-target-restores/SOURCE.json create mode 100644 research/zero-frame-target-restores/code/independent_word_audit.py create mode 100644 research/zero-frame-target-restores/code/plateau_retiming.py create mode 100644 research/zero-frame-target-restores/code/verify_cleanup_endpoints.py create mode 100644 research/zero-frame-target-restores/code/verify_frames.py create mode 100644 research/zero-frame-target-restores/code/verify_plateau_spans.py create mode 100644 research/zero-frame-target-restores/code/verify_target_roles.py create mode 100644 research/zero-frame-target-restores/evidence.json create mode 100644 research/zero-frame-target-restores/expected.json create mode 100644 research/zero-frame-target-restores/selection.json create mode 100644 research/zero-frame-target-restores/verify.py diff --git a/.github/workflows/zero-frame-target-restores.yml b/.github/workflows/zero-frame-target-restores.yml new file mode 100644 index 0000000000..76bee3aebc --- /dev/null +++ b/.github/workflows/zero-frame-target-restores.yml @@ -0,0 +1,48 @@ +name: Verify zero-frame target restores +on: + push: + paths: + - 'research/zero-frame-target-restores/**' + - '.github/workflows/zero-frame-target-restores.yml' + pull_request: + paths: + - 'research/zero-frame-target-restores/**' + - '.github/workflows/zero-frame-target-restores.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - name: Obtain immutable PR272 baseline + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: CrocSwap/integer-mult-bounds + ref: 4d23d0ee5682c99b792614bae4bc5330da19ff13 + path: build/pinned-pr272 + persist-credentials: false + - name: Obtain immutable PR271 cleanup package + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: evmckinney9/integer-mult-bounds + ref: ebc1defe8c13f39f86e5901c3437c1be52886a2b + path: build/pinned-pr271 + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Use predecessor dependencies + run: python -m pip install -r build/pinned-pr272/research/filtered-kernel-target120/requirements.txt + - name: Fresh baseline, target restores and complete exact checks + run: python -B research/zero-frame-target-restores/verify.py --base build/pinned-pr272/research/filtered-kernel-target120 --cleanup-base build/pinned-pr271/research/cleanup-sandwich-272 --output /tmp/zero-frame-restores-replay + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/research/zero-frame-target-restores/AUDIT.md b/research/zero-frame-target-restores/AUDIT.md new file mode 100644 index 0000000000..900dd3090c --- /dev/null +++ b/research/zero-frame-target-restores/AUDIT.md @@ -0,0 +1,43 @@ +# Independent finite-composition audit + +Prepared in a separate reviewer context with OpenAI Codex assistance. This review covers the pinned PR272 baseline, PR271 cleanup composition, frozen target restore selection, verification wrapper, cost objective and artifact bindings. It does not independently prove inherited all-size multiplication interfaces. + +## Result and exact comparison + +The composed endpoint is exactly `8921126351038225858611 / 12500000000000000000000000`, or **0.00071369010808305806868888**. Against reproduced PR271 at `ebc1defe8c13f39f86e5901c3437c1be52886a2b`, whose exact endpoint is `713662156389609974540991 / 10^27`, the gain is exactly `27951693448094147889 / 10^27`, approximately **0.00391665625%** relative. + +The objective is the conditional exponent saving in the retained bound `O(n(log n)^(1-kappa))`. This is not measured multiplication performance, global optimality or a proof of removing the logarithmic factor. The comparison is against pinned, replayed prerequisites; competing proposals should be refreshed before any broader current-best statement. + +## Compatible modifications + +PR271's cleanup rewrite shortens 99 helper endpoints and retiles their residual banks. The additional modification changes 27 pure target restoration ADD frames in three disjoint nine-gate blocks. Those target roles intersect neither the 99 helpers nor their cleanup sources or targets. All three scalar restore blocks survived uniquely in the cleanup output. Their actual selection is rebound and frozen against the cleanup word hash, rather than blindly applying predecessor event ordinals. + +All selected ADDs are category 31, with distinct target operands and no source, helper, COPY temporary or source-owned alias. Existing frame 148238 is the exact zero subspace: dimension 0, empty basis and identity annihilator. The retained target contract requires chronological nesting and covectors annihilating the frame basis; every target cap contains this zero subspace. Pure target ADDs at a common legal frame preserve the predecessor's transformed-row invariant and scalar identity for arbitrary dirt. The non-target source-span inclusion count 0 is appropriate and must not be described as 27 nontrivial inclusions. + +Rebuilding the target paths changes the local histogram by `{1:-12,20:-12,21:+12}`, preserving the cleanup word's rank mass and eliminating 12 additional recursive children. No scalar instruction, coefficient, category or COPY event changes relative to cleanup. The replacement is favorable by strict subadditivity of the admitted moment power, but its exact endpoint comes from pricing the complete literal word and invoice. + +The shortened helper final frames and the cleanup bank retiling are retained. Generic predecessor bank checking alone does not establish the new shorter residuals: the wrapper separately rederives their projector endpoints and bank tiling using pinned cleanup code. It also reruns exact charts for every connector involving the new helper frames on the actual final word. The completed exploratory composition checked 396 such connector/endpoint charts and repeated the retiled bank inventory. No target retiming is assumed to repair or replace this obligation. + +## Exact accounting and metadata + +Final local paid calls are 96376 and rank mass 430435. The literal invoice has 59515200 positive children, rank mass 310216200, stock 2589535, selector charge 1882878976800 and primitive coefficient 188250481662339001. All 47 strict constraints and seven margins pass at the endpoint. The final physical SHA256 is + +`79bd21c92ce4385da640f4e86cf310d3c0d868281e778d5b76acd20c0dd18e31`. + +The actual 925 kernel pivots have entrance rank 1762. Cleanup reduces normalized stock by 1980 through shorter helper endpoints, not additional kernel pivots. The predecessor price interface consumes an effective `new_entrance_rank=3742` solely to reproduce that stock. The composed summary distinguishes `actual_kernel_entrance_rank=1762` and `pricing_stock_adjustment=1980` and corrects `new_rank_mass` to the actual 430435. Effective pricing metadata must not be reported as a geometrical entrance rank. Final invoice and independent census bind price to literal bank stock and actual records. + +## Fresh reproduction and artifact bindings + +The wrapper pins the PR272 manifest and every listed PR271 cleanup source file. It first freshly regenerates PR272's upstream source, compiles all nine native checkers and reproduces its expected receipts. It then runs the pinned cleanup verifier against that newly completed replay, requiring its exact PR271 endpoint. Thus its reuse option does not substitute an unrelated stale replay for baseline regeneration. + +The target selection binds the cleanup output hash and non-MOVE gate ordinals. The rewrite checks actual old frames, disjoint roles, nested MOVEs, unchanged endpoint frames, identical scalar/COPY projection, unchanged actual rank mass and exact histogram delta. Target classification binds the new output hash and zero-frame identity. Independent chronological and full-column checks consume the new records using cleanup's mutated final-frame export. + +The generic bank recount must agree with the cleanup generic receipt. The shortened-endpoint audit requires unchanged initial frames and full frame table, rederives the cleanup residual inventory and 1980 banks saved per stage, and constructs connector charts from final records. It replaces the generic bank receipt with the corrected retiled receipt before finite invoicing. Fresh five-stage columns, coarse price, literal invoice, fixed-prime price and independent bitset/census then operate on the composed artifacts. + +The independently authored standard-library bitset audit checks all 20107 local formal columns forward and inverse, 24 COPY/ERASE pairs, literal histogram, selectors and primitive coefficient, 47 inequalities and seven margins. Exact expected endpoint, final hash, delta, calls, mass, blocks and gate count are compared after execution. Own-package hashes are checked before and after execution. Stored exploratory receipts do not replace fresh verifier success. + +## Independence and retained scope + +Native checks share predecessor provenance; they cover separate obligations but are not independently developed theorem provers. The shortened-endpoint verifier reuses pinned PR271 geometry code and cannot be counted as an independent second implementation of that theorem. Two rational moment engines provide arithmetic diversity, and separately authored bitsets/census provide independent scalar and counting checks. This reviewer inspected the code seams, classification, comparison and evidence; the review does not reimplement all geometry or interval mathematics. + +Kernel and scalar endpoint identities remain over F2. Signed integer coefficients and geometry have distinct inverse/address/cost roles. Uniform compiler, weighted/common charts, restored rows, routing, prime supply, precision/recovery, complex correctness and analytic transfer remain hypotheses. This is a reproducible conditional finite composition over the pinned comparators, without a claim of unconditional multiplication correctness, formal Lean certification, practical speedup or exclusive novelty of inherited mechanisms. diff --git a/research/zero-frame-target-restores/MANIFEST.json b/research/zero-frame-target-restores/MANIFEST.json new file mode 100644 index 0000000000..506efd5259 --- /dev/null +++ b/research/zero-frame-target-restores/MANIFEST.json @@ -0,0 +1,19 @@ +{ + "files": { + "AUDIT.md": "37a09e541223a42f6074fa0e93597540948948152ca2461eaf18af02fff6f4f2", + "NOTICE.md": "9d34fb0d130848f7e74d3757c27bf75924d789efaea7a82d6ebdf9c0ef9a2f2c", + "PROOF.md": "4fc9a313ceecb07cca33c89cb1c8f78e09f9f393c762d15901b3c89616c9ced9", + "README.md": "bc52d492101293f6c3c64381a72d29632bd7ecb9cdbb03c51739bfce929dd707", + "SOURCE.json": "2e5fd6b4a81f76299b3940825786798b030ebe201f1c50ea1242562e5740ebe3", + "code/independent_word_audit.py": "4b69c6b2db0ad8e088b19cd920ace19657bb622be455280acb5974de18fd0084", + "code/plateau_retiming.py": "d1e9f13543765d74908f7294fbcad779030a5c21504104f203b90acd14cad702", + "code/verify_cleanup_endpoints.py": "f970e52bdf4e25b2426e2832cdf8cbf459f4c763c6cb4a90ef6a5aa42feaa19f", + "code/verify_frames.py": "aea01c7275088611c18ae110a2b4abf7b52f8cc8f70c5932a25588ddec4acd19", + "code/verify_plateau_spans.py": "594f1ababb4efc9e597154970ea51f6b850774f4b55f8cf386dbf1eb7fc5322b", + "code/verify_target_roles.py": "88fbafd867d032bc427a8cb44c93b5dd04ef0a552d4432b48c331f864aa991fe", + "evidence.json": "cd18f566676a7bcf5f83a0446e70b9c3207c5f25941e6318b62673399573aa86", + "expected.json": "67e5371caab3a3623bc762be148bb8b108a8532eef4cc46f256ea199fad6a9e3", + "selection.json": "03ee34d1e293ce97a09c2765ae508dca4dd57e18c4c768889448a090e1e5c501", + "verify.py": "4f34d4a9c6169442b9e5f298563473366576798a8d43556ea39c9ba58f7cd3ae" + } +} diff --git a/research/zero-frame-target-restores/NOTICE.md b/research/zero-frame-target-restores/NOTICE.md new file mode 100644 index 0000000000..58c6e465fc --- /dev/null +++ b/research/zero-frame-target-restores/NOTICE.md @@ -0,0 +1,11 @@ +# Attribution and licenses + +Prepared by George Lydakis (@lydakis) with substantial OpenAI Codex assistance in inspection, discovery, independent reviewer context, exact replay and packaging. New work is contributed under the repository's Apache-2.0 license. Existing material retains its original licenses and attribution; credit does not imply endorsement. + +This package builds directly on Dugongue's PR272/PR186 at `4d23d0ee5682c99b792614bae4bc5330da19ff13`: frame-filtered kernels, chronological donor sharing, 120-replica banks and native acceptance code. Its source and NOTICE preserve the PR249, PR259, chafreaky PR266, eumemic PR268 target-prefix sharing, Rohan Arun PR263 retiming with Anthropic Claude disclosure, sennemmi PR261 and PR265 arithmetic, and credited PR235/PR252 lineage. No predecessor file is edited or copied into this additive package. + +The connected-block discovery method and retiming/source-span scripts are adapted from utcorvusvolat-dotcom's PR270 at `9b48fd73531eaf09ebbbd5acb0f7a3eb338d9a2a`, which disclosed substantial OpenAI Codex assistance. Its exact frame validator and source-span validator are retained. The retiming adapter makes metadata copies optional and checks the exact expected call delta, replacing its original zero-call-delta restriction. All original nesting, projection, histogram, rank and unique-gate checks remain. Unchanged native checks then establish acceptance; this adaptation is not itself a certificate. + +The contribution is the concrete zero-frame target restoration selection on the PR271/PR272 composed witness, its explanation and complete exact invoice. It is not a priority claim for connected-block retiming, target-prefix compression or the inherited component relations. The independent Python bitset/census implementation and explicit target-role/cap audit are newly authored verification support. `SOURCE.json` pins the upstream script inputs, baseline and selected data; replay needs no discovery scan. + +PR271 by evmckinney9 at `ebc1defe8c13f39f86e5901c3437c1be52886a2b` supplies the 99-helper cleanup identity, exact shortened endpoint charts and bank re-tiling. It disclosed OpenAI Codex (GPT-6 Astra) discovery assistance and Anthropic Claude replay/packaging assistance. Its pinned package remains external and unchanged; our contribution composes the disjoint target retiming with that exact witness. diff --git a/research/zero-frame-target-restores/PROOF.md b/research/zero-frame-target-restores/PROOF.md new file mode 100644 index 0000000000..46ffe0ef7a --- /dev/null +++ b/research/zero-frame-target-restores/PROOF.md @@ -0,0 +1,13 @@ +# Finite dependency argument + +Freshly reproduce PR272, then run pinned PR271’s verifier to obtain its cleanup final word, SHA256 `0c4d8262996622a8e36b3c0db1e712d868e7c35d13d7848508176efaa3754473`. Its original kernel, target-prefix dependency and 25 gate-retiming checks establish the inherited baseline prerequisites. The frozen selection addresses non-MOVE event ordinals in precisely this word; mismatched inputs are rejected. The three blocks survive uniquely in PR271 and share no operands with the 99 shortened helpers or their cleanup sources/targets. + +Three disjoint connected blocks contain nine restoration ADDs each, all category31, with operands exclusively in the target-register range. Neither operand is a source, helper, COPY temporary or aliased destination. Their original common frames are rank20. The chosen existing frame148238 is the exact zero subspace, with empty basis and identity annihilator. In the retained target-role contract, target covectors must annihilate the chosen frame basis. Every such cap contains the zero frame. No non-target defining-source-span obligation is silently dropped: the changed gates have no non-target operands, which the explicit target audit checks. Full chronological paths and actual endpoint frames are independently checked afterward. + +Change only these ADD frame annotations, then reconstruct all MOVE paths from the actual operand requirements. Each block has eight target roles. Four next need rank20 and four next need rank21. The former four rank20 moves stay; the latter four rank20+rank1 paths become direct rank21 moves. Thus each block has exact delta {20:-4,1:-4,21:+4}; the combined delta is {20:-12,1:-12,21:+12}. It preserves rank mass and removes twelve recursive children. No scalar instruction, sign, category, COPY/ERASE event or endpoint is removed. The complete ordered scalar/COPY projection hash is preserved, while fresh independent formal-column checks verify all arbitrary dirty inputs in both directions. The final physical SHA256 is `79bd21c92ce4385da640f4e86cf310d3c0d868281e778d5b76acd20c0dd18e31`. + +No new basis, chart or bank endpoint is introduced. The unchanged generic bank checker recounts all charts. Its inventory is then re-tiled by pinned PR271’s exact endpoint routine; every shortened endpoint and connector chart is rerun on the final word, and equality with PR271’s corrected numerical bank inventory is required. Only the human-readable label may differ. All scalar, selector, routing, recovery and other finite costs are recomputed in the literal invoice. At any moment exponent 0 0 + H[f] += 1 + elif op == 1: + adds += 1 + units += abs(c) + elif op == 2: + H[z] += 1 + copies += 1 +literal = Counter({r: 600*count for r, count in H.items()}) +for r in (4, 23, 46, 50): + literal[r] += 120*2*v +calls = sum(literal.values()) +mass = sum(r*count for r, count in literal.items()) +invoice = json.loads((OUT / 'temporal/COHORT-FINITE-INVOICE.json').read_text()) +bank_path = OUT / 'compiler/BANK-REVIEW.json' +if not bank_path.exists(): bank_path = OUT / 'compiler/COHORT-BANK-REVIEW.json' +bank = json.loads(bank_path.read_text()) +price = json.loads((LEAD / 'FIXED-PRICE.json').read_text()) +stock = invoice['literal_stock'] +assert copies == 24 and max(literal) < 60 +assert stock == bank['literal_stock'] == 5*invoice['normalized_stock'] +assert 120*stock-mass == 528000 +assert {str(r): str(count) for r, count in literal.items()} == invoice['literal_histogram'] +assert calls == int(invoice['positive_rank_children']) and mass == int(invoice['literal_rank_mass']) +weighted = replicas*(5*adds+6*v) +unit = replicas*(5*units+6*v) +routes = replicas*(24*v+10*R) +normalizer = max(548, int(bank['max_new_chart_factors'])) + 239 +assert normalizer == int(invoice['normalizer_factor_bound']) +selectors = 10*replicas*((stock-1)+R*120*normalizer) +coefficient = (unit+routes*16*14401*14401+routes*(stock+24) + +calls*(8*120*120+8)+calls*(128*240**3) + +16*120**3+120*replicas+calls+selectors+1) +for name, count in [('global_weighted_additions', weighted), + ('global_unit_expanded_additions', unit), ('route_families', routes), + ('extra_selector_calls', selectors), ('full_counted_primitive_coefficient', coefficient)]: + assert count == int(invoice[name]), name +assert coefficient == int(price['finite_coefficient_recomputed']) and coefficient < 2**80 +assert len(price['strict_constraints']) == 47 +assert all(Fraction(value) > 0 for value in price['strict_constraints'].values()) +assert all(Fraction(value) > Fraction(price['kappa']) for value in price['seven_margins'].values()) +result = {'status': 'PASS_INDEPENDENT_PYTHON_BITSET_COLUMNS_AND_LITERAL_CENSUS', + 'word_sha256': hashlib.sha256(data).hexdigest(), 'columns': columns, + 'raw_rank_mass': sum(r*count for r, count in H.items()), 'raw_additions': adds, + 'literal_calls': calls, 'literal_rank_mass': mass, 'literal_stock': stock, + 'selector_calls': selectors, 'coefficient': coefficient, + 'strict_positive_constraints': 47, 'positive_margin_above_kappa': 7, + 'elapsed_seconds': time.monotonic()-START, + 'limitations': 'Does not independently prove frame geometry, chart compiler, recurrence enclosures, inherited constants or all-size interfaces.'} +(OUT / 'independent-word-audit.json').write_text(json.dumps(result, indent=2)+'\n') +print(json.dumps(result, indent=2)) diff --git a/research/zero-frame-target-restores/code/plateau_retiming.py b/research/zero-frame-target-restores/code/plateau_retiming.py new file mode 100644 index 0000000000..e0f7efb47e --- /dev/null +++ b/research/zero-frame-target-restores/code/plateau_retiming.py @@ -0,0 +1,63 @@ +"""Local PR270 retiming adapter: optional metadata copies and exact expected call delta replace the predecessor zero-call-delta restriction. All geometry/projection/rank/delta assertions retained; native and source-span checks required.""" +#!/usr/bin/env python3 +import argparse,json,hashlib,shutil,sys +from pathlib import Path +from array import array +from collections import Counter +if not __debug__:raise SystemExit('assertions are required') +assert sys.byteorder=='little' and array('i').itemsize==4 +ap=argparse.ArgumentParser();ap.add_argument('export',type=Path);ap.add_argument('lead',type=Path);ap.add_argument('scan',type=Path);ap.add_argument('output',type=Path);args=ap.parse_args() +X,L,O=args.export,args.lead,args.output;O.mkdir() +for name in ('COHORT249-INITIAL.json','COHORT249-SELECTION.json','descent-selection.json', + 'DESCENT-RETIMING.json','DESCENT-REBIND-EVIDENCE.json'): + if (L/name).exists():shutil.copy2(L/name,O/name) +fs={int(k):v for k,v in json.loads((X/'frames.json').read_text())['frames'].items()};new={int(k):v for k,v in json.loads((L/'COHORT249-FRAMES.json').read_text()).items()};fs.update(new) +scan=json.loads(args.scan.read_text());added={int(k):v for k,v in scan.get('newframes',{}).items()} +assert not set(added)&set(fs),'plateau frame ID collision' +from verify_frames import validate +for frame in added.values():validate(frame) +fs.update(added) +chosen=[];roles=set();mutations={};expected=Counter() +for c in scan['candidates']: + assert not set(c['roles'])&roles,'frozen plateau roles overlap' + chosen.append(c);roles.update(c['roles']);expected.update({int(k):v for k,v in c['delta'].items()}) + for g in c['gates']:assert g not in mutations;mutations[g]=(c['old_frame'],c['new_frame']) + if str(c['new_frame']) in scan.get('newframes',{}):new[c['new_frame']]=fs[c['new_frame']] +print('selected',len(chosen),'gates',len(mutations),'entropy_gain',sum(c['entropy_gain'] for c in chosen),'delta',dict(expected),flush=True) +raw=array('i');raw.frombytes((L/'COHORT249-RECORDS.bin').read_bytes());events=[tuple(raw[k:k+6]) for k in range(0,len(raw),6) if raw[k]] +assert len(raw)%6==0 +assert hashlib.sha256(raw.tobytes()).hexdigest()==scan['input_sha256'],'frozen plateau input mismatch' +st=json.loads((X/'249-states.json').read_text());n=st['n'];initial={int(k):v for k,v in json.loads((L/'COHORT249-INITIAL.json').read_text()).items()};final={int(k):v for k,v in st['final'].items()};state=dict(initial);out=array('i');cache={};hist=Counter();copy=None +def sub(a,b): + if a==b:return True + if (a,b) not in cache:cache[a,b]=fs[a]['dim']<=fs[b]['dim'] and all(sum(x*y for x,y in zip(u,v))==0 for u in fs[a]['B'] for v in fs[b]['A']) + return cache[a,b] +def move(s,f): + p=state[s] + if p==f:return + assert sub(p,f),(s,p,f) + r=fs[f]['dim']-fs[p]['dim'];out.extend((0,s,p,f,r,0));state[s]=f + if r:hist[r]+=1 +for i,(op,a,b,c,f,z) in enumerate(events): + if op==1: + if i in mutations: + old,fnew=mutations[i];assert old==f;f=fnew + move(a,f);move(b,f);out.extend((op,a,b,c,f,z)) + elif op==2: + assert copy is None and b==n;move(a,c);state[b]=f;copy=(a,b,c,f);hist[z]+=1;out.extend((op,a,b,c,f,z)) + else: + assert op==3 and copy==(a,b,c,f) and state[a]==c and state[b]==f;del state[b];copy=None;out.extend((op,a,b,c,f,z)) +for s in sorted(final):move(s,final[s]) +assert copy is None and state==final +def projection(a):return hashlib.sha256(b''.join(a[k:k+4].tobytes()+a[k+5:k+6].tobytes() for k in range(0,len(a),6) if a[k])).hexdigest() +assert projection(raw)==projection(out) +replay=json.loads((L/'COHORT249-REPLAY.json').read_text());oldH=Counter({int(k):v for k,v in replay['histogram'].items()});delta=Counter(hist);delta.subtract(oldH);delta={k:v for k,v in delta.items() if v};expected={k:v for k,v in expected.items() if v};assert delta==expected,(delta,expected) +assert delta=={int(k):v for k,v in scan['expected_delta'].items() if v} +assert set(mutations)<=set(range(len(events))) and all(events[g][0]==1 for g in mutations) +assert sum(k*v for k,v in hist.items())==sum(k*v for k,v in oldH.items()) +assert sum(hist.values())-sum(oldH.values())==sum(expected.values()) +total=Counter({int(k):v for k,v in replay['delta'].items()});total.update(delta) +replay.update(new_rank_mass=sum(k*v for k,v in hist.items()),actual_kernel_entrance_rank=1762,pricing_stock_adjustment=1980,status='EXPERIMENTAL_CONNECTED_PLATEAU_RETIMING',histogram={str(k):v for k,v in sorted(hist.items())},delta={str(k):v for k,v in sorted(total.items()) if v},plateau_histogram_delta=delta,new_records=len(out)//6) +(O/'COHORT249-REPLAY.json').write_text(json.dumps(replay,indent=2)+'\n');(O/'COHORT249-RECORDS.bin').write_bytes(out.tobytes());(O/'COHORT249-FRAMES.json').write_text(json.dumps(new)+'\n') +receipt=dict(status='FINITE_TRANSCRIPT_REWRITE_CHECKED_NATIVE_CHECKERS_PENDING',selected=chosen,delta=delta,unchanged_scalar_copy_projection=projection(raw),input_sha256=hashlib.sha256(raw.tobytes()).hexdigest(),output_sha256=hashlib.sha256(out.tobytes()).hexdigest(),paid_calls=sum(hist.values()),rank_mass=sum(k*v for k,v in hist.items())) +(O/'PLATEAU-RETIMING.json').write_text(json.dumps(receipt,indent=2)+'\n');print('wrote',O,'calls',sum(hist.values()),flush=True) diff --git a/research/zero-frame-target-restores/code/verify_cleanup_endpoints.py b/research/zero-frame-target-restores/code/verify_cleanup_endpoints.py new file mode 100644 index 0000000000..ef0a2b7041 --- /dev/null +++ b/research/zero-frame-target-restores/code/verify_cleanup_endpoints.py @@ -0,0 +1,22 @@ +"""Recompute the pinned cleanup endpoint charts and inventory on the final word.""" +import importlib.util,json,sys +from pathlib import Path +PRE,D,OUT,CLEAN=map(lambda x:Path(x).resolve(),sys.argv[1:]) +spec=importlib.util.spec_from_file_location('pinned_endpoints',CLEAN/'endpoints272.py');m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m) +def load(p):return json.loads(p.read_text()) +def save(p,x):p.write_text(json.dumps(x,indent=2)+'\n') +receipt=load(D/'CERTIFICATE.json')['receipts']['rewrite'] +assert load(OUT/'lead/COHORT249-INITIAL.json')==load(D/'lead/COHORT249-INITIAL.json') +frames=load(OUT/'lead/COHORT249-FRAMES.json');assert frames==load(D/'lead/COHORT249-FRAMES.json') +new={str(e['frame']):frames[str(e['frame'])] for e in receipt['edits']} +generic=load(OUT/'compiler/BANK-REVIEW.json');prior=load(D/'compiler/BANK-REVIEW.json') +assert {k:v for k,v in generic.items() if k!='label'}=={k:v for k,v in prior.items() if k!='label'} +original=PRE/'temporal/CURRENT249-EXPORT';lead=PRE/'targeted' +bank,br=m.banks(original,lead,new,receipt,generic) +expected=load(D/'compiler/COHORT-BANK-REVIEW.json') +assert {k:v for k,v in bank.items() if k!='label'}=={k:v for k,v in expected.items() if k!='label'} +norm=m.normalizers(original,lead,new,(OUT/'lead/COHORT249-RECORDS.bin').read_bytes(),receipt) +assert br['banks_saved_per_stage']==1980 and norm['max_factors']<=548 +save(OUT/'compiler/GENERIC-BANK-REVIEW.json',generic);save(OUT/'compiler/BANK-REVIEW.json',bank) +save(OUT/'endpoint-composition-audit.json',{'banks':br,'normalizers':norm,'unchanged_helper_endpoints':True}) +print(json.dumps({'banks':br,'normalizers':norm})) diff --git a/research/zero-frame-target-restores/code/verify_frames.py b/research/zero-frame-target-restores/code/verify_frames.py new file mode 100644 index 0000000000..890d9d54f0 --- /dev/null +++ b/research/zero-frame-target-restores/code/verify_frames.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +"""Independently validate exact bases and annihilators of every candidate frame.""" +import argparse +import hashlib +import json +from pathlib import Path +from sympy import Matrix, eye, ones, zeros + +if not __debug__: + raise SystemExit("assertions are required") + + +def validate(frame): + d = frame["dim"] + assert type(d) is int and 0 <= d <= 24 + b, a = frame["B"], frame["A"] + assert len(b) == d and len(a) == 24-d + assert all(len(row) == 24 and all(type(x) is int for x in row) for row in b+a) + B = Matrix(b) if b else zeros(0, 24) + A = Matrix(a) if a else zeros(0, 24) + assert B.rank() == d and A.rank() == 24-d + assert B*A.T == zeros(d, 24-d) + assert (B*(9*eye(24)-ones(24))*B.T).det() != 0 + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("frames", type=Path) + parser.add_argument("output", type=Path) + args = parser.parse_args() + raw = args.frames.read_bytes() + frames = json.loads(raw) + seen = set() + for frame in frames.values(): + key = json.dumps(frame, sort_keys=True) + if key not in seen: + validate(frame) + seen.add(key) + result = dict(status="PASS_EXACT_BASES_ANNIHILATORS_AND_GRAM", + frames_checked=len(frames), distinct_frames_checked=len(seen), + frames_sha256=hashlib.sha256(raw).hexdigest()) + assert not args.output.exists() + args.output.write_text(json.dumps(result, sort_keys=True, indent=2)+"\n") + print(json.dumps(result)) + + +if __name__ == "__main__": + main() diff --git a/research/zero-frame-target-restores/code/verify_plateau_spans.py b/research/zero-frame-target-restores/code/verify_plateau_spans.py new file mode 100644 index 0000000000..49b3566e7a --- /dev/null +++ b/research/zero-frame-target-restores/code/verify_plateau_spans.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""Exact defining-integer source span audit for the frozen changed ADDs.""" +import argparse,json,time,hashlib,sys +from pathlib import Path +from array import array +if not __debug__:raise SystemExit('assertions are required') +assert sys.byteorder=='little' and array('i').itemsize==4 +ap=argparse.ArgumentParser();ap.add_argument('export',type=Path);ap.add_argument('lead',type=Path);ap.add_argument('receipt',type=Path);args=ap.parse_args() +t=time.time();X,L=args.export,args.lead +frames={int(k):r for k,r in json.loads((X/'frames.json').read_text())['frames'].items()};frames.update({int(k):r for k,r in json.loads((L/'COHORT249-FRAMES.json').read_text()).items()}) +st=json.loads((X/'249-states.json').read_text());n,v=st['n'],st['v'];initial={int(k):f for k,f in json.loads((L/'COHORT249-INITIAL.json').read_text()).items()};chi={s:frames[initial[s]]['B'][0] for s in range(v)} +assert all(frames[initial[s]]['dim']==1 for s in range(v)) +receipt=json.loads(args.receipt.read_text());pairs=[(g,c['new_frame']) for c in receipt['selected'] for g in c['gates']];chosen=dict(pairs) +assert len(pairs)==len(chosen),'duplicate selected gates' +columns=[{i:1} if i Date: Sat, 10 Oct 2026 00:21:30 -0400 Subject: [PATCH 02/25] Expose nested exact-replay diagnostics in CI --- .github/workflows/zero-frame-target-restores.yml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.github/workflows/zero-frame-target-restores.yml b/.github/workflows/zero-frame-target-restores.yml index 76bee3aebc..552e4ea44d 100644 --- a/.github/workflows/zero-frame-target-restores.yml +++ b/.github/workflows/zero-frame-target-restores.yml @@ -44,5 +44,14 @@ jobs: run: python -m pip install -r build/pinned-pr272/research/filtered-kernel-target120/requirements.txt - name: Fresh baseline, target restores and complete exact checks run: python -B research/zero-frame-target-restores/verify.py --base build/pinned-pr272/research/filtered-kernel-target120 --cleanup-base build/pinned-pr271/research/cleanup-sandwich-272 --output /tmp/zero-frame-restores-replay + - name: Show nested verifier diagnostics on failure + if: failure() + run: | + python - <<'PYDIAG' + from pathlib import Path + for path in sorted(Path('/tmp/zero-frame-restores-replay').rglob('*.log')): + print('\n---', path, '---') + print('\n'.join(path.read_text(errors='replace').splitlines()[-40:])) + PYDIAG - name: Require unchanged tracked artifacts run: git diff --exit-code From 0fbc0a10bf91bb4494fb78ea32df647b9a5bc13f Mon Sep 17 00:00:00 2001 From: George Lydakis Date: Sat, 10 Oct 2026 00:26:47 -0400 Subject: [PATCH 03/25] Provision declared Boost headers before exact CI replay --- .github/workflows/zero-frame-target-restores.yml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.github/workflows/zero-frame-target-restores.yml b/.github/workflows/zero-frame-target-restores.yml index 552e4ea44d..ed5ab2fc68 100644 --- a/.github/workflows/zero-frame-target-restores.yml +++ b/.github/workflows/zero-frame-target-restores.yml @@ -40,6 +40,13 @@ jobs: - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 with: python-version: ${{ matrix.python-version }} + - name: Prepare declared Boost headers + run: | + if ! test -f /usr/include/boost/multiprecision/cpp_int.hpp; then + sudo apt-get update + sudo apt-get install -y libboost-dev + fi + printf '#include \nint main() { boost::multiprecision::cpp_int n = 1; return n == 1 ? 0 : 1; }\n' | g++ -std=c++17 -x c++ -fsyntax-only - - name: Use predecessor dependencies run: python -m pip install -r build/pinned-pr272/research/filtered-kernel-target120/requirements.txt - name: Fresh baseline, target restores and complete exact checks From c4405c861d9286b1bbe189bab7cfc37220b93177 Mon Sep 17 00:00:00 2001 From: George Lydakis Date: Sat, 10 Oct 2026 01:51:03 -0400 Subject: [PATCH 04/25] Compose twenty extra target pairs on the gen4 frontier --- .gitattributes | 3 + .github/workflows/gen4-extra-target-pairs.yml | 58 +++++++++++ .../gen4-extra-target-pairs/MANIFEST.json | 13 +++ .../gen4-extra-target-pairs/NOTICE-PR281.md | 16 +++ .../gen4-extra-target-pairs/NOTICE-PR283.md | 13 +++ research/gen4-extra-target-pairs/NOTICE.md | 23 +++++ research/gen4-extra-target-pairs/PROOF.md | 80 +++++++++++++++ research/gen4-extra-target-pairs/README.md | 63 ++++++++++++ research/gen4-extra-target-pairs/SOURCE.json | 21 ++++ research/gen4-extra-target-pairs/check.py | 95 ++++++++++++++++++ .../gen4-extra-target-pairs/pairs.json.gz | Bin 0 -> 1107 bytes research/gen4-extra-target-pairs/verify.py | 69 +++++++++++++ 12 files changed, 454 insertions(+) create mode 100644 .github/workflows/gen4-extra-target-pairs.yml create mode 100644 research/gen4-extra-target-pairs/MANIFEST.json create mode 100644 research/gen4-extra-target-pairs/NOTICE-PR281.md create mode 100644 research/gen4-extra-target-pairs/NOTICE-PR283.md create mode 100644 research/gen4-extra-target-pairs/NOTICE.md create mode 100644 research/gen4-extra-target-pairs/PROOF.md create mode 100644 research/gen4-extra-target-pairs/README.md create mode 100644 research/gen4-extra-target-pairs/SOURCE.json create mode 100644 research/gen4-extra-target-pairs/check.py create mode 100644 research/gen4-extra-target-pairs/pairs.json.gz create mode 100644 research/gen4-extra-target-pairs/verify.py diff --git a/.gitattributes b/.gitattributes index 444040ccdb..6cd6ad54bf 100644 --- a/.gitattributes +++ b/.gitattributes @@ -15,3 +15,6 @@ references/partial-gauge/pr97/** whitespace=-blank-at-eof references/three-stage-cover/pr117/** -whitespace # PR186's manifest hashes original bytes, including two CRLF JSON artifacts. research/coordinated-frames-and-entrance-banks/** -text -whitespace + +# The target-pair manifest preserves this pinned upstream notice verbatim. +research/gen4-extra-target-pairs/NOTICE-PR283.md -text whitespace=cr-at-eol diff --git a/.github/workflows/gen4-extra-target-pairs.yml b/.github/workflows/gen4-extra-target-pairs.yml new file mode 100644 index 0000000000..099364a07b --- /dev/null +++ b/.github/workflows/gen4-extra-target-pairs.yml @@ -0,0 +1,58 @@ +name: Verify extra target pairs on gen4 composition +on: + push: + paths: + - 'research/gen4-extra-target-pairs/**' + - '.github/workflows/gen4-extra-target-pairs.yml' + pull_request: + paths: + - 'research/gen4-extra-target-pairs/**' + - '.github/workflows/gen4-extra-target-pairs.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - name: Obtain immutable PR283 prerequisite + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: Dugongue/integer-mult-bounds + ref: 65768f62d4fde0d1fa7fc84f71678522a84aaa6c + path: build/pinned-pr283 + sparse-checkout: research/gen4-composed-endpoints120 + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Prepare declared Boost headers + run: | + if ! test -f /usr/include/boost/multiprecision/cpp_int.hpp; then + sudo apt-get update + sudo apt-get install -y libboost-dev + fi + printf '#include \nint main() { boost::multiprecision::cpp_int n = 1; return n == 1 ? 0 : 1; }\n' | g++ -std=c++17 -x c++ -fsyntax-only - + - name: Install pinned arithmetic dependency + run: python -m pip install -r build/pinned-pr283/research/gen4-composed-endpoints120/requirements.txt + - name: Replay complete prerequisites and composed construction + run: python -B research/gen4-extra-target-pairs/verify.py --base build/pinned-pr283/research/gen4-composed-endpoints120 --output /tmp/gen4-extra-target-pairs + - name: Show bounded diagnostics on failure + if: failure() + run: | + python - <<'PY' + from pathlib import Path + for path in sorted(Path('/tmp/gen4-extra-target-pairs').rglob('*.log')): + print(path) + print('\n'.join(path.read_text(errors='replace').splitlines()[-30:])) + PY + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/research/gen4-extra-target-pairs/MANIFEST.json b/research/gen4-extra-target-pairs/MANIFEST.json new file mode 100644 index 0000000000..95c8f28f2d --- /dev/null +++ b/research/gen4-extra-target-pairs/MANIFEST.json @@ -0,0 +1,13 @@ +{ + "files": { + "NOTICE-PR281.md": "08da3e05381aa0c2ea570fada8218dae70778d3eb0a68477725b2d052d7495b3", + "NOTICE-PR283.md": "05e85dc1d5fe98d4312572ad7440450b934ea8a0b8437a86bda7b2bb1158587d", + "NOTICE.md": "667cf1f2a00e309a879088d9cfd67e7ecc73b3909c3c67f28fe4b78b5260890a", + "PROOF.md": "d31735f699b76c8c05092092cce80fa5242d91bf915608d193bcb9b6eaf7b0a5", + "README.md": "9439245aff38391447574a1fdbba7062042aba9e9d80fee3d7aad86c912b8e0e", + "SOURCE.json": "04bb882d80c65924a600df1dc1d70bcb20d1ee2dd208e5173c277e9c3417872a", + "check.py": "91b9e6753d71e25119eee2c34c2b0b6cf27dcb6324c9a11c28ef8a6b3a0fc9b5", + "pairs.json.gz": "6395b922493fc82ebff1e37bd77841f9ebdcb7a1fa240f7fd040b449f88c1016", + "verify.py": "7c7120d3691c85098b5f4abac5a5fa7360a2ff8ed74720cb380216341cfc9ef7" + } +} diff --git a/research/gen4-extra-target-pairs/NOTICE-PR281.md b/research/gen4-extra-target-pairs/NOTICE-PR281.md new file mode 100644 index 0000000000..35736cc483 --- /dev/null +++ b/research/gen4-extra-target-pairs/NOTICE-PR281.md @@ -0,0 +1,16 @@ +# Attribution + +Prepared for **utcorvusvolat-dotcom** with substantial OpenAI Codex assistance. Apache-2.0. Original prerequisite source, notices, license and AI-assistance disclosures are preserved verbatim in `vendor/pr276`; these credits do not imply review or endorsement. + +- DreamingOfClouds and Anthropic Claude: PR276 gen4 physical bit word and its five-stage completed-bank package. +- Henry Grant (hcg890), PR234, and Jacob Sussman: five-stage architecture and certificate interface. +- eumemic: paired-cube/source527 scalar and physical machinery, common-delivery-frame retiming in PR244, and PR168 lineage; see inherited notices for full attributions. +- Evan McKinney (evmckinney9): PR197 completed banks and PR271 cleanup-sandwich identity. `code/cleanup_reference.py` adapts the public PR271 exact sandwich reference; `cleanup_screen.py` and `cleanup_emit.py` apply its argument to gen4. +- Rohan Arun: PR237 width-120 bank application, PR263 frame descent and concurrent PR279 application of the same 880 retimings to gen4. +- utcorvusvolat-dotcom: PR270 connected-block scan and selection binding; this package composes the 880 gen4 retimings with 440 shortened endpoints and 60 dirty entrance transports, with regenerated exact admissions. +- Chafik Boukhalfa (chafreaky), PR200: physical-word classes; icekylinx, PR144: paired-cube framework; Avi Eisenberg (ikeboy), PR193: retained complex supplier. +- `vendor/json.hpp`: nlohmann JSON, copyright Niels Lohmann, MIT license reproduced in the file header. + +No priority or global-optimality claim is made. The complete inherited attribution chains are in `vendor/pr276/NOTICE.md`, its `notices/` directory and its upstream notices. + +The target-prefix compression stage (`code/target_prefix.py`, `data/target-selection.json`; the mechanism is eumemic's PR268), the pinned call count and κ in `code/price.py`, the word hash in `verify.py` and this package's rebinding were prepared by Rohan Arun (rohanarun) with Anthropic Claude assistance, Apache-2.0. PR280's construction, emitters and checkers and the vendored PR276 package retain their notices unchanged. diff --git a/research/gen4-extra-target-pairs/NOTICE-PR283.md b/research/gen4-extra-target-pairs/NOTICE-PR283.md new file mode 100644 index 0000000000..c3283625db --- /dev/null +++ b/research/gen4-extra-target-pairs/NOTICE-PR283.md @@ -0,0 +1,13 @@ +# Attribution and license + +New terminal-sink port, fresh gen4 response-kernel selection, native audit ports, composition and packaging were prepared with substantial OpenAI Codex assistance. No personal byline is added. + +The immutable PR276 package at d428ab0462b9dfd3131ab4e89999f0adcd6173dd is by DreamingOfClouds with Anthropic Claude assistance and preserves its full inherited credits. See vendor/UPSTREAM-NOTICE.md and vendor/pr276-source.zip. The later PR276 head cf6cb4ebb55f0ee5f03918033e96a29209ff6798 changes CI only. + +The880 concave-descent retimings are Rohan Arun's PR279, prepared with Anthropic Claude assistance, pinned at2e2a38ba3f48edbda2152ed86691c75ff326b254. The later4d8c31eec7ae618645cb058101cb4e72a97268d3 preserves the selection and adds original producer-basis obligations to its prime audit; this package independently retains those through the unchanged original PR276 audit. Its relevant source, proof and notice are retained in vendor. + +Native checker/pricing ancestry and prior response-kernel work are credited in vendor/PRIOR-NATIVE-NOTICE.md. That historical notice describes earlier packages and is attribution, not a claim that their inputs or results are used unchanged here. In particular, old target pruning and parity synthesis are not new counted gains in this package. Fixed-prime finite-level pricing follows PR261 and its credited PR235/PR252 predecessors. Terminal sinks are an established public mechanism; the new contribution is their checked gen4 instantiation, fresh context-sensitive kernel witness and full composition. + +New code is Apache-2.0 under LICENSE. Existing files preserve their original licenses; nlohmann JSON is MIT and Boost is externally supplied under its own license. Public handles in inherited attribution remain. Credits imply neither review nor endorsement. + +Latest composition adds PR279 target-prefix squares at913ccc48a0bc1173709ea92280b96252256b7754, prepared by Rohan Arun with Anthropic Claude assistance and crediting eumemic's PR268 mechanism. PR280 atf063aab8d6e514188e53db57218515df9cdd186e supplies the60 proposed transported entrances and early-restoration mechanism, by utcorvusvolat-dotcom with substantial OpenAI Codex assistance. The new native ports, conflict rejection, later insertion cut, endpoint-aware bank charts and final recomposition were prepared with substantial OpenAI Codex assistance. See vendor/PR279-LATEST-NOTICE.md and vendor/PR280-NOTICE.md. Only29 of60 entrances are admitted. No gain is claimed for rejected candidates. diff --git a/research/gen4-extra-target-pairs/NOTICE.md b/research/gen4-extra-target-pairs/NOTICE.md new file mode 100644 index 0000000000..39db443ac9 --- /dev/null +++ b/research/gen4-extra-target-pairs/NOTICE.md @@ -0,0 +1,23 @@ +# Attribution + +Prepared for George Lydakis with substantial OpenAI Codex assistance. +New code and selection packaging are Apache-2.0 under the repository license. + +This contribution is the exact compatible selection of twenty additional +target pairs, their rebinding to PR283's compacted word, complete fresh +integration and independent replay. It does not claim invention of target +compression, helper kernels, sink removal or the finite-pricing framework. + +- Rohan Arun's PR281, prepared with Anthropic Claude assistance, supplies the + sixty proposed pair groups and common frame bases. See `NOTICE-PR281.md`. +- Dugongue's PR283, prepared with substantial OpenAI Codex assistance, supplies + the pinned composition, native target adapter and complete checkers. Its + files are not modified; see `NOTICE-PR283.md` and its retained vendor notices. +- PR283 preserves DreamingOfClouds' PR276 gen4 word, Rohan Arun's PR279 source + retimings and target squares, utcorvusvolat-dotcom's PR280 transports and + restorations, eumemic's PR268/source527 mechanisms, and the full inherited + contributor and license chain. Those notices remain in the immutable base. + +Credits imply neither review nor endorsement. No exclusive priority or global +optimality claim is made. Exact source commits and data hashes are recorded +in `SOURCE.json`. diff --git a/research/gen4-extra-target-pairs/PROOF.md b/research/gen4-extra-target-pairs/PROOF.md new file mode 100644 index 0000000000..7217d08edb --- /dev/null +++ b/research/gen4-extra-target-pairs/PROOF.md @@ -0,0 +1,80 @@ +# Exact target-pair composition + +## Source and selection + +The prerequisite is PR283 at `65768f62d4fde0d1fa7fc84f71678522a84aaa6c`, manifest +`bbaddd0d899baf91ccb7364da9251c93fea64c5fbaf7ccb6057c39600d4cf521`. Its complete +verifier runs fresh, admitting the word +`6910cbdf504c387242b61d9b9efcaf05488d3865fdc75ffe267e22f438da0521`. + +The new selection comes from the sixty two-target groups in PR281's frozen +selection at `34da045d8275bb43330533a6616d55a194393647`. For each candidate, its +PR280 close event was rebound by a unique surviving scalar instruction to the +original parity-fused gen4 word. PR283's unchanged native adapter maps that +instruction through sink compaction and onto its actual restored word. Every +frozen pair carries the original scalar tuple; the wrapper checks it against +fresh raw records before invoking the adapter. The common cut is PR283's own +cut, not an old raw offset reused without checking. + +All sixty were tested along with the 220 original squares. Forty fail the +actual geometric interval checks. Twenty survive, each with an exact nonzero +prefix dependency. The final frozen file contains only those twenty; it emits +the same word as the sixty-candidate trial. The native compiler recomputes a +minimum-cost response information set, checking every resulting dependency +exactly. Its floating-point ordering proposes a basis; the literal transcript +and exact rational price establish the final claim. No global optimality is claimed. + +## Pair identity and geometry + +For arbitrary dirty targets x and y receiving equal F2 increments R during an +interval, replace x's increments by `x -= y` at the cut and `x += y` at the +close. At the close its value is `x_initial-y_initial+(y_initial+R)`, hence the +same F2 result, and y is unchanged. The signed ADD instructions are retained +in the separately priced odd-payload integer lift. + +The native target emitter checks actual all-input prefix columns, including +arbitrary helper dirt, rejects active target control uses, checks that both +targets are at ZERO for setup, and verifies every regenerated MOVE is nested. +Both targets' restore frames have rank21 and lie within their final caps. +The additional frame Gram audit checks exact inverses and prime guards. +Copies and all input/output frames are unchanged. The twenty new groups are +disjoint from each other and all 220 original groups. + +The final word is +`c58643033f70544ab1af58fb31da5fa1f4869753895aab6bec9d1bcbb8507dc3`. +Its incremental local histogram is `{3:-20,18:-20,21:+20}`. Paid rank mass is +unchanged, while twenty local recursive calls disappear. Twenty reads are +removed and forty scalar ADDs are inserted, for 617,152 ADDs total. + +## Independent checks and complete price + +PR283's native target replay checks all 19,914 local columns forward and inverse. +The added Python implementation independently repeats both directions and +computes signed cancellation-free row bounds. It omits a setup and a restore +specifically from the twenty new pairs and requires both controls to fail. +It also checks byte-identical COPY events, unchanged scalar events outside the +forty affected targets, unchanged initial frames, and the exact histogram delta. + +The global checker verifies all 23,434 columns across five stages, arbitrary +helper dirt, immutable copied-center sources, 120 copies and six omitted-bridge +controls. The forward/inverse signed row-L1 bounds are 62,377 and 1,891,936; +`64*F^3*B^2` has 96 bits and remains below 2^104. + +All 9,836,400 actual bank assignments, endpoint charts and costs are regenerated. +Their complete receipt, apart from its label, is identical to PR283's: 341,356 +banks per stage, literal stock 2,551,580, normalized stock 510,316, 1,210 changed +endpoint charts and normalizer 983. No memory saving is counted for target pairs. + +With 120 replicas, the recounted normalized histogram has 11,670,960 calls, +rank mass 61,132,320 and deficit105,600. Two independent exact rational moment +engines retain the full rare-event fallback. The fixed prime 2^127-1 is checked +by 125 Lucas-Lehmer steps; eight ordinary levels and all 47 strict assembly +inequalities pass, while the adjacent finite grid point is rejected. + +The complete counted primitive coefficient is 185,427,454,637,140,801, including +2,323,665,382,800 bank selector calls and every changed scalar operation. +The independent checker rebinds recursive calls, scalar costs, stock, payload +and that recomputed coefficient to the actual word. The inherited finite +cutoff rule retains all row, setup, padding and preceding-level constants; +no recursive child is absorbed into a constant. All inherited all-size +interfaces remain assumptions, as documented by PR283 and its prerequisites. diff --git a/research/gen4-extra-target-pairs/README.md b/research/gen4-extra-target-pairs/README.md new file mode 100644 index 0000000000..fc17f62622 --- /dev/null +++ b/research/gen4-extra-target-pairs/README.md @@ -0,0 +1,63 @@ +# Twenty additional target pairs on PR283 + +This package raises the conditional exponent from PR283's +`0.000726111344123732762670617` to + +``` +kappa = 726214631355537156447271 / 10^27 + = 0.000726214631355537156447271 +``` + +The gain is 0.0142247% over that pinned construction and 1.75490% over PR275's +earlier zero-frame result. Twenty of PR281's additional target pairs compose +with PR283's sink/kernel/endpoint word. The other forty proposed pairs fail +the unchanged native geometric boundary checks and are excluded. + +| Quantity | Pinned PR283 | This composition | +|---|---:|---:| +| Target groups | 220 | 240 | +| Local scalar ADDs | 617,132 | 617,152 | +| Normalized recursive calls | 11,673,360 | 11,670,960 | +| Local paid rank mass | 422,844 | 422,844 | +| Literal stock, 120 replicas | 2,551,580 | 2,551,580 | + +The exact incremental local histogram is `{3:-20, 18:-20, 21:+20}`. Each pair +replaces a rank-18/rank-3 split with a rank-21 child. Its setup/restoration +adds two scalar ADDs and removes one previous prefix read. Every gain is +recomputed from the emitted word; exponents from separate proposals are not added. + +## Reproduce + +Obtain PR283 at commit `65768f62d4fde0d1fa7fc84f71678522a84aaa6c`, preserving +exact file bytes (`core.autocrlf=false` on Windows). Use Python 3.11+, SymPy +1.14.0, GCC with C++17 support and Boost headers: + +```sh +python -m pip install -r /path/to/pr283/research/gen4-composed-endpoints120/requirements.txt +python -B research/gen4-extra-target-pairs/verify.py \ + --base /path/to/pr283/research/gen4-composed-endpoints120 \ + --output /tmp/gen4-extra-target-pairs --cxx g++ +``` + +On Homebrew macOS, supply the installed GCC executable, such as +`--cxx /opt/homebrew/bin/g++-16 --boost-include /opt/homebrew/include`. +Apple Clang does not provide the prerequisite's `bits/stdc++.h` header. +The output directory must be new and outside both source packages. + +Verification starts with PR283's complete fresh source-bound replay, including +all nine original PR276 stages. It uses PR283's unchanged native target, +geometry, bank, global-column and exact-pricing implementations. A separate +Python checker repeats all 19,914 local columns in both directions, rejects +omissions specifically in the new pairs, and binds the literal counts and +finite invoice. Source manifests are checked before and after. No saved PASS +receipt substitutes for prerequisite execution. Final receipts are +`VERIFICATION.json` and `candidate/INDEPENDENT.json`; allow about ten minutes. + +`PROOF.md` gives the identity, boundaries and price. `SOURCE.json` pins inputs. +Notices preserve contributor and AI-assistance attribution. The older PR275 +package is a historical result and is not an input to this construction. + +This is a conditional finite construction under the retained all-size +compiler, weighted-chart, restored-row, routing, selector, prime-supply, +precision/recovery, complex and analytic hypotheses. It is not a full Lean +proof or a practical multiplication benchmark. diff --git a/research/gen4-extra-target-pairs/SOURCE.json b/research/gen4-extra-target-pairs/SOURCE.json new file mode 100644 index 0000000000..4b24ee1d34 --- /dev/null +++ b/research/gen4-extra-target-pairs/SOURCE.json @@ -0,0 +1,21 @@ +{ + "pr283": { + "commit": "65768f62d4fde0d1fa7fc84f71678522a84aaa6c", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/283", + "package": "research/gen4-composed-endpoints120", + "manifest_sha256": "bbaddd0d899baf91ccb7364da9251c93fea64c5fbaf7ccb6057c39600d4cf521", + "word_sha256": "6910cbdf504c387242b61d9b9efcaf05488d3865fdc75ffe267e22f438da0521" + }, + "pr281": { + "commit": "34da045d8275bb43330533a6616d55a194393647", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/281", + "selection": "research/gen4-retiming-entrances-target/data/target-selection.json", + "selection_sha256": "68c3a750be6de417db2cdd93c475e027dce6b0cdaa4e09b6e3e388d4ff8baa5d" + }, + "pr280_rebinding_source": { + "commit": "f063aab8d6e514188e53db57218515df9cdd186e", + "word_sha256": "71dd08f325566160a01b1c3d8b38450eeb48f478c8f7588065e234d58bddef48" + }, + "result_word_sha256": "c58643033f70544ab1af58fb31da5fa1f4869753895aab6bec9d1bcbb8507dc3", + "kappa": "726214631355537156447271/1000000000000000000000000000" +} diff --git a/research/gen4-extra-target-pairs/check.py b/research/gen4-extra-target-pairs/check.py new file mode 100644 index 0000000000..122c2a391b --- /dev/null +++ b/research/gen4-extra-target-pairs/check.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 +"""Independent columns, new-pair controls and literal invoice bindings.""" +import sys +if not __debug__:raise SystemExit('Assertions must be enabled') +sys.dont_write_bytecode=True +import argparse,hashlib,json,struct +from collections import Counter +from fractions import Fraction as Q +from pathlib import Path + +WORD='c58643033f70544ab1af58fb31da5fa1f4869753895aab6bec9d1bcbb8507dc3' +KAPPA=Q(726214631355537156447271,10**27) +def load(p):return json.loads(p.read_text()) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def word(p):return list(struct.iter_unpack('<6i',p.read_bytes())) +def hist(es):return Counter(e[4]for e in es if e[0]==0 and e[4])+Counter(e[5]for e in es if e[0]==2) + +def check(base,out): + before=base/'final';state=load(base/'restored/249-states.json');n,v=state['n'],state['v'] + assert (n,v)==(19914,1760) + assert sha(out/'COHORT249-RECORDS.bin')==WORD + old=word(before/'COHORT249-RECORDS.bin');new=word(out/'COHORT249-RECORDS.bin') + groups=load(out/'TARGET268-GROUPS.json');previous=load(before/'TARGET268-GROUPS.json') + assert len(groups)==240 and groups[:220]==previous and len(previous)==220 + extra=groups[220:];members={v+t for g in extra for t in g['targets']};assert len(members)==40 + assert all(len(g['targets'])==2 and len(g['dependent'])==1 and g['close_rank']==21 for g in extra) + assert load(out/'COHORT249-INITIAL.json')==load(before/'COHORT249-INITIAL.json') + assert [e for e in old if e[0]in(2,3)]==[e for e in new if e[0]in(2,3)] + assert [e for e in old if e[0]==1 and e[1]not in members and e[2]not in members]==[e for e in new if e[0]==1 and e[1]not in members and e[2]not in members] + local=hist(new);delta=local.copy();delta.subtract(hist(old));delta={r:c for r,c in delta.items()if c} + assert delta=={3:-20,18:-20,21:20} + assert sum(r*c for r,c in local.items())==422844 + def replay(reverse=False,omit=None): + cols=[1<0 + return dict(reverse=reverse,omitted_record=omit,wrong_rows=wrong,row_l1_bound=largest) + forward=replay();inverse=replay(True) + controls=[] + for cat in(34,35): + at=next(i for i,e in enumerate(new)if e[0]==1 and e[5]==cat and e[1]in members and e[2]in members) + controls.append(replay(omit=at)) + native=load(out/'GLOBAL.json');assert native['formal_columns_checked']==23434 + assert native['fresh_center_copies']==120 and len(native['negative_controls'])==6 + assert all(c['rejected']for c in native['negative_controls']) + assert dict(native['local_raw_H'])==local + assert [forward['row_l1_bound'],inverse['row_l1_bound']]==[int(r['cancellation_free_signed_row_l1_upper'])for r in native['signed_lift_prefix']] + adds=sum(e[0]==1 for e in new);units=sum(abs(e[3])for e in new if e[0]==1) + assert adds==native['local_scalar_additions']==sum(e[0]==1 for e in old)+20 + H=Counter({r:120*c for r,c in local.items()});H.update({r:48*v for r in(4,23,46,50)}) + bank=load(out/'BANK-REVIEW.json');oldbank=load(before/'BANK-REVIEW.json') + assert {k:v for k,v in bank.items()if k!='label'}=={k:v for k,v in oldbank.items()if k!='label'} + assert bank['normalized_stock']==510316 and bank['literal_stock']==2551580 + assert bank['actual_role_replica_stage_assignments']==9836400 + price=load(out/'FIXED-PRICE.json');profile=price['profile'];invoice=load(out/'FINITE.json') + assert {int(r):c for r,c in profile['histogram'].items()}==dict(H) + assert profile['calls']==sum(H.values()) and profile['rank_mass']==sum(r*c for r,c in H.items()) + assert profile['stock']==bank['normalized_stock'] and profile['deficit']==105600 + assert Q(price['kappa'])==KAPPA>Q(load(before/'FIXED-PRICE.json')['kappa']) + assert len(price['strict_constraints'])==47 and min(map(Q,price['strict_constraints'].values()))>0 + assert price['ordinary_levels']==8 and price['lucas_lehmer_iterations']==125 and price['lucas_lehmer_residue']=='0' + assert price['adjacent_rejected_at_finite_and_cap'] + assert int(price['finite_coefficient_recomputed'])==int(invoice['full_counted_primitive_coefficient']) + assert int(invoice['positive_rank_children'])==5*sum(H.values()) + assert int(invoice['global_weighted_additions'])==120*(5*adds+6*v) + assert int(invoice['global_unit_expanded_additions'])==120*(5*units+6*v) + assert int(invoice['full_counted_primitive_coefficient'])==185427454637140801 + payload=64*forward['row_l1_bound']**3*inverse['row_l1_bound']**2 + assert payload==int(native['payload_prefix_upper'])==int(invoice['payload_signed_prefix_upper']) and payload<2**104 + result=dict(status='PASS_INDEPENDENT_EXTRA_TARGET_PAIRS_AND_LITERAL_INVOICE',word_sha256=WORD,kappa=str(KAPPA), + kappa_decimal=price['kappa_decimal'],extra_pairs=20,targets=sorted(t-v for t in members),local_histogram_delta=delta, + local_additions=adds,local_unit_additions=units,normalized_calls=sum(H.values()),normalized_stock=profile['stock'], + unchanged_banks=True,forward=forward,inverse=inverse,new_pair_omission_controls=controls, + primitive_coefficient=invoice['full_counted_primitive_coefficient'],payload_bits=payload.bit_length(), + scope='Conditional finite construction. All inherited all-size hypotheses remain assumptions.') + (out/'INDEPENDENT.json').write_text(json.dumps(result,indent=2)+'\n') + print('PASS independent 20-pair composition; kappa = '+price['kappa_decimal'],flush=True) + return result + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--base-replay',type=Path,required=True);ap.add_argument('--candidate',type=Path,required=True);a=ap.parse_args() + check(a.base_replay,a.candidate) diff --git a/research/gen4-extra-target-pairs/pairs.json.gz b/research/gen4-extra-target-pairs/pairs.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..cdedc47987d88f8df2c3529a10ceba8eef2b5a36 GIT binary patch literal 1107 zcmb2|=3oE;rvGp6-1WO{Aj1CPx2@}x?C?{Cb1dEk`|NfV~xO_@&B-+wMH z@y&Yf&3L(xMabzxzF+XK$2a_HJ`1gvFR!kQz9*kj8-4ogx_d`X^RNUc9G`!8>hHI9 zarf>pEL4&Fw^2!JV$Vq#VP&J`E>2=0^?j##Y{Ik+6^bXmIBOwfE1AB?__1e6%AU@? z&vz$&lv%C*@WdB2JtJnJwPzN%C>t9TPLrHtk?N+>H#3lPvgFKwnO9$hcJErV@3{Bc z<8F2*vy@jm@2TljOzaZy*mPB1$o}f?`J1#>Z|#}>@p}H2h8HXETvIXP7rgo@?|V${ zqTTl|7H|FgQD^brT{SwdJyu;&w0g5Bc5m&Cu&2pi6tuGxW2!kB5!GRsJYMD4$)+l!)4p53S+B!B9cqujS=)owWp>trQgbyzLxTk$x?>KU7y zoR|B$(vTH9OP=V;7AJ9keLW+7c3(+JQo^#Y+l@RDuLzd9$eu4f!_Dijcj$%23Ii*v zYWL6(=i_@6wgv3(V}%;!WA(}9@L|OXeVQ4v#_8`@bY;CbAq+I_m51;Z!#5s#!a)Y@ zk&@NC`nhik+pKbt)|usJV)ic9dllmzsNYdyeP6WM?#jnoB|2YD%n~!{=rc(Sc^zQ^ahj8@ zV(^N1_co9xm0wv*?@M^#>HKm=mTc?h@(@?k(hx?Fbj)TqS^Jj0_ohPoE%;YFUSsvj zG+S$ugH>AR#fvwsS1p=lC3ZyY)pfz^YXaSYj-TV}o~Y0i095tbr0`oGQtZ4xk~c z4+a-}?_0D~SsfILJG7dCZVlhlRa_MdbkfS5=c7#X8%xd+HdIb-6M-*(w;5NpC2c!PJuyDyNEOK2>4a^}U0H?obUr7T`K z3*%&sW2QRF0zFh{CL7G`FXrW5tDZOu7^Nqotd;@2yMK}U5)D3P5Y|27{{5%IZJmR&hZU@m34AsnEeb36?X$cAC}K+5BRKgS=jcZjA`;NYo84M XlaBZAt<8?D{mH%S(3jq2X$%Yi2T~6^ literal 0 HcmV?d00001 diff --git a/research/gen4-extra-target-pairs/verify.py b/research/gen4-extra-target-pairs/verify.py new file mode 100644 index 0000000000..e65557397f --- /dev/null +++ b/research/gen4-extra-target-pairs/verify.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +"""Fresh immutable PR283 replay followed by twenty additional target pairs.""" +import sys +if not __debug__:raise SystemExit('Assertions must be enabled') +sys.dont_write_bytecode=True +import argparse,concurrent.futures,gzip,hashlib,json,os,struct,subprocess,time +from pathlib import Path +ROOT=Path(__file__).resolve().parent +BASE_MANIFEST='bbaddd0d899baf91ccb7364da9251c93fea64c5fbaf7ccb6057c39600d4cf521' + +def load(p):return json.loads(p.read_text(encoding='utf-8-sig')) +def sha(p):return hashlib.sha256(p.read_bytes()).hexdigest() +def integrity(root): + manifest=root/'MANIFEST.json';expected=load(manifest)['files'];actual={} + for p in root.rglob('*'): + assert not p.is_symlink(),'Symlink in pinned source package' + if p.is_file()and p!=manifest:actual[p.relative_to(root).as_posix()]=sha(p) + assert actual==expected,'Changed, missing or unpinned source file' + return sha(manifest) + +def main(): + ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--base',type=Path,required=True);ap.add_argument('--output',type=Path,required=True) + ap.add_argument('--cxx',default='g++');ap.add_argument('--boost-include',type=Path);a=ap.parse_args() + base,out=a.base.resolve(),a.output.resolve();assert not out.exists()and not out.is_relative_to(ROOT)and not out.is_relative_to(base) + own=integrity(ROOT);assert integrity(base)==BASE_MANIFEST + out.mkdir(parents=True);(out/'logs').mkdir();began=time.monotonic();stages=[];env=dict(os.environ,PYTHONDONTWRITEBYTECODE='1') + def run(label,cmd): + print(label,flush=True);start=time.monotonic() + with (out/'logs'/(label+'.log')).open('w')as log:subprocess.run(list(map(str,cmd)),stdout=log,stderr=subprocess.STDOUT,env=env,check=True) + stages.append(dict(stage=label,seconds=time.monotonic()-start)) + py=[sys.executable,'-B'];replay=out/'pr283';candidate=out/'candidate';candidate.mkdir() + try: + cmd=py+[base/'verify.py','--output',replay,'--cxx',a.cxx] + if a.boost_include:cmd+=['--boost-include',a.boost_include.resolve()] + run('01-pr283',cmd) + admitted=load(replay/'CERTIFICATE.json') + assert admitted['status']=='PASS_SOURCE_REGENERATED_COMPOSITION'and admitted['upstream_fresh_nine_stages'] + assert admitted['package_manifest_sha256']==BASE_MANIFEST + pairs=json.loads(gzip.decompress((ROOT/'pairs.json.gz').read_bytes()));assert len(pairs)==20 + selection=load(base/'inputs/targets220.json');assert len(selection['groups'])==220 + original=list(struct.iter_unpack('<6i',(replay/'base/249-records.bin').read_bytes())) + for pair in pairs: + e=original[pair['close_after_record']] + assert [e[j]for j in(0,1,2,3,5)]==pair['reference_close_scalar'] + selection['groups']+=pairs + selected=out/'targets240.json';selected.write_text(json.dumps(selection,separators=(',',':'))+'\n') + def exe(name):return replay/'bin'/(name+('.exe'if os.name=='nt'else'')) + X=replay/'restored' + run('02-target-pairs',[exe('target'),X,X,selected,candidate,replay/'base/249-records.bin',replay/'sinks/OLD-TO-NEW.json']) + jobs=[('03-target-grams',[exe('target-gram'),X,candidate,candidate/'TARGET279-GRAM.json']), + ('04-legality',[exe('legality'),X,candidate,candidate/'LEGALITY.json']), + ('05-prefix',[exe('prefix'),X,candidate,candidate/'PREFIX.json']), + ('06-banks',[exe('banks'),X,candidate/'COHORT249-INITIAL.json',candidate/'COHORT249-FRAMES.json',candidate,'gen4-extra-target-pairs']), + ('07-global',[exe('global'),candidate/'COHORT249-RECORDS.bin',X/'249-states.json',candidate/'GLOBAL.json'])] + with concurrent.futures.ThreadPoolExecutor(max_workers=3)as pool:list(pool.map(lambda x:run(*x),jobs)) + run('08-price',[exe('price'),candidate/'COHORT249-REPLAY.json',candidate/'BANK-REVIEW.json',candidate/'PRICE.json']) + run('09-finite',[exe('finite'),candidate/'COHORT249-RECORDS.bin',candidate/'PRICE.json',candidate/'BANK-REVIEW.json',candidate/'GLOBAL.json',candidate/'FINITE.json']) + run('10-fixed',[exe('fixed'),candidate/'PRICE.json',candidate/'FINITE.json',candidate/'FIXED-PRICE.json']) + run('11-independent',py+[ROOT/'check.py','--base-replay',replay,'--candidate',candidate]) + assert integrity(ROOT)==own and integrity(base)==BASE_MANIFEST + proof=load(candidate/'INDEPENDENT.json') + result=dict(status='PASS_IMMUTABLE_EXTRA_TARGET_PAIRS_ON_GEN4_COMPOSITION',manifest_sha256=own,base_manifest_sha256=BASE_MANIFEST, + inputs_unchanged=True,fresh_stages=sorted(stages,key=lambda x:x['stage']),seconds=time.monotonic()-began, + word_sha256=proof['word_sha256'],kappa=proof['kappa'],kappa_decimal=proof['kappa_decimal'],scope=proof['scope']) + (out/'VERIFICATION.json').write_text(json.dumps(result,indent=2)+'\n');print('PASS kappa = '+result['kappa_decimal'],flush=True) + except BaseException as e: + (out/'FAILURE.json').write_text(json.dumps(dict(error=str(e),completed_stages=stages),indent=2)+'\n');raise + +if __name__=='__main__':main() From 6b817d07454a458baa93a6185e885121cfb57b03 Mon Sep 17 00:00:00 2001 From: George Lydakis Date: Sat, 10 Oct 2026 03:38:16 -0400 Subject: [PATCH 05/25] Compose source retiming and target prefixes on gen5 --- .gitattributes | 5 + .github/workflows/gen5-retiming-targets.yml | 58 + research/gen5-retiming-targets/MANIFEST.json | 26 + .../gen5-retiming-targets/NOTICE-PR283.md | 13 + .../gen5-retiming-targets/NOTICE-PR285.md | 56 + research/gen5-retiming-targets/NOTICE.md | 26 + research/gen5-retiming-targets/PROOF.md | 97 + research/gen5-retiming-targets/README.md | 52 + research/gen5-retiming-targets/SOURCE.json | 22 + research/gen5-retiming-targets/check.py | 102 + research/gen5-retiming-targets/code/banks.cpp | 39 + .../gen5-retiming-targets/code/finite.cpp | 14 + research/gen5-retiming-targets/code/fixed.cpp | 62 + .../gen5-retiming-targets/code/global.cpp | 42 + .../gen5-retiming-targets/code/legality.cpp | 7 + research/gen5-retiming-targets/code/price.cpp | 28 + .../code/retime-support.hpp | 19 + .../gen5-retiming-targets/code/retime279.cpp | 8 + .../code/target-gram.cpp | 4 + .../gen5-retiming-targets/code/target.cpp | 58 + research/gen5-retiming-targets/export.py | 35 + .../gen5-retiming-targets/retiming.json.gz | Bin 0 -> 66551 bytes .../gen5-retiming-targets/targets.json.gz | Bin 0 -> 10672 bytes .../gen5-retiming-targets/vendor/json.hpp | 25526 ++++++++++++++++ research/gen5-retiming-targets/verify.py | 76 + 25 files changed, 26375 insertions(+) create mode 100644 .github/workflows/gen5-retiming-targets.yml create mode 100644 research/gen5-retiming-targets/MANIFEST.json create mode 100644 research/gen5-retiming-targets/NOTICE-PR283.md create mode 100644 research/gen5-retiming-targets/NOTICE-PR285.md create mode 100644 research/gen5-retiming-targets/NOTICE.md create mode 100644 research/gen5-retiming-targets/PROOF.md create mode 100644 research/gen5-retiming-targets/README.md create mode 100644 research/gen5-retiming-targets/SOURCE.json create mode 100644 research/gen5-retiming-targets/check.py create mode 100644 research/gen5-retiming-targets/code/banks.cpp create mode 100644 research/gen5-retiming-targets/code/finite.cpp create mode 100644 research/gen5-retiming-targets/code/fixed.cpp create mode 100644 research/gen5-retiming-targets/code/global.cpp create mode 100644 research/gen5-retiming-targets/code/legality.cpp create mode 100644 research/gen5-retiming-targets/code/price.cpp create mode 100644 research/gen5-retiming-targets/code/retime-support.hpp create mode 100644 research/gen5-retiming-targets/code/retime279.cpp create mode 100644 research/gen5-retiming-targets/code/target-gram.cpp create mode 100644 research/gen5-retiming-targets/code/target.cpp create mode 100644 research/gen5-retiming-targets/export.py create mode 100644 research/gen5-retiming-targets/retiming.json.gz create mode 100644 research/gen5-retiming-targets/targets.json.gz create mode 100644 research/gen5-retiming-targets/vendor/json.hpp create mode 100644 research/gen5-retiming-targets/verify.py diff --git a/.gitattributes b/.gitattributes index 6cd6ad54bf..b2a8f6bce5 100644 --- a/.gitattributes +++ b/.gitattributes @@ -18,3 +18,8 @@ research/coordinated-frames-and-entrance-banks/** -text -whitespace # The target-pair manifest preserves this pinned upstream notice verbatim. research/gen4-extra-target-pairs/NOTICE-PR283.md -text whitespace=cr-at-eol + +# Preserve every source byte covered by the gen5 composition manifest. +research/gen5-retiming-targets/** -text whitespace=cr-at-eol +# Imported native files retain their original trailing blank lines. +research/gen5-retiming-targets/code/** whitespace=cr-at-eol,-blank-at-eof diff --git a/.github/workflows/gen5-retiming-targets.yml b/.github/workflows/gen5-retiming-targets.yml new file mode 100644 index 0000000000..632babb5d8 --- /dev/null +++ b/.github/workflows/gen5-retiming-targets.yml @@ -0,0 +1,58 @@ +name: Verify gen5 retiming and target composition +on: + push: + paths: + - 'research/gen5-retiming-targets/**' + - '.github/workflows/gen5-retiming-targets.yml' + pull_request: + paths: + - 'research/gen5-retiming-targets/**' + - '.github/workflows/gen5-retiming-targets.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + exact-replay: + runs-on: ubuntu-24.04 + timeout-minutes: 25 + strategy: + fail-fast: false + matrix: + python-version: ['3.11', '3.13'] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - name: Obtain immutable PR285 prerequisite + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: DreamingOfClouds/integer-mult-bounds + ref: b40c1a3d8f40ee3764b9f13fe850f663f2d8c834 + path: build/pinned-pr285 + sparse-checkout: research/five-stage-gen5-banks + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: ${{ matrix.python-version }} + - name: Prepare declared Boost headers + run: | + if ! test -f /usr/include/boost/multiprecision/cpp_int.hpp; then + sudo apt-get update + sudo apt-get install -y libboost-dev + fi + printf '#include \nint main() { boost::multiprecision::cpp_int n = 1; return n == 1 ? 0 : 1; }\n' | g++ -std=c++17 -x c++ -fsyntax-only - + - name: Install pinned arithmetic dependency + run: python -m pip install -r build/pinned-pr285/research/five-stage-gen5-banks/requirements.txt + - name: Replay complete prerequisites and composed construction + run: python -B research/gen5-retiming-targets/verify.py --base build/pinned-pr285/research/five-stage-gen5-banks --output /tmp/gen5-retiming-targets + - name: Show bounded diagnostics on failure + if: failure() + run: | + python - <<'PY' + from pathlib import Path + for path in sorted(Path('/tmp/gen5-retiming-targets').rglob('*.log')): + print(path) + print('\n'.join(path.read_text(errors='replace').splitlines()[-30:])) + PY + - name: Require unchanged tracked artifacts + run: git diff --exit-code diff --git a/research/gen5-retiming-targets/MANIFEST.json b/research/gen5-retiming-targets/MANIFEST.json new file mode 100644 index 0000000000..126ef6458f --- /dev/null +++ b/research/gen5-retiming-targets/MANIFEST.json @@ -0,0 +1,26 @@ +{ + "files": { + "NOTICE-PR283.md": "05e85dc1d5fe98d4312572ad7440450b934ea8a0b8437a86bda7b2bb1158587d", + "NOTICE-PR285.md": "e568be11d66f7225a76affd7af7bffc4e26663b792ba0dca2411cabc0cccd005", + "NOTICE.md": "23569769c782073e01e9510d809a7054b6cd9710381071a0f8ba7e510163a926", + "PROOF.md": "5fa279249408a0a1de90464b59441fc3f7c3b69e3f6af3829e6c4dac4902666e", + "README.md": "c52518f060213c9c98746d36f3de401baa38730931909534f8d73590784d67a7", + "SOURCE.json": "72ef476c62756fa0ce27a73319af034eae8099a141b55841d3e2bd315bb01678", + "check.py": "cbb36751c401426046412703558e5f8228f82c6256e7d671918b9b76ac12914d", + "code/banks.cpp": "f0f25b123294691729234daeb1efbad3f5772bb22fd12cbb549a6fd5f4d1e8ff", + "code/finite.cpp": "bd5c031eaeaddaf006ff112d55610c68fc3af477d361566a76e7744a7cd249e2", + "code/fixed.cpp": "fa4111e0cf9f25375c59d1889399fcad52fd41813787872027638a2d4a4b8dc5", + "code/global.cpp": "dd169bbd147094311aca109c59e1e7a671de710287664e30ddf43b367a8194f0", + "code/legality.cpp": "5acdc6849ba294637807b0b1528c97a60c48b2c3d9927bb2d2600ff13bf0d425", + "code/price.cpp": "3962654aefc8488a4062dbd430eea0952f1f908f144565c75a79f18b7232f8ed", + "code/retime-support.hpp": "da751f6a43e8fe9d8eee10c0ab80b241f74fe077d018f96416dfea40d08d0b6c", + "code/retime279.cpp": "7733ddcfb948a627d9cd6512adbf9c870120540f95fbd1377edeb55bc9254868", + "code/target-gram.cpp": "37ed84c30e49819588e5fdae44c7898d70b8db0e1e276f78d4f25ae8a650ab94", + "code/target.cpp": "05765824937eeb09c6d24e37a5f45c867a428649fd02c707dad19bf122776083", + "export.py": "e3c98dfa41e3325524df2c71b672b41af21c080a5ea61f0d283118a591c5e2b5", + "retiming.json.gz": "5a9c50bce30eeaa8c3f16f2a8c6fc20a2cccf978b563741c3e8f75fecde3b3b3", + "targets.json.gz": "93c10779ca435db930d6d385ab799c712bc064b886902ecdd83b48f4bb09c8ce", + "vendor/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "verify.py": "0544ee16e7ef30fb4d25d826815cd9cda5aea1d986faadfb1cc1cbf5075daa5b" + } +} diff --git a/research/gen5-retiming-targets/NOTICE-PR283.md b/research/gen5-retiming-targets/NOTICE-PR283.md new file mode 100644 index 0000000000..c3283625db --- /dev/null +++ b/research/gen5-retiming-targets/NOTICE-PR283.md @@ -0,0 +1,13 @@ +# Attribution and license + +New terminal-sink port, fresh gen4 response-kernel selection, native audit ports, composition and packaging were prepared with substantial OpenAI Codex assistance. No personal byline is added. + +The immutable PR276 package at d428ab0462b9dfd3131ab4e89999f0adcd6173dd is by DreamingOfClouds with Anthropic Claude assistance and preserves its full inherited credits. See vendor/UPSTREAM-NOTICE.md and vendor/pr276-source.zip. The later PR276 head cf6cb4ebb55f0ee5f03918033e96a29209ff6798 changes CI only. + +The880 concave-descent retimings are Rohan Arun's PR279, prepared with Anthropic Claude assistance, pinned at2e2a38ba3f48edbda2152ed86691c75ff326b254. The later4d8c31eec7ae618645cb058101cb4e72a97268d3 preserves the selection and adds original producer-basis obligations to its prime audit; this package independently retains those through the unchanged original PR276 audit. Its relevant source, proof and notice are retained in vendor. + +Native checker/pricing ancestry and prior response-kernel work are credited in vendor/PRIOR-NATIVE-NOTICE.md. That historical notice describes earlier packages and is attribution, not a claim that their inputs or results are used unchanged here. In particular, old target pruning and parity synthesis are not new counted gains in this package. Fixed-prime finite-level pricing follows PR261 and its credited PR235/PR252 predecessors. Terminal sinks are an established public mechanism; the new contribution is their checked gen4 instantiation, fresh context-sensitive kernel witness and full composition. + +New code is Apache-2.0 under LICENSE. Existing files preserve their original licenses; nlohmann JSON is MIT and Boost is externally supplied under its own license. Public handles in inherited attribution remain. Credits imply neither review nor endorsement. + +Latest composition adds PR279 target-prefix squares at913ccc48a0bc1173709ea92280b96252256b7754, prepared by Rohan Arun with Anthropic Claude assistance and crediting eumemic's PR268 mechanism. PR280 atf063aab8d6e514188e53db57218515df9cdd186e supplies the60 proposed transported entrances and early-restoration mechanism, by utcorvusvolat-dotcom with substantial OpenAI Codex assistance. The new native ports, conflict rejection, later insertion cut, endpoint-aware bank charts and final recomposition were prepared with substantial OpenAI Codex assistance. See vendor/PR279-LATEST-NOTICE.md and vendor/PR280-NOTICE.md. Only29 of60 entrances are admitted. No gain is claimed for rejected candidates. diff --git a/research/gen5-retiming-targets/NOTICE-PR285.md b/research/gen5-retiming-targets/NOTICE-PR285.md new file mode 100644 index 0000000000..3a110e116d --- /dev/null +++ b/research/gen5-retiming-targets/NOTICE-PR285.md @@ -0,0 +1,56 @@ +# Attribution and licence + +Apache-2.0 applies. Original headers, licences, notices and AI-assistance disclosures are preserved. The +credits below do not imply review or endorsement. + +## Inherited, unchanged or with rebound constants + +- **Five-stage architecture and finite interface package:** Henry Grant (hcg890), PR234, and Jacob + Sussman's five-stage construction and gcert/1 export. The complete inherited five-stage credits are in + `UPSTREAM-PR234-NOTICE.md`. +- **Package machinery:** eumemic's source527 package, prepared with substantial OpenAI Codex assistance, + with its lineage: Dugongue's PR207/PR216 finite and bank admissions, Rohan Arun's PR211 and sennemmi's + PR230 frame work, and eumemic's PR210. Their notices are retained verbatim in `notices/`. + This covers the scalar program `scalar/word.py` (byte-identical), the physical event emitter, the parity + fusion, the raw-ledger census, the stage-private bank template and checker, the moment, prime and + finite-bill checks, and `verify.py`. In this package they are rebound to the gen5 helper's constants; + the logic is unchanged. +- **Banks:** Evan McKinney's PR197 completed-bank method. Rohan Arun's PR237 published the width-120 + application first. +- **Complex supplier:** Avi Eisenberg (ikeboy)'s PR193 helper, inside Sussman's five-stage certificate. + The original disclosures are in `inputs/complex`. +- **Physical-word classes:** Chafik Boukhalfa (chafreaky)'s PR200 `bit/word.py` and `bit/base_word.py`, + vendored unchanged in `gen5bit/bit`. `gen5bit/NOTICE-PR200` is PR200's own notice. +- **Checker:** eumemic's PR168-v4 `check_paired_cube_bit.py`, vendored unchanged. +- **Paired-cube framework and its developments:** + - icekylinx's PR144: paired-coordinate/shared-core framework and configurable local channels. + - PR161/PR168 (eumemic): annealed modules, nested schedules and the generator. + - James Chang's PR166 and PR162's carrier rule. + +## New in this package + +**The gen5 modules** (on top of #276's gen4 word): `data/pair_module_p12.json` (pair + centre, debt 164) and +`data/qmod_p12.json` (all-but-one, debt 11), annealed against the exact one-instance compile cost with exact +closed-form rank evaluators; the new frozen arcs `data/arcs_p12.json`; and the `--bank-parity` option of the +pair producer. + +**The gen4 bit word** (from #276, retained). This covers: + +- the arc-aware per-cube local design (`local_design()` recipe trees and `data/local_design_p12.json`); +- the centre-sharing pair-module patch in `finish()`. + +**Its physical-layer producers.** `gen5bit/producer/make_physical.py` and `descent.py` are new +implementations of PR200's stated rules. + +**Package integration.** This covers: + +- `prepare.py` and `virtual_check.py`; +- the rewritten `scalar_check.py` controls; +- the rank-21, rank-18 and rank-17 geometry checks; +- the odd-coefficient choice in the `scalar_check.py` controls; +- the gen5 bank patterns and documentation. + +All of this was prepared by DreamingOfClouds with Anthropic Claude assistance. The circuit and module +search was run by Claude agents (simulated annealing, CP-SAT and exact one-instance compiles), and every +reported number was re-run with the exact generator. No exclusive priority is claimed for any inherited +design or theorem interface. diff --git a/research/gen5-retiming-targets/NOTICE.md b/research/gen5-retiming-targets/NOTICE.md new file mode 100644 index 0000000000..66e14753b9 --- /dev/null +++ b/research/gen5-retiming-targets/NOTICE.md @@ -0,0 +1,26 @@ +# Attribution and scope + +Prepared for George Lydakis with substantial OpenAI Codex assistance, including +coordinated independent research and review by Ody. New contributions are +Apache-2.0. No exclusive priority is claimed. + +This package contributes the source-bound gen5 source-retiming selection, the +exact prefix-boundary search and target selection, their verified composition, +the gen5 bank/price adapters, independent circuit and invoice checks, immutable +replay and CI. The mechanisms build on prior contributions: + +- DreamingOfClouds' PR285 supplies the new gen5 module circuits and immutable + nine-stage package, prepared with Anthropic Claude assistance. Its full notice + is preserved in NOTICE-PR285.md. +- Dugongue's PR283 supplies the compatibility exporter, native tools and exact + pricers, prepared with OpenAI Codex assistance. Its full notice is preserved in + NOTICE-PR283.md; retained native sources and the JSON header remain attributed. +- Rohan Arun's PR279 supplies source concave retiming and target-square work; + PR281 supplies the target candidate sets and bases, with Anthropic Claude + assistance disclosed. Our boundaries and source frames are re-derived on gen5. +- Eumemic supplies the target-prefix mechanism and source527 lineage; Chafik + Boukhalfa, utcorvusvolat-dotcom and the full inherited contributor chain are + credited in the preserved prerequisite notices. + +All-size hypotheses remain conditional. Certificate success does not formally +verify the whole multiplication theorem. diff --git a/research/gen5-retiming-targets/PROOF.md b/research/gen5-retiming-targets/PROOF.md new file mode 100644 index 0000000000..ba67a1598c --- /dev/null +++ b/research/gen5-retiming-targets/PROOF.md @@ -0,0 +1,97 @@ +# Source-bound finite composition + +## Sources and selections + +The immutable PR285 package is the defining gen5 source. The wrapper validates +its exact manifest and freshly runs its virtual, raw, bit, scalar, primes, +banks, complex, math and finite stages. It then exports the parity-fused physical +word through the untouched generator and emitter. The word hash must be +`6613c804f11ee9e96d96f1a34f8a7afa7a4a5380d998a72a1ac29012aeca029f`. +The cohort adapter changes filenames and records the actual histogram; it does +not change the baseline stream, frames, initial states or helper ownership. + +The source-retiming search raises source-source ADDs to legal existing frames +from their next operand requirements, using exact containment and a concavity +screen. Its 880 frozen entries bind old frames, bases and scalar events to the +actual gen5 word. The retained native verifier replays exact integer source +supports, admits every replacement Gram matrix, checks chronological nesting, +and rejects 880 undersized-frame controls. All 19406 local inputs, including +arbitrary helper dirt, are represented. The scalar/COPY projection and endpoints +are unchanged. The retimed word hash is +`729b7dd88da3d5da4ec2ba77325312e6730c7c4b93abbffc0f2fa9eca533a48a`. + +For targets, the inherited candidate target sets and bases were screened on the +actual gen5 word. The search tests the earliest admissible boundary and every +target update up to the last admissible boundary, maintaining exact F2 prefix +columns and comparing information-set costs. The 2560-boundary experiment finds +220 profitable four-target groups. Approximate costs only order discovery; +the frozen selections must pass exact circuit, geometry and rational pricing. +Close records refer to the gen5 baseline, then bind through unique surviving +scalar/COPY events in the retimed word. The target transformer independently +recomputes every prefix dependency and the information set. All 880 participating +targets are disjoint. There are 220 relations, 1760 removed prefix ADDs and 1320 +inserted setup/restoration ADDs. + +## Exact cost changes + +The source retiming histogram delta is +`{1:-1760, 2:+880, 20:-880, 21:+1760, 22:-880}`. +The target delta is +`{1:-221, 2:-8, 17:-1, 18:-7, 20:-212, 21:+220}`. +Their rank-weighted sums vanish. They remove 1109 local children total, or +133080 normalized calls at 120 replicas. The target relation count is not the +same as its 229-child saving. Local ADDs fall from 574832 to 574392; the final +unit-expanded count is 577912. Local rank mass stays 411356. + +Helper endpoints are unchanged, so the exact PR285 bank patterns are doubled +from 60 to 120 replicas: 20 banks of (7^12,4^9), 8722 of 4^30, 1062 of 3^40, +96 of 6^20, and 319968 of 24^5, per stage. Every bank has width 120. The native +allocator checks the complete residual census, all 9531600 assignments, coverage +without collisions and omitted/repeated-block controls. It independently +rebuilds all 411 endpoint charts with exact inverse/projector/weighted-split +checks; the largest factor count is 318, below the retained ceiling 744. + +PR285's initial helper rank sum is 51396, giving normalized stock +`168960 + 24*15886 - 51396 = 498828`. This derives the native price binding +constant 117564. The old gen4 constant 119374 is not reused. The bank adapter +requires unchanged helper endpoints and rejects new helper gauges; it is scoped +to this source-retiming/target-only construction. The normalizer ceiling is 983, +and the complete counted selector bill is 2251688038800. The native price's +floating proposal bracket was widened to 0.001; both exact rational moment +bounds, the adjacent grid check and the unchanged complex constraints still +determine acceptance. + +## Independent verification and assembly + +The unchanged target transformer checks every local column in both directions, +actual nested moves, literal prefix dependencies and omitted setup/restoration. +The separate legality and target-Gram tools admit the final circuit. The global +checker covers 22926 formal columns, 120 fresh center copies and six rejected +omitted bridges. The complete fresh PR285 scalar stage separately checks its +signed integer decoder and actual-context controls. + +`check.py` independently replays all 19406 local F2 columns forward and inverse, +rejects setup/restoration omissions in the final target group, checks the two +literal histogram deltas, and binds unaffected scalar/COPY events and helper +initial frames. It derives the helper rank census from source frames, recounts +bank slots, reconstructs the normalized histogram and recomputes the full +primitive coefficient directly from literal unit ADDs, routes, children and +selectors. It checks equality against both native invoice engines. + +Forward/inverse cancellation-free signed row-L1 bounds are 46393 and 2303032. +Their payload bound has 95 bits and is below 2^104. The full primitive coefficient +is 180164370784684201. The exact engines verify eight ordinary levels, the fixed +prime 2^127-1 with 125 Lucas-Lehmer steps, all 47 strict assembly inequalities and +the rejected adjacent finite grid point. The unchanged retained complex supplier +has coarse bound 747454944651775/10^18; this construction remains bit-limited. + +The final word hash is +`7afb22d4d11c0d558644ae18c9227180300fd242c819ae227e94e891decc5d60`. +The final rational is `744118535019311029483079/10^27`, strictly above PR285. + +## Scope + +All inherited all-size compiler, weighted-chart, restored-row, routing, selector, +prime-supply, precision/recovery, complex and analytic interfaces remain +assumptions. This finite certificate is not a formal proof of the complete +multiplication theorem, a multiplier benchmark, or a global-optimality claim. diff --git a/research/gen5-retiming-targets/README.md b/research/gen5-retiming-targets/README.md new file mode 100644 index 0000000000..c352e7b81f --- /dev/null +++ b/research/gen5-retiming-targets/README.md @@ -0,0 +1,52 @@ +# Gen5 source retiming and target-prefix compression + +**Conditional κ = 744118535019311029483079 / 10^27 = +0.000744118535019311029483079**, 0.1794423% above freshly reproduced PR285. + +This package ports two independently discovered optimizations to PR285's actual +gen5 word: 880 source-frame retimings and 220 target-prefix groups. The target +search examined 2560 admissible boundaries using exact prefix columns. Closing +at the latest admissible boundary gave no savings; earlier boundaries expose +220 dependencies. The source search derives its frames from the new word's +operand chronology. Neither selection reuses gen4 record indices. + +| Quantity | PR285 baseline | Composition | +|---|---:|---:| +| Local recursive calls | 92502 | 91393 | +| Local scalar ADDs | 574832 | 574392 | +| Local rank mass | 411356 | 411356 | +| Normalized calls, 120 replicas | 11438160 | 11305080 | +| Literal stock, 120 replicas | 2494140 | 2494140 | + +Source retiming removes 880 local children. Target compression removes another +229 children and 440 scalar ADDs. The complete doubled PR285 bank layout is +retained: 329868 banks per stage and 9531600 role/replica/stage assignments. +The complex supplier and all inherited hypotheses remain unchanged. + +## Reproduce + +Use Python 3.11+, SymPy 1.14.0, GCC/C++17 and Boost headers. Obtain PR285 at +`b40c1a3d8f40ee3764b9f13fe850f663f2d8c834`, then run: + +```sh +python -m pip install -r /path/to/pr285/research/five-stage-gen5-banks/requirements.txt +python -B research/gen5-retiming-targets/verify.py \ + --base /path/to/pr285/research/five-stage-gen5-banks \ + --output /tmp/gen5-retiming-targets --cxx g++ +``` + +The output directory must not exist. For Homebrew GCC, add +`--cxx /opt/homebrew/bin/g++-16 --boost-include /opt/homebrew/include`. +The wrapper freshly verifies all nine PR285 stages, exports its word, rebuilds +the native tools, applies both selections, and reruns geometry, Gram, banks, +global columns, exact moments and the literal finite invoice. A separate Python +checker verifies the final columns, actual circuit differences and cost formula. +Saved PASS receipts never replace execution. Source manifests are checked before +and after the run. CI executes the full command on Python 3.11 and 3.13. + +The primitive coefficient is 180164370784684201, with a 95-bit payload bound, +eight ordinary levels, the fixed prime 2^127-1, 47 strict assembly inequalities +and rejection of the adjacent finite grid point. This is a conditional finite +construction, not a formally verified complete theorem or a measured multiplier. + +See [PROOF.md](PROOF.md), [SOURCE.json](SOURCE.json) and [NOTICE.md](NOTICE.md). diff --git a/research/gen5-retiming-targets/SOURCE.json b/research/gen5-retiming-targets/SOURCE.json new file mode 100644 index 0000000000..6674586ee3 --- /dev/null +++ b/research/gen5-retiming-targets/SOURCE.json @@ -0,0 +1,22 @@ +{ + "pr285": { + "commit": "b40c1a3d8f40ee3764b9f13fe850f663f2d8c834", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/285", + "package": "research/five-stage-gen5-banks", + "manifest_sha256": "2bf16d814b629cfb314db663532c55eba5f12d63f732793e825d1ec3eb07df17", + "word_sha256": "6613c804f11ee9e96d96f1a34f8a7afa7a4a5380d998a72a1ac29012aeca029f" + }, + "native_source_pr283": { + "commit": "65768f62d4fde0d1fa7fc84f71678522a84aaa6c", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/283", + "package": "research/gen4-composed-endpoints120" + }, + "target_group_source_pr281": { + "commit": "34da045d8275bb43330533a6616d55a194393647", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/281", + "selection_sha256": "68c3a750be6de417db2cdd93c475e027dce6b0cdaa4e09b6e3e388d4ff8baa5d" + }, + "retimed_word_sha256": "729b7dd88da3d5da4ec2ba77325312e6730c7c4b93abbffc0f2fa9eca533a48a", + "final_word_sha256": "7afb22d4d11c0d558644ae18c9227180300fd242c819ae227e94e891decc5d60", + "kappa": "744118535019311029483079/1000000000000000000000000000" +} diff --git a/research/gen5-retiming-targets/check.py b/research/gen5-retiming-targets/check.py new file mode 100644 index 0000000000..b133b1917a --- /dev/null +++ b/research/gen5-retiming-targets/check.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Independent gen5 composition, arbitrary-column and literal-cost checks.""" +import sys +if not __debug__:raise SystemExit('Assertions must be enabled') +sys.dont_write_bytecode=True +import argparse,hashlib,json,struct +from pathlib import Path +from collections import Counter +from fractions import Fraction as Q +WORD='7afb22d4d11c0d558644ae18c9227180300fd242c819ae227e94e891decc5d60' +KAPPA=Q(744118535019311029483079,10**27) + +def load(p):return json.loads(p.read_text()) +def word(p):return list(struct.iter_unpack('<6i',p.read_bytes())) +def hist(es):return Counter(e[4]for e in es if e[0]==0 and e[4])+Counter(e[5]for e in es if e[0]==2) +def delta(a,b): + h=hist(a);h.subtract(hist(b));return {r:c for r,c in h.items()if c} + +def main(root): + b=root/'base';r=root/'retimed';d=root/'candidate';st=load(b/'249-states.json');n,v=st['n'],st['v'];assert(n,v)==(19406,1760) + old=word(b/'249-records.bin');mid=word(r/'COHORT249-RECORDS.bin');new=word(d/'COHORT249-RECORDS.bin') + assert hashlib.sha256((d/'COHORT249-RECORDS.bin').read_bytes()).hexdigest()==WORD + project=lambda es:[(e[0],e[1],e[2],e[3],e[5])for e in es if e[0]] + assert project(old)==project(mid) + assert delta(mid,old)=={1:-1760,2:880,20:-880,21:1760,22:-880} + assert delta(new,mid)=={1:-221,17:-1,18:-7,2:-8,20:-212,21:220} + rt=load(r/'RETIMING279.json');assert rt['selected_gates']==rt['undersized_frame_controls_rejected']==880 + assert rt['checked_source_indices']==1760 and not rt['rejected'] and rt['identical_scalar_and_copy_projection'] + groups=load(d/'TARGET268-GROUPS.json');assert len(groups)==220 and all(len(g['targets'])==4 and len(g['dependent'])==1 for g in groups) + members={v+t for g in groups for t in g['targets']};assert len(members)==880 + assert load(d/'COHORT249-INITIAL.json')==st['initial']==load(r/'COHORT249-INITIAL.json') + assert load(d/'COHORT249-SELECTION.json')==[] + assert [e for e in mid if e[0]in(2,3)]==[e for e in new if e[0]in(2,3)] + assert [e for e in mid if e[0]==1 and e[1]not in members and e[2]not in members]==[e for e in new if e[0]==1 and e[1]not in members and e[2]not in members] + def replay(reverse=False,omit=None): + cols=[1<0) + return dict(reverse=reverse,omitted_record=omit,wrong_rows=wrong,row_l1_bound=largest) + fw=replay();inv=replay(True);controls=[] + for cat in(34,35): + at=next(i for i in range(len(new)-1,-1,-1)if new[i][0]==1 and new[i][5]==cat) + controls.append(replay(omit=at)) + h=hist(new);assert sum(r*c for r,c in h.items())==411356 + g=load(d/'GLOBAL.json');assert g['formal_columns_checked']==22926 and g['fresh_center_copies']==120 + assert len(g['negative_controls'])==6 and all(c['rejected']for c in g['negative_controls']) + assert dict(g['local_raw_H'])==h + assert[fw['row_l1_bound'],inv['row_l1_bound']]==[46393,2303032]==[int(x['cancellation_free_signed_row_l1_upper'])for x in g['signed_lift_prefix']] + adds=sum(e[0]==1 for e in new);units=sum(abs(e[3])for e in new if e[0]==1) + assert adds==574392==g['local_scalar_additions']==sum(e[0]==1 for e in old)-440 + bank=load(d/'BANK-REVIEW.json');fs=load(b/'frames.json')['frames'];ranks=Counter() + initial_rank=0 + for s in range(2*v,n): + f=st['initial'][str(s)];end=st['final'][str(s)];di=fs[str(f)]['dim'];df=fs[str(end)]['dim'];assert df==24 + ranks[df-di]+=1;initial_rank+=di + assert ranks=={3:354,4:2182,6:16,7:2,24:13332} and initial_rank==51396 + slots=Counter();nb=0 + for p in bank['bank_patterns']: + assert sum(p['widths'])==120 and p['count']>0 + for rank in p['widths']:slots[rank]+=p['count'] + nb+=p['count'] + assert slots=={r:120*c for r,c in ranks.items()} and nb==bank['banks_per_stage']==329868 + assert bank['actual_role_replica_stage_assignments']==5*sum(slots.values())==9531600 + assert bank['literal_stock']==844800+5*nb==2494140 and bank['normalized_stock']==498828 + assert bank['new_exact_charts']==411 and bank['max_new_chart_factors']==318 and bank['normalizer_factor_ceiling']==983 + assert bank['new_entrance_rank']==bank['endpoint_rank_deficit']==0 + price=load(d/'FIXED-PRICE.json');p=price['profile'];invoice=load(d/'FINITE.json') + H=Counter({r:120*c for r,c in h.items()});H.update({r:48*v for r in(4,23,46,50)}) + assert {int(r):c for r,c in p['histogram'].items()}==dict(H) + assert p['calls']==sum(H.values())==11305080 and p['rank_mass']==sum(r*c for r,c in H.items()) + assert p['stock']==498828 and p['deficit']==105600 + assert Q(price['kappa'])==KAPPA>Q(load(root/'pr285/verification.json')['kappa']) + assert len(price['strict_constraints'])==47 and min(map(Q,price['strict_constraints'].values()))>0 + assert price['ordinary_levels']==8 and price['lucas_lehmer_iterations']==125 and price['lucas_lehmer_residue']=='0' and price['adjacent_rejected_at_finite_and_cap'] + assert int(invoice['full_counted_primitive_coefficient'])==int(price['finite_coefficient_recomputed'])==180164370784684201 + m=120;N=240;stock=bank['literal_stock'];E=5*sum(H.values());routes=120*(24*v+10*(n-2*v)) + selector=1200*((stock-1)+(n-2*v)*120*983) + coefficient=120*(5*units+6*v)+routes*16*(m*m+1)**2+routes*(stock+24)+E*(8*m*m+8)+E*128*N**3+16*m**3+120*120+E+selector+1 + assert selector==bank['selector_charge']==2251688038800 + assert coefficient==int(invoice['full_counted_primitive_coefficient']) + + assert int(invoice['positive_rank_children'])==5*sum(H.values()) + assert int(invoice['global_weighted_additions'])==120*(5*adds+6*v) + assert int(invoice['global_unit_expanded_additions'])==120*(5*units+6*v) + payload=64*fw['row_l1_bound']**3*inv['row_l1_bound']**2 + assert payload==int(g['payload_prefix_upper'])==int(invoice['payload_signed_prefix_upper']) and payload<2**104 + result=dict(status='PASS_INDEPENDENT_GEN5_COMPOSITION_AND_LITERAL_INVOICE',word_sha256=WORD,kappa=str(KAPPA),kappa_decimal=price['kappa_decimal'],retimed_gates=880,target_groups=220,local_additions=adds,normalized_calls=sum(H.values()),forward=fw,inverse=inv,target_omission_controls=controls,bank_assignments=9531600,primitive_coefficient=invoice['full_counted_primitive_coefficient'],payload_bits=payload.bit_length(),scope='Conditional finite construction. All inherited all-size hypotheses remain assumptions.') + (d/'INDEPENDENT.json').write_text(json.dumps(result,indent=2)+'\n');print('PASS independent gen5 composition; kappa = '+price['kappa_decimal']) + +if __name__=='__main__': + ap=argparse.ArgumentParser();ap.add_argument('--replay',type=Path,required=True);a=ap.parse_args();main(a.replay) diff --git a/research/gen5-retiming-targets/code/banks.cpp b/research/gen5-retiming-targets/code/banks.cpp new file mode 100644 index 0000000000..80612d1dfd --- /dev/null +++ b/research/gen5-retiming-targets/code/banks.cpp @@ -0,0 +1,39 @@ +#include +#include +#include +using namespace std;using J=nlohmann::json;using Q=boost::multiprecision::cpp_rational;using Z=boost::multiprecision::cpp_int;using M=vector>; +J ld(string p){ifstream f(p);if(!f)throw runtime_error("missing "+p);J j;f>>j;return j;} +Q rat(J j){return j.is_string()?Q(j.get()):Q(j.get());}M eye(int n){M a(n,vector(n));for(int i=0;i(a.size()));for(int i=0;i(b[0].size()));for(int i=0;i=(Z(1)<<80)||d>=(Z(1)<<80))throw runtime_error("finite prime guard exceeded");} +M inverse(M a,int &ops,Q &det){int n=a.size();M b=eye(n);det=1;ops=0;for(int k=0;kpiv;for(int col=0;colv(n);v[free]=1;for(int i=0;iw;int count;}; +int main(int ac,char**av){if(ac!=6)throw runtime_error("args: baseline_export initial_json new_frames_json output_dir label");string inp=av[1],out=av[4];auto st=ld(inp+"/249-states.json"),fj=ld(inp+"/frames.json")["frames"],ini=ld(av[2]),nf=ld(av[3]);int n=st["n"],v=st["v"],R=n-2*v,baseBanks=0;mapdims;for(auto it=fj.begin();it!=fj.end();it++)dims[stoi(it.key())]=it.value()["dim"];for(auto it=nf.begin();it!=nf.end();it++)dims[stoi(it.key())]=it.value()["dim"]; + +M G=eye(24);for(auto&r:G)for(auto&q:r)q-=Q(1)/9; +J all=fj;for(auto it=nf.begin();it!=nf.end();it++){if(all.contains(it.key()))throw runtime_error("framecollision");all[it.key()]=it.value();} +auto basis=[&](int id){M U;for(auto row:all.at(to_string(id))["B"]){vectorx;for(auto z:row)x.push_back(rat(z));U.push_back(x);}return U;}; +auto zeros=[](){return M(24,vector(24));}; +auto projector=[&](M U){if(U.empty())return zeros();int ops;Q det;auto H=mul(mul(U,G),tr(U));auto HI=inverse(H,ops,det);return mul(mul(tr(U),HI),mul(U,G));}; +J charts=J::array();int maxops=0;set>pairs;int endpointDeficit=0,base3=0,base4=0,base6=0,base7=0,base24=0; +for(int i=2*v;i0||dims.at(h)!=24)pairs.insert({f,h});} +baseBanks=3*base3+4*base4+6*base6+7*base7+24*base24; +for(auto[f,h]:pairs){M U=basis(f),H=basis(h);int d=U.size(),e=H.size(),r=e-d;if(r<=0||e>24)throw runtime_error("endpoint dimensions"); + auto PU=projector(U),PH=projector(H);if(mul(PU,PH)!=PU||mul(PH,PU)!=PU)throw runtime_error("non-nested endpoint projectors"); + M V=H;if(d){auto N=nullspace(mul(mul(U,G),tr(H)));V=mul(N,H);}M K;if(e<24)K=nullspace(mul(H,G));M rows=V;rows.insert(rows.end(),U.begin(),U.end());rows.insert(rows.end(),K.begin(),K.end());if(rows.size()!=24||V.size()!=r)throw runtime_error("complete endpoint chart");M B=tr(rows);int ops;Q det;M inv=inverse(B,ops,det),P=PH;for(int i=0;i<24;i++)for(int j=0;j<24;j++)P[i][j]-=PU[i][j];M target=zeros();for(int i=0;i1024)throw runtime_error("chart budget"); +map>fam,basefam;mapgauge,newfam;int sumdim=0,changed=0;for(int i=0;iexpectedbase{{3,base3},{4,base4},{6,base6},{7,base7},{24,base24-changed}};for(auto[r,k]:expectedbase)if(basefam[r].size()!=k)throw runtime_error("base census mismatch"); +vectorpat;auto add=[&](vectorw,int count){if(count<0||accumulate(w.begin(),w.end(),0)!=120)throw runtime_error("pattern");if(count)pat.push_back({w,count});};auto repeated=[](int r,int n){return vector(n,r);};auto mix=[&](int r,int nr,int four){auto w=repeated(r,nr);w.insert(w.end(),four,4);return w;};// Gen5 target-only port: retain the exact PR285 bank patterns, doubled to 120 replicas. +if(!newfam.empty()||changed||sumdim||endpointDeficit)throw runtime_error("target-only helper endpoints changed"); +if(base3!=354||base4!=2182||base6!=16||base7!=2||base24!=13332)throw runtime_error("gen5 baseline census"); +add(mix(7,12,9),20);add(repeated(4,30),8722);add(repeated(3,40),1062);add(repeated(6,20),96);add(repeated(24,5),319968); +struct Slot{int bank,off,r,block;};map>slots;int banks=0;J pj=J::array();for(auto pp:pat){pj.push_back({{"widths",pp.w},{"count",pp.count}});for(int b=0;b>(8*j))&255;hash*=1099511628211ull;}};long long assignments=0,mass=0,columns=0,controls=0;for(int stage=0;stage<5;stage++){vector>occ(banks);for(auto[r,rows]:fam)for(int i=0;is{};s[col]=1;vector>bl;int o=0;for(int r:pp.w){bl.push_back({o,r});o+=r;}if(rev)reverse(bl.begin(),bl.end());for(auto[o,r]:bl)for(int j=o;js{};s[col]=1;int o=0;for(int b=0;b +#include "json.hpp" +#include +#include +#include +#include +#include +#include +using namespace std;using namespace boost::multiprecision;using J=nlohmann::json;using I=cpp_int;using Q=cpp_rational; +void need(bool x,const char*s){if(!x)throw runtime_error(s);}J load(string p){ifstream f(p);need(bool(f),"missing input");J j;f>>j;return j;} +Q rat(string s){auto p=s.find('/');return p==string::npos?Q(I(s)):Q(I(s.substr(0,p)))/I(s.substr(p+1));}I ceilQ(Q x){return (numerator(x)+denominator(x)-1)/denominator(x);}struct E{int op,a,b,c,f,z;}; +int main(int argc,char**argv){try{need(argc==6,"usage RECORDS ROOT_PRICE BANK_RECEIPT FIVE_STAGE_RECEIPT OUTPUT");ifstream f(argv[1],ios::binary|ios::ate);size_t bytes=f.tellg();need(bytes%sizeof(E)==0,"ABI");vectorev(bytes/sizeof(E));f.seekg(0);f.read((char*)ev.data(),bytes);J price=load(argv[2])["cohort_candidate"],bank=load(argv[3]),global=load(argv[4]);int chartBound=max(744,bank["max_new_chart_factors"].get()), normalizerBound=chartBound+239;need(chartBound<=1024&&bank["normalizer_factor_ceiling"]==normalizerBound,"dynamic normalizer bound");mapH;I adds=0,units=0,copies=0;for(auto e:ev){if(e.op==0&&e.f)H[e.f]++;else if(e.op==1){adds++;units+=abs(e.c);}else if(e.op==2){H[e.z]++;copies++;}}need(copies==24&&adds>0&&units>=adds,"actualword inventory");int m=120,v=1760,R=bank["actual_helper_roles"].get(),T=120,N=2*m,d=m*m,stock=bank["literal_stock"];need(stock==bank["normalized_stock"].get()*5&&bank["actual_role_replica_stage_assignments"]==600LL*R,"actualbanks");need(bank["new_exact_charts"].get()>0&&bank["max_new_chart_factors"]<=chartBound&&I(bank["max_intermediate_denominator"].get())<(I(1)<<80)&&I(bank["max_intermediate_numerator"].get())<(I(1)<<80),"newchart invoice");mapL;for(auto[r,n]:H)L[r]+=600*n;for(int r:{4,23,46,50})L[r]+=120*2*v;I Ecount=0,mass=0;J hh=J::object();for(auto[r,n]:L){Ecount+=n;mass+=r*n;need(r<60,"half-shrink");hh[to_string(r)]=n.convert_to();need(n==5*price["histogram"][to_string(r)].get(),"fullH versusnormalizedprice");}need(m*I(stock)-mass==528000,"physicaldeficit");need(price["stock"].get()*5==stock,"literalstock notnormalized");Q mu=rat(price["moment_upper"]);need(mu<1,"strict moment");Q c=rat(price["coarse"]),deltaTau=1-mu,deltaLin=1-Q(mass)/(m*stock)-Q(32*m)*Ecount/(I("10000000000000000")*stock);need(deltaLin>0,"linear fallback");I Jroute=T*(24*v+10*R),good=8*m*m+8,high=16*I(d+1)*(d+1),K=2*5*T*(I(stock-1)+I(R)*120*normalizerBound),weighted=T*(5*adds+6*v),unit=T*(5*units+6*v);need(K==bank["selector_charge"].get()&&K<(I(1)<<48),"all selector factors");I F=I(global["signed_lift_prefix"][0]["cancellation_free_signed_row_l1_upper"].get()),B=I(global["signed_lift_prefix"][1]["cancellation_free_signed_row_l1_upper"].get()),payload=64*F*F*F*B*B;need(payload<(I(1)<<104),"payload prefix");I coeff=unit+Jroute*high+Jroute*(stock+24)+Ecount*good+Ecount*(128*I(N)*N*N)+16*I(m)*m*m+120*T+Ecount+K+1;need(coeff<(I(1)<<80)&&2*I(m)*m*m*I("10000000000000000")<(I(1)<<80),"fixed coefficient below prime threshold");need(I(stock+24)<(I(1)<<80),"stocklessprime");Q previous=rat("384599/10000000000");J cuts=J::array();for(int stage=0;stage<3;stage++){Q a=(1-c)*c+c*previous;vectorgaps={c-a,1-a-c,1-a-c*(1-previous),1-c};Q gap=*min_element(gaps.begin(),gaps.end());need(gap>0,"ordinary cutoff gap");I L1=ceilQ(36/(gap*gap)),L2=ceilQ(2*(4+msb(coeff)+1)/gap),cut=max(I(1),max(L1,L2));need(Q(cut)*gap*gap>=36&&Q(cut)*gap>=2*(4+msb(coeff)+1),"cutoff inequality");cuts.push_back({{"stage",stage+1},{"minimum_gap",gap.str()},{"counted_coefficient_cutoff_log2",cut.convert_to()},{"general_rule","For full inherited constants C_full>=counted coefficient, replace C by C_full in max(1,ceil(36/delta^2),ceil(2*(4+ceil(log2 C))/delta))."}});previous=a;} +J out={{"status","PASS_COHORT_LITERAL_FIVE_STAGE_FINITE_INVOICE_AND_POSITIVE_CUTOFFS"},{"physical_replicas",T},{"actual_helper_roles",R},{"literal_stock",stock},{"normalized_stock",price["stock"]},{"positive_rank_children",Ecount.convert_to()},{"literal_rank_mass",mass.convert_to()},{"literal_deficit",528000},{"literal_histogram",hh},{"global_weighted_additions",weighted.convert_to()},{"global_unit_expanded_additions",unit.convert_to()},{"route_families",Jroute.convert_to()},{"normalizer_factor_bound",normalizerBound},{"new_chart_factor_max",bank["max_new_chart_factors"]},{"extra_selector_calls",K.convert_to()},{"full_counted_primitive_coefficient",coeff.convert_to()},{"primitive_coefficient_bits",msb(coeff)+1},{"payload_signed_prefix_upper",payload.convert_to()},{"payload_bits",msb(payload)+1},{"internal_row_coefficient",14401},{"external_complex_row_coefficient",20161},{"simultaneous_extra_work_streams",1},{"strict_moment_slack",deltaTau.str()},{"linear_moment_slack",deltaLin.str()},{"ordinary_cutoffs",cuts},{"scope","Sufficient finite invoice for the literal new cohort word, 120 physical replicas and fully admitted bank stock; original 48dim route, retained odd-prime rational address grid, common-ancestor compiler and complex recovery interfaces are inherited unchanged. No Lean or independent certification of those underlying public theorems asserted."}};ofstream(argv[5])< +#include "json.hpp" +#include +#include +#include +#include +#include +#include +using namespace std;using namespace boost::multiprecision;using J=nlohmann::json;using Q=cpp_rational;using I=cpp_int; +Q parse(string s){auto p=s.find('/');return p==string::npos?Q(I(s)):Q(I(s.substr(0,p)))/I(s.substr(p+1));} +Q get(J j){return j.is_string()?parse(j.get()):Q(j.get());} +J load(string p){ifstream f(p);if(!f)throw runtime_error(p);J j;f>>j;return j;} +Q down(Q x){I d=I(1)<<224;return Q(I(numerator(x)*d/denominator(x)))/d;} +Q up(Q x){I d=I(1)<<224;return Q(I((numerator(x)*d+denominator(x)-1)/denominator(x)))/d;} +pair logbase(Q x){Q z=(x-1)/(x+1),t=z,s=0;for(int i=0;i<48;i++){s+=2*t/(2*i+1);t*=z*z;}return {down(s),up(s+2*t/(97*(1-z*z)))};} +pair logbound_raw(Q x){int k=0;while(x>=2){x/=2;k++;}auto [l,u]=logbase(x);auto [a,b]=logbase(Q(2));return {down(l+k*a),up(u+k*b)};} +pair logbound(Q x){static map> cache;auto it=cache.find(x);if(it!=cache.end())return it->second;return cache[x]=logbound_raw(x);} +pair expbound(Q l,Q u){if(l<0||u>=Q(1)/10)throw runtime_error("exp domain");Q tl=1,tu=1,sl=1,su=1;for(int i=1;i<=32;i++){tl=down(tl*l/i);tu=up(tu*u/i);sl=down(sl+tl);su=up(su+tu);}return {sl,up(su+tu*u/33/(1-u/34))};} +pair moment(mapH,int m,int W,Q a){Q lo=0,hi=0;for(auto [r,n]:H){auto[l,u]=logbound(Q(m)/r);auto[e,f]=expbound(a*l,a*u);Q w=Q(r*n)/(m*W);lo+=w*e;hi+=w*f;}return {down(lo),up(hi)};} +map assembly(Q a,Q b,Q k,Q guard,Q rowgap){Q eta=Q(1)/parse("1000000000000000000000000"),beta=Q(1)/parse("1000000000"),tau=1-a,sigma=1-b,q=a*(1-2*eta),lp=1-q,lam=(tau+lp)/2,c=q+eta/4,eps=(1-eta)/(1+q),mi=eps*q,r=(mi+1-eps)/2,delta=eta/8,internal=tau+(1-beta)*max(Q(sigma-tau),Q(0)),leaf=sigma+beta*(1-sigma);maps={ +{"bit_positive",a},{"complex_above_bit",b-a},{"complex_below_1_32",Q(1)/32-b},{"beta_positive",beta},{"beta_below_one",1-beta},{"leaf_above_bit",(1-beta)*b-a}, +{"q_positive",q},{"q_below_internal",1-internal-q},{"q_below_leaf",1-leaf-q},{"c_positive",c},{"c_below_one",1-c},{"reservations",c-q},{"lambda_tau",lam-tau},{"lambda_sigma",lam-sigma},{"lambda_internal",lam-internal},{"lp_lambda",lp-lam},{"compact_leaf",lp-leaf},{"compact_reservations",lp-(1-c)},{"lp_below_one",q}, +{"eps_positive",eps},{"eps_below_one",1-eps},{"guard_width",1-eps},{"K_geometry",1-eps*(1+c)},{"K_log",eps*c},{"record_suffix",1-eps},{"phase_local",1-eps-delta},{"phase_boundary",r-delta},{"gamma_sublinear",1-eps-r},{"cell_band",eps-(1-r)/2},{"prime_pack",1-eps},{"alpha_positive",r},{"alpha_one",1-r},{"alpha_fourth",Q(1)/4-r},{"delta_positive",delta},{"delta_eighth",Q(1)/8-delta},{"record_fallback",eps-a},{"small_field",1-eps-mi},{"artificial",8-eps+r-delta-mi},{"literal_guard",guard},{"row_gap",rowgap}}; +vector margins={1-eps,a,mi,a,min(Q(1-eps-delta),Q(r-delta)),1-eps-delta,eps};for(int i=0;i<7;i++)s["margin"+to_string(i)]=margins[i]-k;return s;} + +// Native port of PR261 fixed_prime_math.py; physical input is supplied, not assumed proved here. +using D=cpp_dec_float_100; +void need(bool b,string s){if(!b)throw runtime_error(s);} +I integer(J x){return x.is_string()?I(x.get()):I(x.get());} +I ceilq(Q x){need(x>=0,"ceil domain");return I((numerator(x)+denominator(x)-1)/denominator(x));} +const I prime=(I(1)<<127)-1,grid("1000000000000000000000000000"); +const Q rho=Q(3456000)/prime,eta=Q(1)/I("1000000000000000000000000"); +Q floor30(Q x){I g("1000000000000000000000000000000");return Q(I(numerator(x)*g/denominator(x)))/g;} +Q ceil30(Q x){I g("1000000000000000000000000000000");return Q(ceilq(x*g))/g;} +pair log2engine(Q x){static map>cache;if(cache.count(x))return cache[x];Q original=x;int k=0;while(x>2){x/=2;k++;}auto unit=[](Q x){Q z=(x-1)/(x+1),t=z,s=0;for(int j=0;j<80;j++){s+=2*t/(2*j+1);t*=z*z;}return pair{s,s+2*t/(161*(1-z*z))};};auto[a,b]=unit(x);auto[c,d]=unit(2);return cache[original]={floor30(a+k*c),ceil30(b+k*d)};} +pair exp2engine(Q x){need(x>=0&&x<1,"second exp domain");Q t=1,s=1;for(int j=1;j<=12;j++){t*=x/j;s+=t;}return{s,s+t*x/13/(1-x/14)};} +pair fixedmoment(mapH,int W,Q c,int engine){long long count=0;for(auto[r,n]:H)count+=n;if(engine==1){auto[a,b]=moment(H,120,W,c);auto[l,u]=logbound(120);auto[e,f]=expbound(c*l,c*u);Q fallback=Q(3840*count)/W*rho;return{down(a+fallback*e),up(b+fallback*f)};}Q a=0,b=0;for(auto[r,n]:H){auto[l,u]=log2engine(Q(120)/r);a+=Q(r*n)/(120*W)*exp2engine(c*l).first;b+=Q(r*n)/(120*W)*exp2engine(c*u).second;}auto[l,u]=log2engine(120);Q fallback=Q(3840*count)/W*rho;return{floor30(a)+fallback*exp2engine(c*l).first,ceil30(b)+fallback*exp2engine(c*u).second};} +Q kap(Q a){Q q=a*(1-2*eta),v=(1-eta)*q/(1+q);return Q(I((numerator(v)*grid-1)/denominator(v)))/grid;} +J sj(map x){J j=J::object();for(auto[k,v]:x)j[k]=v.str();return j;} +int main(int argc,char**argv){try{ + need(argc==4,"usage: fixed-price PRICE_JSON FINITE_INVOICE_JSON OUTPUT_JSON");J raw=load(argv[1]),invoice=load(argv[2]),profile=raw.contains("cohort_candidate")?raw["cohort_candidate"]:raw; + I ll=4;for(int k=0;k<125;k++)ll=(ll*ll-2)%prime;need(ll==0,"Lucas Lehmer");for(int p=2;p*p<=127;p++)need(127%p!=0,"exponent primality");need(rho(I(1)<<80),"prime bounds"); + mapH;long long count=0,mass=0;int W=profile["stock"].get();need(W>0,"positive stock");for(auto it=profile["histogram"].begin();it!=profile["histogram"].end();it++){int r=stoi(it.key());long long n=integer(it.value()).convert_to();need(r>0&&r<60&&n>0,"half shrink children");H[r]=n;count+=n;mass+=r*n;} + need(integer(profile["calls"])==count&&integer(profile["rank_mass"])==mass&&integer(profile["deficit"])==120LL*W-mass,"profile inventory"); + // High precision floating only proposes a point; both exact engines must separate it. + vector>terms;for(auto[r,n]:H)terms.push_back({D(r*n)/D(120LL*W),log(D(120)/D(r))});D fall=D(3840*count)/W*D(3456000)/D(prime.convert_to()),l=0,u=D(".003");for(int i=0;i<240;i++){D c=(l+u)/2,v=fall*exp(c*log(D(120)));for(auto[t,z]:terms)v+=t*exp(c*z);if(v<1)l=c;else u=c;} + I ticks=(l*D(grid.convert_to())).convert_to();Q c=Q(ticks)/grid,next=c+Q(1)/grid;J bounds=J::array();Q momentupper; + for(int engine:{1,2}){auto[a,b]=fixedmoment(H,W,c,engine);auto[d,e]=fixedmoment(H,W,next,engine);need(b<1&&d>1,"exact coarse adjacent bracket");bounds.push_back({{"engine",engine},{"lower",a.str()},{"upper",b.str()},{"next_lower",d.str()},{"next_upper",e.str()}});if(engine==1)momentupper=b;} + I replicas=integer(invoice["physical_replicas"]);need(replicas>0&&replicas%40==0,"replica multiple of 40"); I stock=integer(invoice["literal_stock"]),calls=0,lmass=0;need(stock==5*W&&integer(invoice["normalized_stock"])==W,"literal stock");need(invoice["literal_histogram"].size()==H.size(),"literal histogram size");for(auto[r,n]:H){I nn=integer(invoice["literal_histogram"].at(to_string(r)));need(nn==5*n,"literal histogram");calls+=nn;lmass+=r*nn;} + need(lmass==integer(invoice["literal_rank_mass"])&&integer(invoice["literal_deficit"])==120*stock-lmass&&calls==integer(invoice["positive_rank_children"]),"literal ledger"); + I chartBound=max(I(744),integer(invoice["new_chart_factor_max"])),normalizerBound=chartBound+239; need(chartBound<=1024,"bounded exact chart arithmetic"); I coeff=integer(invoice["full_counted_primitive_coefficient"]),units=integer(invoice["global_unit_expanded_additions"]),routes=integer(invoice["route_families"]),selectors=integer(invoice["extra_selector_calls"]); + need(units>=integer(invoice["global_weighted_additions"])&&integer(invoice["global_weighted_additions"])>0,"positive operation costs"); need(integer(invoice["new_chart_factor_max"])>0&&integer(invoice["payload_signed_prefix_upper"])>0,"positive chart payload bounds"); need(selectors==10*replicas*((stock-1)+integer(invoice["actual_helper_roles"])*120*normalizerBound),"selector bill");need(routes==replicas*(24*1760+10*integer(invoice["actual_helper_roles"])),"route bill"); + I computed=units+routes*16*14401*14401+routes*(stock+24)+calls*(8*120*120+8)+calls*(128*I(240)*240*240)+16*I(120)*120*120+120*replicas+calls+selectors+1; + need(coeff==computed&&coeff<(I(1)<<80)&&stock gaps={{"atom",c-bit},{"borrowing",1-bit-c},{"remainder",1-bit-c*(1-old)},{"stock",1-c}};Q delta=1;for(auto[k,v]:gaps){need(v>0,"finite positive gaps");delta=min(delta,v);}int logcoeff=msb(coeff-1)+1;I cut=max(I(1),max(ceilq(36/(delta*delta)),ceilq(2*(4+logcoeff)/delta)));need(Q(cut)*delta*delta>=36&&Q(cut)*delta>=2*(4+logcoeff),"finite cutoff");stages.push_back({{"level",++levels},{"gaps",sj(gaps)},{"minimum_gap",delta.str()},{"log2_cutoff",cut.convert_to()}});chain.push_back(bit.str());if(kap(bit)==cap)break;need(levels<20,"finite levels failed");} + auto constraints=assembly(bit,parse("747454944651775/1000000000000000000"),cap,1,Q(1000000)-Q(51*20161)/25);need(constraints.size()==47,"47 constraints");for(auto[k,v]:constraints)need(v>0,"constraint "+k);J rejects=J::array();for(Q a:{bit,c}){auto test=assembly(a,parse("747454944651775/1000000000000000000"),cap+Q(1)/grid,1,Q(1000000)-Q(51*20161)/25);J bad=J::array();for(auto[k,v]:test)if(v<=0)bad.push_back(k);need(!bad.empty(),"adjacent kappa");rejects.push_back(bad);} + Q linear=1-Q(mass)/(120*W)-rho*Q(3840*count)/W;need(linear>0&&momentupper<1,"moment admission");J margins=J::object();for(int i=0;i<7;i++)margins[to_string(i)]=Q(constraints["margin"+to_string(i)]+cap).str(); + J out={{"status","PASS_NATIVE_FIXED_PRIME_FINITE_AND_47_CONSTRAINTS"},{"scope","Conditional arithmetic on supplied physical inventory; counts and inherited all-size, compiler, common chart, restored-row, routing, precision/recovery and complex-reduction interfaces require their separate evidence."},{"prime",prime.convert_to()},{"lucas_lehmer_iterations",125},{"lucas_lehmer_residue",ll.convert_to()},{"rho",rho.str()},{"profile",profile},{"coarse",c.str()},{"coarse_bounds",bounds},{"ordinary_levels",levels},{"ordinary_chain",chain},{"finite_levels",stages},{"ordinary_bit",bit.str()},{"kappa",cap.str()},{"kappa_decimal",cap.convert_to().str(40,std::ios_base::fixed)},{"strict_constraints",sj(constraints)},{"seven_margins",margins},{"adjacent_rejected_at_finite_and_cap",rejects},{"finite_invoice_retained",invoice},{"finite_coefficient_recomputed",computed.convert_to()},{"linear_moment_slack",linear.str()},{"strict_moment_slack",Q(1-momentupper).str()},{"method","Native C++ exact rationals: independent 48-term/32-degree binary224 and 80-term/12-degree decimal30 engines; decimal100 only proposes exact checked coarse point."},{"finite_cutoff_scope","Computed coefficient is the full counted finite invoice. For inherited all-size C_full >= this coefficient, replace ceil(log2 C) with ceil(log2 C_full) in the displayed cutoff formula."}}; + ofstream(argv[3])< +#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==4,"usage RAW6_RECORDS STATES_JSON OUTPUT");std::string pre=argv[1];J states;std::ifstream(argv[2])>>states;int v=states["v"],r=states["n"].get()-2*v,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[3])< +#include +#include +using namespace std;using nlohmann::json;struct Ev{int k,a,b,c,f,z;};struct F{int d;vector>B,A;};json ld(string p){json j;ifstream(p)>>j;return j;}int main(int ac,char**av){if(ac!=4)return 2;string in=av[1],out=av[2];auto st=ld(in+"/249-states.json"),fj=ld(in+"/frames.json"),nf=ld(out+"/COHORT249-FRAMES.json"),ii=ld(out+"/COHORT249-INITIAL.json"),sel=ld(out+"/COHORT249-SELECTION.json"),own=ld(in+"/249-DONOR-OWNERSHIP.json");int n=st["n"],v=st["v"],zero=st["ZERO"];mapfs;long long maxabs=0;int oldmax=0;for(auto it=fj["frames"].begin();it!=fj["frames"].end();++it){int k=stoi(it.key());oldmax=max(oldmax,k);F f{it.value()["dim"],it.value()["B"],it.value()["A"]};for(auto M:{f.B,f.A})for(auto r:M)for(auto x:r)maxabs=max(maxabs,llabs(x));fs[k]=f;}for(auto it=nf.begin();it!=nf.end();++it){int k=stoi(it.key());if(fs.count(k))throw runtime_error("new frame collides");fs[k]={it.value()["dim"],it.value()["B"],it.value()["A"]};}map,bool>cache;long long contain=0;auto sub=[&](int a,int b){if(!fs.count(a)||!fs.count(b))throw runtime_error("unknown frame");auto k=make_pair(a,b);if(cache.count(k))return cache[k];contain++;bool ok=fs[a].d<=fs[b].d;for(auto r:fs[a].B)for(auto s:fs[b].A){boost::multiprecision::cpp_int d=0;for(int i=0;i<24;i++)d+=boost::multiprecision::cpp_int(r[i])*s[i];if(d)ok=false;}return cache[k]=ok;};setowners,donors,chosen;for(auto x:st["source_owned_roles"])owners.insert(x.get());for(auto x:own["donor_keys"])donors.insert(x.get());setpivots,partners;for(auto s:sel){int p=s["a"];if(!pivots.insert(p).second)throw runtime_error("repeated pivot");for(int r:s["partners"])partners.insert(r);}for(int p:pivots)if(partners.count(p))throw runtime_error("basis support is not square zero");for(auto s:sel){vectormembers=s["partners"].get>();members.push_back(s["a"]);for(int p:members){if(p<2*v||p>=n)throw runtime_error("invalid or overlapping helper");chosen.insert(p);int role=st["regs"][p-2*v];if(owners.count(role)||donors.count(role))throw runtime_error("source owner or donor selected");}int id=s["new_frame_id"];auto f=fs.at(id);if(f.d!=s["E_dimension"]||f.B.size()!=f.d||f.A.size()!=24-f.d)throw runtime_error("wrong new rank");for(auto r:f.A)for(auto b:f.B){boost::multiprecision::cpp_int d=0;for(int k=0;k<24;k++)d+=boost::multiprecision::cpp_int(r[k])*b[k];if(d)throw runtime_error("new ann mismatch");}} +vectorstate(n+1,zero);for(auto it=ii.begin();it!=ii.end();++it)state[stoi(it.key())]=it.value();bool copied=false;int copySource=-1;long long mov=0,adds=0,cop=0,era=0,mass=0;maphist;Ev e;ifstream f(out+"/COHORT249-RECORDS.bin",ios::binary);long long records=0;while(f.read((char*)&e,sizeof e)){records++;if(e.a<0||e.a>n||(e.k!=0&&(e.b<0||e.b>n)))throw runtime_error("bad role id");if(e.k==0){if(e.a==n&&!copied)throw runtime_error("move inactive temporary");if(state[e.a]!=e.b||!sub(e.b,e.c)||fs[e.c].d-fs[e.b].d!=e.f)throw runtime_error("illegal or mispriced MOVE");state[e.a]=e.c;if(e.f){hist[e.f]++;mass+=e.f;}mov++;}else if(e.k==1){if(state[e.a]!=e.f||state[e.b]!=e.f)throw runtime_error("ADD not in common frame");if((e.a==n||e.b==n)&&!copied)throw runtime_error("ADD inactive temporary");if(e.a==e.b)throw runtime_error("self ADD");if(copied&&(e.a==copySource||e.a==n))throw runtime_error("copied source or temporary mutated inside COPY window");adds++;}else if(e.k==2){if(copied||e.b!=n||state[e.a]!=e.c)throw runtime_error("invalid COPY lifecycle");if(e.z!=fs[e.c].d)throw runtime_error("COPY rank");copied=true;copySource=e.a;state[n]=e.f;hist[e.z]++;mass+=e.z;cop++;}else if(e.k==3){if(!copied||e.b!=n||e.a!=copySource||state[e.a]!=e.c||state[n]!=e.f)throw runtime_error("invalid ERASE lifecycle");copied=false;era++;}else throw runtime_error("unknown event");}if(copied||cop!=24||era!=24)throw runtime_error("unclosed COPY");for(int s=0;s +#include "json.hpp" +#include +#include +#include +#include +#include +using namespace std;using namespace boost::multiprecision;using J=nlohmann::json;using Q=cpp_rational;using I=cpp_int; +Q parse(string s){auto p=s.find('/');return p==string::npos?Q(I(s)):Q(I(s.substr(0,p)))/I(s.substr(p+1));} +Q get(J j){return j.is_string()?parse(j.get()):Q(j.get());} +J load(string p){ifstream f(p);if(!f)throw runtime_error(p);J j;f>>j;return j;} +Q down(Q x){I d=I(1)<<224;return Q(I(numerator(x)*d/denominator(x)))/d;} +Q up(Q x){I d=I(1)<<224;return Q(I((numerator(x)*d+denominator(x)-1)/denominator(x)))/d;} +pair logbase(Q x){Q z=(x-1)/(x+1),t=z,s=0;for(int i=0;i<48;i++){s+=2*t/(2*i+1);t*=z*z;}return {down(s),up(s+2*t/(97*(1-z*z)))};} +pair logbound_raw(Q x){int k=0;while(x>=2){x/=2;k++;}auto [l,u]=logbase(x);auto [a,b]=logbase(Q(2));return {down(l+k*a),up(u+k*b)};} +pair logbound(Q x){static map> cache;auto it=cache.find(x);if(it!=cache.end())return it->second;return cache[x]=logbound_raw(x);} +pair expbound(Q l,Q u){if(l<0||u>=Q(1)/10)throw runtime_error("exp domain");Q tl=1,tu=1,sl=1,su=1;for(int i=1;i<=32;i++){tl=down(tl*l/i);tu=up(tu*u/i);sl=down(sl+tl);su=up(su+tu);}return {sl,up(su+tu*u/33/(1-u/34))};} +pair moment(mapH,int m,int W,Q a){Q lo=0,hi=0;for(auto [r,n]:H){auto[l,u]=logbound(Q(m)/r);auto[e,f]=expbound(a*l,a*u);Q w=Q(r*n)/(m*W);lo+=w*e;hi+=w*f;}return {down(lo),up(hi)};} +map assembly(Q a,Q b,Q k,Q guard,Q rowgap){Q eta=Q(1)/parse("1000000000000"),beta=Q(1)/parse("1000000000"),tau=1-a,sigma=1-b,q=a*(1-2*eta),lp=1-q,lam=(tau+lp)/2,c=q+eta/4,eps=(1-eta)/(1+q),mi=eps*q,r=(mi+1-eps)/2,delta=eta/8,internal=tau+(1-beta)*max(Q(sigma-tau),Q(0)),leaf=sigma+beta*(1-sigma);maps={ +{"bit_positive",a},{"complex_above_bit",b-a},{"complex_below_1_32",Q(1)/32-b},{"beta_positive",beta},{"beta_below_one",1-beta},{"leaf_above_bit",(1-beta)*b-a}, +{"q_positive",q},{"q_below_internal",1-internal-q},{"q_below_leaf",1-leaf-q},{"c_positive",c},{"c_below_one",1-c},{"reservations",c-q},{"lambda_tau",lam-tau},{"lambda_sigma",lam-sigma},{"lambda_internal",lam-internal},{"lp_lambda",lp-lam},{"compact_leaf",lp-leaf},{"compact_reservations",lp-(1-c)},{"lp_below_one",q}, +{"eps_positive",eps},{"eps_below_one",1-eps},{"guard_width",1-eps},{"K_geometry",1-eps*(1+c)},{"K_log",eps*c},{"record_suffix",1-eps},{"phase_local",1-eps-delta},{"phase_boundary",r-delta},{"gamma_sublinear",1-eps-r},{"cell_band",eps-(1-r)/2},{"prime_pack",1-eps},{"alpha_positive",r},{"alpha_one",1-r},{"alpha_fourth",Q(1)/4-r},{"delta_positive",delta},{"delta_eighth",Q(1)/8-delta},{"record_fallback",eps-a},{"small_field",1-eps-mi},{"artificial",8-eps+r-delta-mi},{"literal_guard",guard},{"row_gap",rowgap}}; +vector margins={1-eps,a,mi,a,min(Q(1-eps-delta),Q(r-delta)),1-eps-delta,eps};for(int i=0;i<7;i++)s["margin"+to_string(i)]=margins[i]-k;return s;} + +pair momentbad(mapH,int m,int W,Q a){auto[l,u]=moment(H,m,W,a);long long N=0;for(auto[r,n]:H)N+=n;auto[fl,fu]=moment({{1,32LL*m*m*N}},m,W,a);return{l+fl/parse("10000000000000000"),u+fu/parse("10000000000000000")};} +J price(mapH,int W){long double l=.0007L,u=.001L;auto app=[&](long double a){long double z=0,N=0;for(auto[r,n]:H){z+=(long double)n/W*pow((long double)r/120,1-a);N+=n;}return z+1e-16L*32*120*120*N/W*pow(1.L/120,1-a);};for(int i=0;i<80;i++){long double a=(l+u)/2;if(app(a)<1)l=a;else u=a;}long long proposal=(long long)(l*1e18L),low=proposal-10000,high=proposal+10000;Q grid=parse("1000000000000000000");if(momentbad(H,120,W,Q(low)/grid).second>=1||momentbad(H,120,W,Q(high)/grid).first<=1)throw runtime_error("proposal bracket");while(high-low>1){long long z=low+(high-low)/2;auto[a,b]=momentbad(H,120,W,Q(z)/grid);if(b<1)low=z;else if(a>1)high=z;else throw runtime_error("insufficient interval precision");}Q c=Q(low)/grid;auto[ml,mu]=momentbad(H,120,W,c);auto[nl,nu]=momentbad(H,120,W,c+1/grid);if(!(mu<1&&nl>1))throw runtime_error("coarse grid");Q bit=parse("384599/10000000000");J chain=J::array({bit.str()});for(int i=0;i<3;i++){bit=(1-c)*c+c*bit;chain.push_back(bit.str());}Q b=parse("747454944651775/1000000000000000000"),eta=parse("1/1000000000000"),q=bit*(1-2*eta),bound=(1-eta)*q/(1+q);I z=(numerator(bound)*I("1000000000000000000")-1)/denominator(bound);Q k=Q(z)/grid;auto constraints=assembly(bit,b,k,1,Q(1000000)-Q(51*20161)/25),adj=assembly(bit,b,k+1/grid,1,Q(1000000)-Q(51*20161)/25);int pass=0,fail=0;for(auto[name,x]:constraints)pass+=x>0;for(auto[name,x]:adj)fail+=x<=0;if(pass!=47||!fail)throw runtime_error("assembly");long long mass=0,count=0;J h=J::object();for(auto[r,n]:H){mass+=r*n;count+=n;h[to_string(r)]=n;}return{{"stock",W},{"histogram",h},{"rank_mass",mass},{"calls",count},{"deficit",120LL*W-mass},{"coarse",c.str()},{"coarse_decimal",c.convert_to()},{"moment_upper",mu.str()},{"next_coarse_moment_lower",nl.str()},{"bootstrap_chain",chain},{"ordinary_bit",bit.str()},{"kappa",k.str()},{"kappa_decimal",k.convert_to()},{"positive_constraints",pass},{"next_kappa_rejected",fail}};} +int main(int argc,char**argv){if(argc!=4)throw runtime_error("args RECORDS_RECEIPT BANK_RECEIPT OUTPUT");auto rec=load(argv[1]),bank=load(argv[2]);mapH;for(auto it=rec["histogram"].begin();it!=rec["histogram"].end();it++)H[stoi(it.key())]=120*it.value().get();for(int r:{4,23,46,50})H[r]+=48*1760;auto old=H;for(auto it=rec["delta"].begin();it!=rec["delta"].end();it++)old[stoi(it.key())]-=120*it.value().get();int W=bank["normalized_stock"],R=bank["actual_helper_roles"],S=rec["new_entrance_rank"];int endpoint=bank.value("endpoint_rank_deficit",0);if(W!=117564+24*R-endpoint-S)throw runtime_error("stock binding");J baseline=price(old,W+S+endpoint),candidate=price(H,W);if(baseline["deficit"]!=105600||candidate["deficit"]!=105600)throw runtime_error("fixed deficit");J out={{"status","PASS_EXACT_SOURCE_BOUND_CONDITIONAL_PRICING_47_AND_ADJACENT_CONTROLS"},{"baseline",baseline},{"cohort_candidate",candidate},{"bank_completion_required",true},{"finite_bill_and_all_size_interfaces_not_reproved",true}};ofstream(argv[3])< +#include +#include +using namespace std;using J=nlohmann::json;using Q=boost::multiprecision::cpp_rational;using Z=boost::multiprecision::cpp_int;using M=vector>; +J ld(string p){ifstream f(p);if(!f)throw runtime_error("missing "+p);J j;f>>j;return j;} +Q rat(J j){return j.is_string()?Q(j.get()):Q(j.get());}M eye(int n){M a(n,vector(n));for(int i=0;i(a.size()));for(int i=0;i(b[0].size()));for(int i=0;i=(Z(1)<<80)||d>=(Z(1)<<80))throw runtime_error("finite prime guard exceeded");} +M inverse(M a,int &ops,Q &det){int n=a.size();M b=eye(n);det=1;ops=0;for(int k=0;kpiv;for(int col=0;colv(n);v[free]=1;for(int i=0;iw;int count;}; +int main(int ac,char**av){if(ac!=6)throw runtime_error("args: baseline_export initial_json new_frames_json output_dir label");string inp=av[1],out=av[4];auto st=ld(inp+"/249-states.json"),fj=ld(inp+"/frames.json")["frames"],ini=ld(av[2]),nf=ld(av[3]);int n=st["n"],v=st["v"];mapdims;for(auto it=fj.begin();it!=fj.end();it++)dims[stoi(it.key())]=it.value()["dim"];for(auto it=nf.begin();it!=nf.end();it++)dims[stoi(it.key())]=it.value()["dim"]; +M G=eye(24);for(auto&r:G)for(auto&q:r)q-=Q(1)/9;J charts=J::array();int maxops=0;for(auto it=nf.begin();it!=nf.end();it++){int d=it.value()["dim"];M U;for(auto row:it.value()["B"]){vectorr;for(auto x:row)r.push_back(rat(x));U.push_back(r);}if(U.size()!=d)throw runtime_error("dim");auto UG=mul(U,G);auto V=nullspace(UG);M B=tr(V);for(int i=0;i<24;i++)for(int j=0;j1024)throw runtime_error("expanded exact chart budget exceeded"); +map>fam,basefam;mapgauge,newfam;int sumdim=0,changed=0;for(int i=0;iexpectedbase{{4,2200},{6,22},{7,5},{11,48},{12,23},{15,2},{24,14287-changed}};for(auto[r,k]:expectedbase)if(basefam[r].size()!=k)throw runtime_error("base census mismatch"); +vectorpat;auto add=[&](vectorw,int count){if(count<0||accumulate(w.begin(),w.end(),0)!=120)throw runtime_error("pattern");if(count)pat.push_back({w,count});};auto repeated=[](int r,int n){return vector(n,r);};auto mix=[&](int r,int nr,int four){auto w=repeated(r,nr);w.insert(w.end(),four,4);return w;};add(mix(11,8,8),720);add(mix(7,4,23),150);add(repeated(6,20),132);add(repeated(12,10),276);add(repeated(15,8),30);int fill4=0;for(auto[r,k]:newfam){if(r<4||r>24)throw runtime_error("unsupported residual rank");fill4+=30*k*(30-r);add(mix(r,4,30-r),30*k);}if((254790-fill4)%30)throw runtime_error("rank4 remainder");add(repeated(4,30),(254790-fill4)/30);add(repeated(24,5),24*(14287-changed)); +struct Slot{int bank,off,r,block;};map>slots;int banks=0;J pj=J::array();for(auto pp:pat){pj.push_back({{"widths",pp.w},{"count",pp.count}});for(int b=0;b>(8*j))&255;hash*=1099511628211ull;}};long long assignments=0,mass=0,columns=0,controls=0;for(int stage=0;stage<5;stage++){vector>occ(banks);for(auto[r,rows]:fam)for(int i=0;is{};s[col]=1;vector>bl;int o=0;for(int r:pp.w){bl.push_back({o,r});o+=r;}if(rev)reverse(bl.begin(),bl.end());for(auto[o,r]:bl)for(int j=o;js{};s[col]=1;int o=0;for(int b=0;bv;for(auto x:r)v.push_back(rat(x));a.push_back(v);}return a;}vectorloadword(string p){ifstream f(p,ios::binary);if(!f)throw runtime_error("missingword");vectorw;Ev e;while(f.read((char*)&e,sizeof e))w.push_back(e);return w;}void need(bool b,string s){if(!b)throw runtime_error(s);} +int main(int ac,char**av){string base=av[1],lead=av[2],out=av[4];filesystem::create_directories(out);auto st=ld(base+"/249-states.json"),fs=ld(base+"/frames.json")["frames"],nf=ld(lead+"/COHORT249-FRAMES.json"),ini=ld(lead+"/COHORT249-INITIAL.json"),sel=ld(av[3]);for(auto it=nf.begin();it!=nf.end();it++){need(!fs.contains(it.key()),"framecollision");fs[it.key()]=it.value();}int n=st["n"],v=st["v"];auto w=loadword(lead+"/COHORT249-RECORDS.bin");mapbybasis;mapdims;for(auto it=fs.begin();it!=fs.end();it++){int id=stoi(it.key());bybasis.emplace(it.value()["B"].dump(),id);dims[id]=it.value()["dim"];}map,vector>matches;for(int i=0;i<(int)w.size();i++){auto e=w[i];if(e.k==1)matches[{e.a,e.b,e.c,e.z,e.f}].push_back(i);}mapchosen;J bindings=J::array(),rejected=J::array();setnewframeids;for(auto z:sel["entries"]){auto sc=z["scalar"].get>();need(sc[0]key={sc[0],sc[1],sc[2],sc[3],old};if(matches[key].size()!=1){rejected.push_back({{"pinned_record",z["record"]},{"reason","notuniquematch"},{"matches",matches[key].size()}});continue;}auto it=bybasis.find(z["new_basis"].dump());need(it!=bybasis.end(),"newbasisnotexisting");int f=it->second,at=matches[key][0];need(dims[f]==z["new_dimension"]&&dims[old]==z["old_dimension"],"dimension");need(chosen.emplace(at,f).second,"duplicategate");bindings.push_back({{"pinned_record",z["record"]},{"actual_record",at},{"scalar",sc},{"old_frame",old},{"new_frame",f},{"old_basis_sha256",z["old_basis_sha256"]}});newframeids.insert(f);}need(!chosen.empty(),"nomoves"); +// Exact rational nondegeneracy of every replacement frame. Existing source basis rows are verified against exported covectors. +M G=eye(24);for(auto &row:G)for(auto&q:row)q-=Q(1)/9;for(int f:newframeids){M B=parse(fs[to_string(f)]["B"]);need(B.size()==dims[f],"dimrows");int ops;Q det;M H=mul(mul(B,G),tr(B));inverse(H,ops,det);admit(det);}vector>chi(v);for(int s=0;s();need(3*x-1==st["source_covectors"][s][j].get(),"chicovectorbinding");chi[s].push_back(x);}}auto inspan=[&](int s,int f){for(auto a:fs[to_string(f)]["A"]){Z q=0;for(int j=0;j<24;j++)q+=Z(a[j].get())*chi[s][j];if(q!=0)return false;}return true;};vector>cols(n+1);for(int i=0;isources;for(auto[s,x]:cols[e.a])sources.insert(s);for(auto[s,x]:cols[e.b])sources.insert(s);for(int s:sources){need(sstate(n+1,st["ZERO"]);for(auto it=ini.begin();it!=ini.end();it++)state[stoi(it.key())]=it.value();map,bool>contained;auto sub=[&](int a,int b){auto key=make_pair(a,b);if(contained.count(key))return contained[key];bool ok=dims[a]<=dims[b];for(auto x:fs[to_string(a)]["B"])for(auto y:fs[to_string(b)]["A"]){Z z=0;for(int j=0;j<24;j++)z+=Z(x[j].get())*y[j].get();if(z!=0)ok=false;}return contained[key]=ok;};vectorword;auto move=[&](int a,int f){int old=state[a];if(old==f)return;need(sub(old,f),"newchronologynonnested");word.push_back({0,a,old,f,dims[f]-dims[old],0});state[a]=f;};copied=false;int copies=0;for(int i=0;i<(int)w.size();i++){auto e=w[i];if(!e.k)continue;if(e.k==1){if(chosen.count(i))e.f=chosen[i];move(e.a,e.f);if(e.b==n)need(copied&&state[n]==e.f,"tempframe");else move(e.b,e.f);}else if(e.k==2){need(!copied,"copyopen");move(e.a,e.c);state[n]=e.f;copySource=e.a;copied=true;copies++;}else if(e.k==3){need(copied&&e.a==copySource&&state[e.a]==e.c&&state[n]==e.f,"copyendpoint");copied=false;}word.push_back(e);}need(!copied&&copies==24,"copycount");for(int i=0;i>a,b;auto projection=[](const vector&w){vector>p;for(auto e:w)if(e.k)p.push_back({e.k,e.a,e.b,e.c,e.z});return p;};need(projection(w)==projection(word),"scalar-copy-projection-changed");auto hist=[](const vector&w){maph;for(auto e:w)if(e.k==0&&e.f)h[e.f]++;else if(e.k==2)h[e.z]++;return h;};auto oldH=hist(w),newH=hist(word);J h=J::object(),delta=J::object();long long oldmass=0,mass=0,oldcalls=0,calls=0;setranks;for(auto[r,c]:oldH){oldmass+=r*c;oldcalls+=c;ranks.insert(r);}for(auto[r,c]:newH){mass+=r*c;calls+=c;ranks.insert(r);h[to_string(r)]=c;}for(int r:ranks)if(newH[r]!=oldH[r])delta[to_string(r)]=newH[r]-oldH[r];need(mass==oldmass,"rankmass");if(chosen.size()==880)need(delta==sel["expected_local_histogram_delta"],"publishedhistogramdelta");auto rep=ld(lead+"/COHORT249-REPLAY.json");rep["histogram"]=h;for(auto it=delta.begin();it!=delta.end();it++)rep["delta"][it.key()]=rep["delta"].value(it.key(),0LL)+it.value().get();rep["new_records"]=word.size();rep["new_rank_mass"]=mass;rep["retimed_279_gates"]=chosen.size();J receipt={{"status","PASS_PR279_REBOUND_EXACT_SIGNED_SOURCE_SPANS_AND_GEOMETRY"},{"selected_gates",chosen.size()},{"rejected",rejected},{"actual_n",n},{"old_rank_mass",oldmass},{"new_rank_mass",mass},{"old_calls",oldcalls},{"new_calls",calls},{"removed_calls",oldcalls-calls},{"histogram_delta",delta},{"bindings",bindings},{"signed_source_spans",spans},{"checked_source_indices",checkedSources},{"undersized_frame_controls_rejected",negativeControls},{"exact_gram_checks",newframeids.size()},{"max_gram_numerator",maxnum.str()},{"max_gram_denominator",maxden.str()},{"identical_scalar_and_copy_projection",true},{"chronological_containment_pairs",contained.size()},{"all_dirty_initial_inputs_replayed",n},{"selected_gates_contain_only_original_source_inputs",true},{"unchanged_endpoints",true},{"copy_windows",copies},{"scope","Fresh exact integer source-span replay on input word; rational Gram and bigint actual nesting; full global/bank/final price separate"}};ofstream(out+"/RETIMING279.json")<known;for(auto it=fs.begin();it!=fs.end();it++)known.insert(it.value()["B"].dump());J checks=J::array();int existing=0;M G=eye(24);for(auto&r:G)for(auto&q:r)q-=Q(1)/9;for(auto g:gs){int id=g["frame"];auto f=nf[to_string(id)];M B;for(auto row:f["B"]){vectorr;for(auto x:row)r.push_back(rat(x));B.push_back(r);}int ops;Q det;auto inv=inverse(mul(mul(B,G),tr(B)),ops,det);admit(det);for(auto r:inv)for(auto q:r)admit(q);existing+=known.count(f["B"].dump());checks.push_back({{"frame",id},{"rank",B.size()},{"gram_determinant",det.str()},{"existing_basis",known.count(f["B"].dump())>0}});}J out={{"status","PASS_ALL_TARGET_RESTORE_FRAME_GRAMS_AND_FINITE_GUARDS"},{"groups",gs.size()},{"existing_baseline_bases",existing},{"largest_numerator",maxnum.str()},{"largest_denominator",maxden.str()},{"guard","Every pivot, inverse coefficient, and final determinant numerator/denominator <2^80; hence invertible over each prime q>2^80."},{"frames",checks}};ofstream(av[3])< +#include +#include +using namespace std;using J=nlohmann::json;using Q=boost::multiprecision::cpp_rational;using I=boost::multiprecision::cpp_int; +struct Ev{int k,a,b,c,f,z;};struct F{int d;vector>B,A;};J ld(string p){J j;ifstream(p)>>j;return j;}vectorclearrow(vectorr){I l=1;for(auto x:r){I a=l,b=denominator(x);while(b!=0){I t=a%b;a=b;b=t;}l=l/a*denominator(x);}vectorv;for(auto x:r){Q q=x*l;I a=numerator(q);if(a>LLONG_MAX||a());}return v;} +F frame(J rows){F f;for(auto row:rows){vectorr;for(auto x:row)r.push_back(Q(x.is_string()?x.get():x.dump()));f.B.push_back(clearrow(r));}f.d=f.B.size();vector>m;for(auto r:f.B){vectora;for(auto x:r)a.push_back(Q(x));m.push_back(a);}int p=0;vectorpc;for(int c=0;c<24;c++){int k=p;while(kr(24);r[c]=1;for(int i=0;ifs;for(auto j:{sf["frames"],nf})for(auto it=j.begin();it!=j.end();it++)fs[stoi(it.key())]={it.value()["dim"],it.value()["B"],it.value()["A"]};map,bool>cache;auto sub=[&](int a,int b){auto key=make_pair(a,b);if(cache.count(key))return cache[key];bool ok=fs.at(a).d<=fs.at(b).d;for(auto&r:fs.at(a).B)for(auto&s:fs.at(b).A){I d=0;for(int k=0;k<24;k++)d+=I(r[k])*s[k];if(d)ok=false;}return cache[key]=ok;};vectorold;Ev e;ifstream input(L+"/COHORT249-RECORDS.bin",ios::binary);while(input.read((char*)&e,sizeof e))old.push_back(e);vectorcats=st["physical"]["category_names"].get>();while(cats.size()<38)cats.push_back("extension_"+to_string(cats.size()));map>events;for(int i=0;ibase;ifstream basein(X+"/249-records.bin",ios::binary);while(basein.read((char*)&e,sizeof e))base.push_back(e);map>baseevents;vector>baseorder;for(int i=0;ireference;ifstream refinput(av[5],ios::binary);while(refinput.read((char*)&e,sizeof e))reference.push_back(e);auto oldnew=ld(av[6]);map,vector> currentEvents;for(int i=0;i=0;k--){auto t=reference.at(k);if(!t.k)continue;if(!oldnew.contains(to_string(t.a))||!oldnew.contains(to_string(t.b)))continue;t.a=oldnew[to_string(t.a)];t.b=oldnew[to_string(t.b)];auto found=currentEvents.find({t.k,t.a,t.b,t.c,t.z});if(found!=currentEvents.end()&&found->second.size()==1)return found->second[0];}throw runtime_error("no unique surviving boundary anchor");};cut=anchor(sel["cut_record"]);if(cut<0)throw runtime_error("anchorcut"); +int fid=max(300000,fs.rbegin()->first+1);vectorowner(v,-1),dep(v,-1),ini(n+1,zero),fin(n+1,zero); +for(int s=0;s>closes;int rejected=0; +for(auto r:sel["groups"]){ + auto f=frame(r["close_basis"]);fs[fid]=f;int firstAbove=old.size(),lastBelow=cut;bool valid=true; + settargets=r["targets"].get>();for(int t:targets)if(owner[t]>=0||!sub(fid,fin[v+t]))valid=false; + for(int i=cut+1;i<(int)old.size()&&valid;i++){auto e=old[i];if(e.k==1&&e.a>=v&&e.a<2*v&&targets.count(e.a-v)){ + bool below=sub(e.f,fid),above=sub(fid,e.f);if(!below&&!above){valid=false;break;} + if(!above)lastBelow=max(lastBelow,i);if(!below)firstAbove=min(firstAbove,i); + }} + int close=anchor(r["close_after_record"]);if(close=firstAbove||close<=cut)valid=false; + if(!valid){fs.erase(fid);rejected++;continue;} + int j=groups.size();r["frame"]=fid;r["cut_record"]=cut;r["close_after_record"]=close;r["close_rank"]=f.d; + r["retained"]=r["targets"];r["dependent"]=J::object();nf[to_string(fid)]={{"dim",f.d},{"B",f.B},{"A",f.A}}; + for(int t:targets)owner[t]=j;groups.push_back(r);closes[close].push_back(j);fid++; +} +cerr<<"Actual cut "<M(size_t(n+1)*W),responses(size_t(v)*W);auto row=[&](int s){return M.data()+size_t(s)*W;};auto response=[&](int s){return responses.data()+size_t(s)*W;};for(int i=0;icut){if(b>=v&&b<2*v&&owner[b-v]>=0&&i<=groups[owner[b-v]]["close_after_record"].get())throw runtime_error("active target read");if(e.a>=v&&e.a<2*v&&owner[e.a-v]>=0&&i<=groups[owner[e.a-v]]["close_after_record"].get()){if(b>=v&&b<2*v)throw runtime_error("target prefix input");for(int k=0;k lastDim(v,0); vector splitCost(v,0); +auto psi=[](int r){return r?pow((long double)r/120,1-.0007121L):0.L;}; +for(int i=cut+1;i<(int)old.size();i++){auto e=old[i];if(e.k==1&&e.a>=v&&e.a<2*v){int t=e.a-v,j=owner[t];if(j>=0&&i<=groups[j]["close_after_record"].get()){int d=fs.at(e.f).d;if(dts=g["targets"].get>();int h=ts.size(),end=fs.at(g["frame"].get()).d;if(h>63)throw runtime_error("target information-set cap"); + vectorw(h);for(int k=0;kend)throw runtime_error("close rank");w[k]=splitCost[t]+psi(end-lastDim[t])-psi(end);} + vectororder(h);iota(order.begin(),order.end(),0);stable_sort(order.begin(),order.end(),[&](int a,int b){return w[a],uint64_t>,greater> bas;J retained=J::array(),deps=J::object();long double nw=0,ow=0; + auto firstbit=[&](const vector&a){for(int k=W-1;k>=0;k--)if(a[k])return 64*k+63-__builtin_clzll(a[k]);return -1;}; + for(int z:order){vectora(response(ts[z]),response(ts[z])+W);uint64_t coeff=0;for(auto &[k,b]:bas)if((a[k/64]>>(k%64))&1){for(int t=0;t=0){bas[k]={a,coeff^(1ULL<>t)&1)donors.push_back(ts[t]);deps[to_string(ts[z])]=donors;}} + for(int t:g["retained"]){auto it=find(ts.begin(),ts.end(),t);if(it==ts.end())throw runtime_error("old retained outside group");ow+=w[it-ts.begin()];} + int oldgates=0,newgates=0;for(auto it=g["dependent"].begin();it!=g["dependent"].end();it++)oldgates+=it.value().size();for(auto it=deps.begin();it!=deps.end();it++)newgates+=it.value().size(); + bool take=nwkeep;for(int t:g["retained"])keep.insert(t); + for(auto it=g["dependent"].begin();it!=g["dependent"].end();it++){int t=stoi(it.key());if(keep.count(t))throw runtime_error("new basis overlap");dep[t]=j;for(int d:it.value())if(!keep.count(d))throw runtime_error("new donor not basis");for(int k=0;kout;auto state=ini;mapH,oldH;for(auto e:old)if(e.k==0&&e.f)oldH[e.f]++;else if(e.k==2)oldH[e.z]++;auto moveTo=[&](int s,int f){if(state[s]==f)return;if(!sub(state[s],f))throw runtime_error("nonnested actual role "+to_string(s)+" "+to_string(state[s])+" to "+to_string(f));int r=fs[f].d-fs[state[s]].d;out.push_back({0,s,state[s],f,r,0});if(r)H[r]++;state[s]=f;};auto add=[&](int a,int b,int c,int f,int z){moveTo(a,f);moveTo(b,f);out.push_back({1,a,b,c,f,z});};int inserted=0,deleted=0,first=-1;auto batch=[&](int j,bool setup){auto r=groups[j];bool nonzero=false;for(auto it=r["dependent"].begin();it!=r["dependent"].end();it++)if(!it.value().empty())nonzero=true;if(!nonzero)return;int f=setup?zero:r["frame"].get();for(int t:r["targets"])moveTo(v+t,f);for(auto it=r["dependent"].begin();it!=r["dependent"].end();it++)for(int p:it.value()){int a=v+stoi(it.key());if(setup&&first<0)first=out.size();add(a,v+p,setup?-1:1,f,setup?34:35);inserted++;}};center=-1;for(int i=0;i=v&&e.a<2*v?dep[e.a-v]:-1;if(j>=0&&i>cut&&i<=groups[j]["close_after_record"].get())deleted++;else add(e.a,e.b,e.c,e.f,e.z);}else if(e.k==2){moveTo(e.a,e.c);state[e.b]=e.f;out.push_back(e);H[e.z]++;center=e.a;}else if(e.k==3){if(state[e.a]!=e.c||state[e.b]!=e.f)throw runtime_error("COPY close frame");out.push_back(e);center=-1;}if(i==cut){if(center!=-1)throw runtime_error("cut COPY");for(int t=0;t=0&&state[v+t]!=zero)throw runtime_error("setup target not zero");for(int j=0;jranks;for(auto[r,c]:H)ranks.insert(r);for(auto[r,c]:oldH)ranks.insert(r);for(int r:ranks)if(H[r]!=oldH[r])delta[to_string(r)]=H[r]-oldH[r];if(mass!=oldmass)throw runtime_error("rank mass changed"); +auto replay=[&](bool rev,int omit){fill(M.begin(),M.end(),0);for(int i=0;i=v&&s<2*v&&(s-v)/64==k)ex^=1ULL<<((s-v)%64);bad+=row(s)[k]!=ex;}return bad;};if(replay(false,-1)||replay(true,-1))throw runtime_error("full endpoint columns");auto wrong=replay(false,first);int restore=-1;for(int i=0;i=0&&(!wrong||!wrongRestore))throw runtime_error("vacuous negative");ofstream bout(O+"/COHORT249-RECORDS.bin",ios::binary);bout.write((char*)out.data(),out.size()*sizeof(Ev));ofstream(O+"/COHORT249-FRAMES.json")<();if(value)receipt["delta"][it.key()]=value;else receipt["delta"].erase(it.key());}receipt["histogram"]=hist;receipt["new_rank_mass"]=mass;receipt["new_records"]=out.size();receipt["target_prefix_composed"]=true;ofstream(O+"/COHORT249-REPLAY.json"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

GUB%SNV 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 literal 0 HcmV?d00001 diff --git a/research/gen5-retiming-targets/vendor/json.hpp b/research/gen5-retiming-targets/vendor/json.hpp new file mode 100644 index 0000000000..82d69f7c5d --- /dev/null +++ b/research/gen5-retiming-targets/vendor/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