Map Editor

RD Core / Commit #3

Commit Map Editor

Alex committed 18/10/2026 23:40 main Patch

436 files +250,791 -0

All commits Browse code

A RD_Map_Editor/source/templatemap854.cpp +2,569-0 View file

Large diff collapsed. 2,570 diff lines hidden.

		@@ -0,0 +1,2569 @@
1	+	//////////////////////////////////////////////////////////////////////
2	+	// This file is part of Remere's Map Editor
3	+	//////////////////////////////////////////////////////////////////////
4	+	// Remere's Map Editor is free software: you can redistribute it and/or modify
5	+	// it under the terms of the GNU General Public License as published by
6	+	// the Free Software Foundation, either version 3 of the License, or
7	+	// (at your option) any later version.
8	+	//
9	+	// Remere's Map Editor is distributed in the hope that it will be useful,
10	+	// but WITHOUT ANY WARRANTY; without even the implied warranty of
11	+	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	+	// GNU General Public License for more details.
13	+	//
14	+	// You should have received a copy of the GNU General Public License
15	+	// along with this program. If not, see <http://www.gnu.org/licenses/>.
16	+	//////////////////////////////////////////////////////////////////////
17	+
18	+	#include "main.h"
19	+
20	+	#include "templates.h"
21	+
22	+	ConversionMap getReplacementMapFrom854To854() {
23	+	ConversionMap replacement_map;
24	+	std::vector<uint16_t> vecval;
25	+
26	+	vecval.clear();
27	+	vecval.push_back(2696);
28	+	replacement_map.stm[8368] = vecval;
29	+	vecval.clear();
30	+	vecval.push_back(10546);
31	+	replacement_map.stm[1497] = vecval;
32	+	vecval.clear();
33	+	vecval.push_back(8368);
34	+	replacement_map.stm[8112] = vecval;
35	+	vecval.clear();
36	+	vecval.push_back(4526);
37	+	replacement_map.stm[102] = vecval;
38	+	vecval.clear();
39	+	vecval.push_back(10547);
40	+	replacement_map.stm[10546] = vecval;
41	+	vecval.clear();
42	+	vecval.push_back(10548);
43	+	replacement_map.stm[10547] = vecval;
44	+	vecval.clear();
45	+	vecval.push_back(10549);
46	+	replacement_map.stm[10548] = vecval;
47	+	vecval.clear();
48	+	vecval.push_back(10550);
49	+	replacement_map.stm[10549] = vecval;
50	+	vecval.clear();
51	+	vecval.push_back(10551);
52	+	replacement_map.stm[10550] = vecval;
53	+	vecval.clear();
54	+	vecval.push_back(10552);
55	+	replacement_map.stm[10551] = vecval;
56	+	vecval.clear();
57	+	vecval.push_back(10553);
58	+	replacement_map.stm[10552] = vecval;
59	+	vecval.clear();
60	+	vecval.push_back(10554);
61	+	replacement_map.stm[10553] = vecval;
62	+	vecval.clear();
63	+	vecval.push_back(10555);
64	+	replacement_map.stm[10554] = vecval;
65	+	vecval.clear();
66	+	vecval.push_back(10556);
67	+	replacement_map.stm[10555] = vecval;
68	+	vecval.clear();
69	+	vecval.push_back(10557);
70	+	replacement_map.stm[10556] = vecval;
71	+	vecval.clear();
72	+	vecval.push_back(10558);
73	+	replacement_map.stm[10557] = vecval;
74	+	vecval.clear();
75	+	vecval.push_back(10559);
76	+	replacement_map.stm[10558] = vecval;
77	+	vecval.clear();
78	+	vecval.push_back(10560);
79	+	replacement_map.stm[10559] = vecval;
80	+	vecval.clear();
81	+	vecval.push_back(10561);
82	+	replacement_map.stm[10560] = vecval;
83	+	vecval.clear();
84	+	vecval.push_back(10562);
85	+	replacement_map.stm[10561] = vecval;
86	+	vecval.clear();
87	+	vecval.push_back(10563);
88	+	replacement_map.stm[10562] = vecval;
89	+	vecval.clear();
90	+	vecval.push_back(10564);
91	+	replacement_map.stm[10563] = vecval;
92	+	vecval.clear();
93	+	vecval.push_back(10565);
94	+	replacement_map.stm[10564] = vecval;
95	+	vecval.clear();
96	+	vecval.push_back(10566);
97	+	replacement_map.stm[10565] = vecval;
98	+	vecval.clear();
99	+	vecval.push_back(10567);
100	+	replacement_map.stm[10566] = vecval;
101	+	vecval.clear();
102	+	vecval.push_back(10568);
103	+	replacement_map.stm[10567] = vecval;
104	+	vecval.clear();
105	+	vecval.push_back(10569);
106	+	replacement_map.stm[10568] = vecval;
107	+	vecval.clear();
108	+	vecval.push_back(10570);
109	+	replacement_map.stm[10569] = vecval;
110	+	vecval.clear();
111	+	vecval.push_back(10571);
112	+	replacement_map.stm[10570] = vecval;
113	+	vecval.clear();
114	+	vecval.push_back(10572);
115	+	replacement_map.stm[10571] = vecval;
116	+	vecval.clear();
117	+	vecval.push_back(10573);
118	+	replacement_map.stm[10572] = vecval;
119	+	vecval.clear();
120	+	vecval.push_back(10574);
121	+	replacement_map.stm[10573] = vecval;
122	+	vecval.clear();
123	+	vecval.push_back(10575);
124	+	replacement_map.stm[10574] = vecval;
125	+	vecval.clear();
126	+	vecval.push_back(10576);
127	+	replacement_map.stm[10575] = vecval;
128	+	vecval.clear();
129	+	vecval.push_back(10577);
130	+	replacement_map.stm[10576] = vecval;
131	+	vecval.clear();
132	+	vecval.push_back(10578);
133	+	replacement_map.stm[10577] = vecval;
134	+	vecval.clear();
135	+	vecval.push_back(10579);
136	+	replacement_map.stm[10578] = vecval;
137	+	vecval.clear();
138	+	vecval.push_back(10580);
139	+	replacement_map.stm[10579] = vecval;
140	+	vecval.clear();
141	+	vecval.push_back(10581);
142	+	replacement_map.stm[10580] = vecval;
143	+	vecval.clear();
144	+	vecval.push_back(10582);
145	+	replacement_map.stm[10581] = vecval;
146	+	vecval.clear();
147	+	vecval.push_back(10583);
148	+	replacement_map.stm[10582] = vecval;
149	+	vecval.clear();
150	+	vecval.push_back(10584);
151	+	replacement_map.stm[10583] = vecval;
152	+	vecval.clear();
153	+	vecval.push_back(10585);
154	+	replacement_map.stm[10584] = vecval;
155	+	vecval.clear();
156	+	vecval.push_back(10586);
157	+	replacement_map.stm[10585] = vecval;
158	+	vecval.clear();
159	+	vecval.push_back(10587);
160	+	replacement_map.stm[10586] = vecval;
161	+	vecval.clear();
162	+	vecval.push_back(10588);
163	+	replacement_map.stm[10587] = vecval;
164	+	vecval.clear();
165	+	vecval.push_back(10589);
166	+	replacement_map.stm[10588] = vecval;
167	+	vecval.clear();
168	+	vecval.push_back(10590);
169	+	replacement_map.stm[10589] = vecval;
170	+	vecval.clear();
171	+	vecval.push_back(10591);
172	+	replacement_map.stm[10590] = vecval;
173	+	vecval.clear();
174	+	vecval.push_back(10592);
175	+	replacement_map.stm[10591] = vecval;
176	+	vecval.clear();
177	+	vecval.push_back(10593);
178	+	replacement_map.stm[10592] = vecval;
179	+	vecval.clear();
180	+	vecval.push_back(10594);
181	+	replacement_map.stm[10593] = vecval;
182	+	vecval.clear();
183	+	vecval.push_back(10595);
184	+	replacement_map.stm[10594] = vecval;
185	+	vecval.clear();
186	+	vecval.push_back(10596);
187	+	replacement_map.stm[10595] = vecval;
188	+	vecval.clear();
189	+	vecval.push_back(10597);
190	+	replacement_map.stm[10596] = vecval;
191	+	vecval.clear();
192	+	vecval.push_back(10598);
193	+	replacement_map.stm[10597] = vecval;
194	+	vecval.clear();
195	+	vecval.push_back(10599);
196	+	replacement_map.stm[10598] = vecval;
197	+	vecval.clear();
198	+	vecval.push_back(10600);
199	+	replacement_map.stm[10599] = vecval;
200	+	vecval.clear();
201	+	vecval.push_back(10601);
202	+	replacement_map.stm[10600] = vecval;
203	+	vecval.clear();
204	+	vecval.push_back(10602);
205	+	replacement_map.stm[10601] = vecval;
206	+	vecval.clear();
207	+	vecval.push_back(10603);
208	+	replacement_map.stm[10602] = vecval;
209	+	vecval.clear();
210	+	vecval.push_back(10604);
211	+	replacement_map.stm[10603] = vecval;
212	+	vecval.clear();
213	+	vecval.push_back(10605);
214	+	replacement_map.stm[10604] = vecval;
215	+	vecval.clear();
216	+	vecval.push_back(10606);
217	+	replacement_map.stm[10605] = vecval;
218	+	vecval.clear();
219	+	vecval.push_back(10607);
220	+	replacement_map.stm[10606] = vecval;
221	+	vecval.clear();
222	+	vecval.push_back(10608);
223	+	replacement_map.stm[10607] = vecval;
224	+	vecval.clear();
225	+	vecval.push_back(10609);
226	+	replacement_map.stm[10608] = vecval;
227	+	vecval.clear();
228	+	vecval.push_back(10610);
229	+	replacement_map.stm[10609] = vecval;
230	+	vecval.clear();
231	+	vecval.push_back(10611);
232	+	replacement_map.stm[10610] = vecval;
233	+	vecval.clear();
234	+	vecval.push_back(10612);
235	+	replacement_map.stm[10611] = vecval;
236	+	vecval.clear();
237	+	vecval.push_back(10613);
238	+	replacement_map.stm[10612] = vecval;
239	+	vecval.clear();
240	+	vecval.push_back(10614);
241	+	replacement_map.stm[10613] = vecval;
242	+	vecval.clear();
243	+	vecval.push_back(10615);
244	+	replacement_map.stm[10614] = vecval;
245	+	vecval.clear();
246	+	vecval.push_back(10616);
247	+	replacement_map.stm[10615] = vecval;
248	+	vecval.clear();
249	+	vecval.push_back(10617);
250	+	replacement_map.stm[10616] = vecval;
251	+	vecval.clear();
252	+	vecval.push_back(10618);
253	+	replacement_map.stm[10617] = vecval;
254	+	vecval.clear();
255	+	vecval.push_back(10619);
256	+	replacement_map.stm[10618] = vecval;
257	+	vecval.clear();
258	+	vecval.push_back(10620);
259	+	replacement_map.stm[10619] = vecval;
260	+	vecval.clear();
261	+	vecval.push_back(10621);
262	+	replacement_map.stm[10620] = vecval;
263	+	vecval.clear();
264	+	vecval.push_back(10622);
265	+	replacement_map.stm[10621] = vecval;
266	+	vecval.clear();
267	+	vecval.push_back(10623);
268	+	replacement_map.stm[10622] = vecval;
269	+	vecval.clear();
270	+	vecval.push_back(10624);
271	+	replacement_map.stm[10623] = vecval;
272	+	vecval.clear();
273	+	vecval.push_back(10625);
274	+	replacement_map.stm[10624] = vecval;
275	+	vecval.clear();
276	+	vecval.push_back(10626);
277	+	replacement_map.stm[10625] = vecval;
278	+	vecval.clear();
279	+	vecval.push_back(10627);
280	+	replacement_map.stm[10626] = vecval;
281	+	vecval.clear();
282	+	vecval.push_back(10628);
283	+	replacement_map.stm[10627] = vecval;
284	+	vecval.clear();
285	+	vecval.push_back(10629);
286	+	replacement_map.stm[10628] = vecval;
287	+	vecval.clear();
288	+	vecval.push_back(10630);
289	+	replacement_map.stm[10629] = vecval;
290	+	vecval.clear();
291	+	vecval.push_back(10631);
292	+	replacement_map.stm[10630] = vecval;
293	+	vecval.clear();
294	+	vecval.push_back(10632);
295	+	replacement_map.stm[10631] = vecval;
296	+	vecval.clear();
297	+	vecval.push_back(10633);
298	+	replacement_map.stm[10632] = vecval;
299	+	vecval.clear();
300	+	vecval.push_back(10634);
301	+	replacement_map.stm[10633] = vecval;
302	+	vecval.clear();
303	+	vecval.push_back(10635);
304	+	replacement_map.stm[10634] = vecval;
305	+	vecval.clear();
306	+	vecval.push_back(10636);
307	+	replacement_map.stm[10635] = vecval;
308	+	vecval.clear();
309	+	vecval.push_back(10637);
310	+	replacement_map.stm[10636] = vecval;
311	+	vecval.clear();
312	+	vecval.push_back(10638);
313	+	replacement_map.stm[10637] = vecval;
314	+	vecval.clear();
315	+	vecval.push_back(10639);
316	+	replacement_map.stm[10638] = vecval;
317	+	vecval.clear();
318	+	vecval.push_back(10640);
319	+	replacement_map.stm[10639] = vecval;
320	+	vecval.clear();
321	+	vecval.push_back(10641);
322	+	replacement_map.stm[10640] = vecval;
323	+	vecval.clear();
324	+	vecval.push_back(10642);
325	+	replacement_map.stm[10641] = vecval;
326	+	vecval.clear();
327	+	vecval.push_back(10643);
328	+	replacement_map.stm[10642] = vecval;
329	+	vecval.clear();
330	+	vecval.push_back(10644);
331	+	replacement_map.stm[10643] = vecval;
332	+	vecval.clear();
333	+	vecval.push_back(10645);
334	+	replacement_map.stm[10644] = vecval;
335	+	vecval.clear();
336	+	vecval.push_back(10646);
337	+	replacement_map.stm[10645] = vecval;
338	+	vecval.clear();
339	+	vecval.push_back(10647);
340	+	replacement_map.stm[10646] = vecval;
341	+	vecval.clear();
342	+	vecval.push_back(10648);
343	+	replacement_map.stm[10647] = vecval;
344	+	vecval.clear();
345	+	vecval.push_back(10649);
346	+	replacement_map.stm[10648] = vecval;
347	+	vecval.clear();
348	+	vecval.push_back(10650);
349	+	replacement_map.stm[10649] = vecval;
350	+	vecval.clear();
351	+	vecval.push_back(10651);
352	+	replacement_map.stm[10650] = vecval;
353	+	vecval.clear();
354	+	vecval.push_back(10652);
355	+	replacement_map.stm[10651] = vecval;
356	+	vecval.clear();
357	+	vecval.push_back(10653);
358	+	replacement_map.stm[10652] = vecval;
359	+	vecval.clear();
360	+	vecval.push_back(10654);
361	+	replacement_map.stm[10653] = vecval;
362	+	vecval.clear();
363	+	vecval.push_back(10655);
364	+	replacement_map.stm[10654] = vecval;
365	+	vecval.clear();
366	+	vecval.push_back(10656);
367	+	replacement_map.stm[10655] = vecval;
368	+	vecval.clear();
369	+	vecval.push_back(10657);
370	+	replacement_map.stm[10656] = vecval;
371	+	vecval.clear();
372	+	vecval.push_back(10658);
373	+	replacement_map.stm[10657] = vecval;
374	+	vecval.clear();
375	+	vecval.push_back(10659);
376	+	replacement_map.stm[10658] = vecval;
377	+	vecval.clear();
378	+	vecval.push_back(10660);
379	+	replacement_map.stm[10659] = vecval;
380	+	vecval.clear();
381	+	vecval.push_back(10661);
382	+	replacement_map.stm[10660] = vecval;
383	+	vecval.clear();
384	+	vecval.push_back(10662);
385	+	replacement_map.stm[10661] = vecval;
386	+	vecval.clear();
387	+	vecval.push_back(10663);
388	+	replacement_map.stm[10662] = vecval;
389	+	vecval.clear();
390	+	vecval.push_back(10664);
391	+	replacement_map.stm[10663] = vecval;
392	+	vecval.clear();
393	+	vecval.push_back(10665);
394	+	replacement_map.stm[10664] = vecval;
395	+	vecval.clear();
396	+	vecval.push_back(10666);
397	+	replacement_map.stm[10665] = vecval;
398	+	vecval.clear();
399	+	vecval.push_back(10667);
400	+	replacement_map.stm[10666] = vecval;
401	+	vecval.clear();
402	+	vecval.push_back(10668);
403	+	replacement_map.stm[10667] = vecval;
404	+	vecval.clear();
405	+	vecval.push_back(10669);
406	+	replacement_map.stm[10668] = vecval;
407	+	vecval.clear();
408	+	vecval.push_back(10670);
409	+	replacement_map.stm[10669] = vecval;
410	+	vecval.clear();
411	+	vecval.push_back(10671);
412	+	replacement_map.stm[10670] = vecval;
413	+	vecval.clear();
414	+	vecval.push_back(10672);
415	+	replacement_map.stm[10671] = vecval;
416	+	vecval.clear();
417	+	vecval.push_back(10673);
418	+	replacement_map.stm[10672] = vecval;
419	+	vecval.clear();
420	+	vecval.push_back(10674);
421	+	replacement_map.stm[10673] = vecval;
422	+	vecval.clear();
423	+	vecval.push_back(10675);
424	+	replacement_map.stm[10674] = vecval;
425	+	vecval.clear();
426	+	vecval.push_back(10676);
427	+	replacement_map.stm[10675] = vecval;
428	+	vecval.clear();
429	+	vecval.push_back(10677);
430	+	replacement_map.stm[10676] = vecval;
431	+	vecval.clear();
432	+	vecval.push_back(10678);
433	+	replacement_map.stm[10677] = vecval;
434	+	vecval.clear();
435	+	vecval.push_back(10679);
436	+	replacement_map.stm[10678] = vecval;
437	+	vecval.clear();
438	+	vecval.push_back(10680);
439	+	replacement_map.stm[10679] = vecval;
440	+	vecval.clear();
441	+	vecval.push_back(10681);
442	+	replacement_map.stm[10680] = vecval;
443	+	vecval.clear();
444	+	vecval.push_back(10682);
445	+	replacement_map.stm[10681] = vecval;
446	+	vecval.clear();
447	+	vecval.push_back(10683);
448	+	replacement_map.stm[10682] = vecval;
449	+	vecval.clear();
450	+	vecval.push_back(10684);
451	+	replacement_map.stm[10683] = vecval;
452	+	vecval.clear();
453	+	vecval.push_back(10685);
454	+	replacement_map.stm[10684] = vecval;
455	+	vecval.clear();
456	+	vecval.push_back(10686);
457	+	replacement_map.stm[10685] = vecval;
458	+	vecval.clear();
459	+	vecval.push_back(10687);
460	+	replacement_map.stm[10686] = vecval;
461	+	vecval.clear();
462	+	vecval.push_back(10688);
463	+	replacement_map.stm[10687] = vecval;
464	+	vecval.clear();
465	+	vecval.push_back(10689);
466	+	replacement_map.stm[10688] = vecval;
467	+	vecval.clear();
468	+	vecval.push_back(10690);
469	+	replacement_map.stm[10689] = vecval;
470	+	vecval.clear();
471	+	vecval.push_back(10691);
472	+	replacement_map.stm[10690] = vecval;
473	+	vecval.clear();
474	+	vecval.push_back(10692);
475	+	replacement_map.stm[10691] = vecval;
476	+	vecval.clear();
477	+	vecval.push_back(10693);
478	+	replacement_map.stm[10692] = vecval;
479	+	vecval.clear();
480	+	vecval.push_back(10694);
481	+	replacement_map.stm[10693] = vecval;
482	+	vecval.clear();
483	+	vecval.push_back(10695);
484	+	replacement_map.stm[10694] = vecval;
485	+	vecval.clear();
486	+	vecval.push_back(10696);
487	+	replacement_map.stm[10695] = vecval;
488	+	vecval.clear();
489	+	vecval.push_back(10697);
490	+	replacement_map.stm[10696] = vecval;
491	+	vecval.clear();
492	+	vecval.push_back(10698);
493	+	replacement_map.stm[10697] = vecval;
494	+	vecval.clear();
495	+	vecval.push_back(10699);
496	+	replacement_map.stm[10698] = vecval;
497	+	vecval.clear();
498	+	vecval.push_back(10700);
499	+	replacement_map.stm[10699] = vecval;
500	+	vecval.clear();
501	+	vecval.push_back(10701);
502	+	replacement_map.stm[10700] = vecval;
503	+	vecval.clear();
504	+	vecval.push_back(10702);
505	+	replacement_map.stm[10701] = vecval;
506	+	vecval.clear();
507	+	vecval.push_back(10703);
508	+	replacement_map.stm[10702] = vecval;
509	+	vecval.clear();
510	+	vecval.push_back(10704);
511	+	replacement_map.stm[10703] = vecval;
512	+	vecval.clear();
513	+	vecval.push_back(10705);
514	+	replacement_map.stm[10704] = vecval;
515	+	vecval.clear();
516	+	vecval.push_back(10706);
517	+	replacement_map.stm[10705] = vecval;
518	+	vecval.clear();
519	+	vecval.push_back(10707);
520	+	replacement_map.stm[10706] = vecval;
521	+	vecval.clear();
522	+	vecval.push_back(10708);
523	+	replacement_map.stm[10707] = vecval;
524	+	vecval.clear();
525	+	vecval.push_back(10709);
526	+	replacement_map.stm[10708] = vecval;
527	+	vecval.clear();
528	+	vecval.push_back(10710);
529	+	replacement_map.stm[10709] = vecval;
530	+	vecval.clear();
531	+	vecval.push_back(10711);
532	+	replacement_map.stm[10710] = vecval;
533	+	vecval.clear();
534	+	vecval.push_back(10712);
535	+	replacement_map.stm[10711] = vecval;
536	+	vecval.clear();
537	+	vecval.push_back(10713);
538	+	replacement_map.stm[10712] = vecval;
539	+	vecval.clear();
540	+	vecval.push_back(10714);
541	+	replacement_map.stm[10713] = vecval;
542	+	vecval.clear();
543	+	vecval.push_back(10715);
544	+	replacement_map.stm[10714] = vecval;
545	+	vecval.clear();
546	+	vecval.push_back(10716);
547	+	replacement_map.stm[10715] = vecval;
548	+	vecval.clear();
549	+	vecval.push_back(10717);
550	+	replacement_map.stm[10716] = vecval;
551	+	vecval.clear();
552	+	vecval.push_back(10718);
553	+	replacement_map.stm[10717] = vecval;
554	+	vecval.clear();
555	+	vecval.push_back(10719);
556	+	replacement_map.stm[10718] = vecval;
557	+	vecval.clear();
558	+	vecval.push_back(10720);
559	+	replacement_map.stm[10719] = vecval;
560	+	vecval.clear();
561	+	vecval.push_back(10721);
562	+	replacement_map.stm[10720] = vecval;
563	+	vecval.clear();
564	+	vecval.push_back(10722);
565	+	replacement_map.stm[10721] = vecval;
566	+	vecval.clear();
567	+	vecval.push_back(10723);
568	+	replacement_map.stm[10722] = vecval;
569	+	vecval.clear();
570	+	vecval.push_back(10724);
571	+	replacement_map.stm[10723] = vecval;
572	+	vecval.clear();
573	+	vecval.push_back(10725);
574	+	replacement_map.stm[10724] = vecval;
575	+	vecval.clear();
576	+	vecval.push_back(10726);
577	+	replacement_map.stm[10725] = vecval;
578	+	vecval.clear();
579	+	vecval.push_back(10727);
580	+	replacement_map.stm[10726] = vecval;
581	+	vecval.clear();
582	+	vecval.push_back(10728);
583	+	replacement_map.stm[10727] = vecval;
584	+	vecval.clear();
585	+	vecval.push_back(10729);
586	+	replacement_map.stm[10728] = vecval;
587	+	vecval.clear();
588	+	vecval.push_back(10730);
589	+	replacement_map.stm[10729] = vecval;
590	+	vecval.clear();
591	+	vecval.push_back(10731);
592	+	replacement_map.stm[10730] = vecval;
593	+	vecval.clear();
594	+	vecval.push_back(10732);
595	+	replacement_map.stm[10731] = vecval;
596	+	vecval.clear();
597	+	vecval.push_back(10733);
598	+	replacement_map.stm[10732] = vecval;
599	+	vecval.clear();
600	+	vecval.push_back(10734);
601	+	replacement_map.stm[10733] = vecval;
602	+	vecval.clear();
603	+	vecval.push_back(10735);
604	+	replacement_map.stm[10734] = vecval;
605	+	vecval.clear();
606	+	vecval.push_back(10736);
607	+	replacement_map.stm[10735] = vecval;
608	+	vecval.clear();
609	+	vecval.push_back(10737);
610	+	replacement_map.stm[10736] = vecval;
611	+	vecval.clear();
612	+	vecval.push_back(10738);
613	+	replacement_map.stm[10737] = vecval;
614	+	vecval.clear();
615	+	vecval.push_back(10739);
616	+	replacement_map.stm[10738] = vecval;
617	+	vecval.clear();
618	+	vecval.push_back(10740);
619	+	replacement_map.stm[10739] = vecval;
620	+	vecval.clear();
621	+	vecval.push_back(10741);
622	+	replacement_map.stm[10740] = vecval;
623	+	vecval.clear();
624	+	vecval.push_back(10742);
625	+	replacement_map.stm[10741] = vecval;
626	+	vecval.clear();
627	+	vecval.push_back(10743);
628	+	replacement_map.stm[10742] = vecval;
629	+	vecval.clear();
630	+	vecval.push_back(10744);
631	+	replacement_map.stm[10743] = vecval;
632	+	vecval.clear();
633	+	vecval.push_back(10745);
634	+	replacement_map.stm[10744] = vecval;
635	+	vecval.clear();
636	+	vecval.push_back(10746);
637	+	replacement_map.stm[10745] = vecval;
638	+	vecval.clear();
639	+	vecval.push_back(10747);
640	+	replacement_map.stm[10746] = vecval;
641	+	vecval.clear();
642	+	vecval.push_back(10748);
643	+	replacement_map.stm[10747] = vecval;
644	+	vecval.clear();
645	+	vecval.push_back(10749);
646	+	replacement_map.stm[10748] = vecval;
647	+	vecval.clear();
648	+	vecval.push_back(10750);
649	+	replacement_map.stm[10749] = vecval;
650	+	vecval.clear();
651	+	vecval.push_back(10751);
652	+	replacement_map.stm[10750] = vecval;
653	+	vecval.clear();
654	+	vecval.push_back(10752);
655	+	replacement_map.stm[10751] = vecval;
656	+	vecval.clear();
657	+	vecval.push_back(10753);
658	+	replacement_map.stm[10752] = vecval;
659	+	vecval.clear();
660	+	vecval.push_back(10754);
661	+	replacement_map.stm[10753] = vecval;
662	+	vecval.clear();
663	+	vecval.push_back(10755);
664	+	replacement_map.stm[10754] = vecval;
665	+	vecval.clear();
666	+	vecval.push_back(10756);
667	+	replacement_map.stm[10755] = vecval;
668	+	vecval.clear();
669	+	vecval.push_back(10757);
670	+	replacement_map.stm[10756] = vecval;
671	+	vecval.clear();
672	+	vecval.push_back(10758);
673	+	replacement_map.stm[10757] = vecval;
674	+	vecval.clear();
675	+	vecval.push_back(10759);
676	+	replacement_map.stm[10758] = vecval;
677	+	vecval.clear();
678	+	vecval.push_back(10760);
679	+	replacement_map.stm[10759] = vecval;
680	+	vecval.clear();
681	+	vecval.push_back(10761);
682	+	replacement_map.stm[10760] = vecval;
683	+	vecval.clear();
684	+	vecval.push_back(10762);
685	+	replacement_map.stm[10761] = vecval;
686	+	vecval.clear();
687	+	vecval.push_back(10763);
688	+	replacement_map.stm[10762] = vecval;
689	+	vecval.clear();
690	+	vecval.push_back(10764);
691	+	replacement_map.stm[10763] = vecval;
692	+	vecval.clear();
693	+	vecval.push_back(10765);
694	+	replacement_map.stm[10764] = vecval;
695	+	vecval.clear();
696	+	vecval.push_back(10766);
697	+	replacement_map.stm[10765] = vecval;
698	+	vecval.clear();
699	+	vecval.push_back(10767);
700	+	replacement_map.stm[10766] = vecval;
701	+	vecval.clear();
702	+	vecval.push_back(10768);
703	+	replacement_map.stm[10767] = vecval;
704	+	vecval.clear();
705	+	vecval.push_back(10769);
706	+	replacement_map.stm[10768] = vecval;
707	+	vecval.clear();
708	+	vecval.push_back(10770);
709	+	replacement_map.stm[10769] = vecval;
710	+	vecval.clear();
711	+	vecval.push_back(10771);
712	+	replacement_map.stm[10770] = vecval;
713	+	vecval.clear();
714	+	vecval.push_back(10772);
715	+	replacement_map.stm[10771] = vecval;
716	+	vecval.clear();
717	+	vecval.push_back(10773);
718	+	replacement_map.stm[10772] = vecval;
719	+	vecval.clear();
720	+	vecval.push_back(10774);
721	+	replacement_map.stm[10773] = vecval;
722	+	vecval.clear();
723	+	vecval.push_back(10775);
724	+	replacement_map.stm[10774] = vecval;
725	+	vecval.clear();
726	+	vecval.push_back(10776);
727	+	replacement_map.stm[10775] = vecval;
728	+	vecval.clear();
729	+	vecval.push_back(10777);
730	+	replacement_map.stm[10776] = vecval;
731	+	vecval.clear();
732	+	vecval.push_back(10778);
733	+	replacement_map.stm[10777] = vecval;
734	+	vecval.clear();
735	+	vecval.push_back(10779);
736	+	replacement_map.stm[10778] = vecval;
737	+	vecval.clear();
738	+	vecval.push_back(10780);
739	+	replacement_map.stm[10779] = vecval;
740	+	vecval.clear();
741	+	vecval.push_back(10781);
742	+	replacement_map.stm[10780] = vecval;
743	+	vecval.clear();
744	+	vecval.push_back(10782);
745	+	replacement_map.stm[10781] = vecval;
746	+	vecval.clear();
747	+	vecval.push_back(10783);
748	+	replacement_map.stm[10782] = vecval;
749	+	vecval.clear();
750	+	vecval.push_back(10784);
751	+	replacement_map.stm[10783] = vecval;
752	+	vecval.clear();
753	+	vecval.push_back(10785);
754	+	replacement_map.stm[10784] = vecval;
755	+	vecval.clear();
756	+	vecval.push_back(10786);
757	+	replacement_map.stm[10785] = vecval;
758	+	vecval.clear();
759	+	vecval.push_back(10787);
760	+	replacement_map.stm[10786] = vecval;
761	+	vecval.clear();
762	+	vecval.push_back(10788);
763	+	replacement_map.stm[10787] = vecval;
764	+	vecval.clear();
765	+	vecval.push_back(10789);
766	+	replacement_map.stm[10788] = vecval;
767	+	vecval.clear();
768	+	vecval.push_back(10790);
769	+	replacement_map.stm[10789] = vecval;
770	+	vecval.clear();
771	+	vecval.push_back(10791);
772	+	replacement_map.stm[10790] = vecval;
773	+	vecval.clear();
774	+	vecval.push_back(10792);
775	+	replacement_map.stm[10791] = vecval;
776	+	vecval.clear();
777	+	vecval.push_back(10793);
778	+	replacement_map.stm[10792] = vecval;
779	+	vecval.clear();
780	+	vecval.push_back(10794);
781	+	replacement_map.stm[10793] = vecval;
782	+	vecval.clear();
783	+	vecval.push_back(10795);
784	+	replacement_map.stm[10794] = vecval;
785	+	vecval.clear();
786	+	vecval.push_back(10796);
787	+	replacement_map.stm[10795] = vecval;
788	+	vecval.clear();
789	+	vecval.push_back(10797);
790	+	replacement_map.stm[10796] = vecval;
791	+	vecval.clear();
792	+	vecval.push_back(10798);
793	+	replacement_map.stm[10797] = vecval;
794	+	vecval.clear();
795	+	vecval.push_back(10799);
796	+	replacement_map.stm[10798] = vecval;
797	+	vecval.clear();
798	+	vecval.push_back(10800);
799	+	replacement_map.stm[10799] = vecval;
800	+	vecval.clear();
801	+	vecval.push_back(10801);
802	+	replacement_map.stm[10800] = vecval;
803	+	vecval.clear();
804	+	vecval.push_back(10802);
805	+	replacement_map.stm[10801] = vecval;
806	+	vecval.clear();
807	+	vecval.push_back(10803);
808	+	replacement_map.stm[10802] = vecval;
809	+	vecval.clear();
810	+	vecval.push_back(10804);
811	+	replacement_map.stm[10803] = vecval;
812	+	vecval.clear();
813	+	vecval.push_back(10805);
814	+	replacement_map.stm[10804] = vecval;
815	+	vecval.clear();
816	+	vecval.push_back(10806);
817	+	replacement_map.stm[10805] = vecval;
818	+	vecval.clear();
819	+	vecval.push_back(10807);
820	+	replacement_map.stm[10806] = vecval;
821	+	vecval.clear();
822	+	vecval.push_back(10808);
823	+	replacement_map.stm[10807] = vecval;
824	+	vecval.clear();
825	+	vecval.push_back(10809);
826	+	replacement_map.stm[10808] = vecval;
827	+	vecval.clear();
828	+	vecval.push_back(10810);
829	+	replacement_map.stm[10809] = vecval;
830	+	vecval.clear();
831	+	vecval.push_back(10811);
832	+	replacement_map.stm[10810] = vecval;
833	+	vecval.clear();
834	+	vecval.push_back(10812);
835	+	replacement_map.stm[10811] = vecval;
836	+	vecval.clear();
837	+	vecval.push_back(10813);
838	+	replacement_map.stm[10812] = vecval;
839	+	vecval.clear();
840	+	vecval.push_back(10814);
841	+	replacement_map.stm[10813] = vecval;
842	+	vecval.clear();
843	+	vecval.push_back(10815);
844	+	replacement_map.stm[10814] = vecval;
845	+	vecval.clear();
846	+	vecval.push_back(10816);
847	+	replacement_map.stm[10815] = vecval;
848	+	vecval.clear();
849	+	vecval.push_back(10817);
850	+	replacement_map.stm[10816] = vecval;
851	+	vecval.clear();
852	+	vecval.push_back(10818);
853	+	replacement_map.stm[10817] = vecval;
854	+	vecval.clear();
855	+	vecval.push_back(10819);
856	+	replacement_map.stm[10818] = vecval;
857	+	vecval.clear();
858	+	vecval.push_back(10820);
859	+	replacement_map.stm[10819] = vecval;
860	+	vecval.clear();
861	+	vecval.push_back(10821);
862	+	replacement_map.stm[10820] = vecval;
863	+	vecval.clear();
864	+	vecval.push_back(10822);
865	+	replacement_map.stm[10821] = vecval;
866	+	vecval.clear();
867	+	vecval.push_back(10823);
868	+	replacement_map.stm[10822] = vecval;
869	+	vecval.clear();
870	+	vecval.push_back(10824);
871	+	replacement_map.stm[10823] = vecval;
872	+	vecval.clear();
873	+	vecval.push_back(10825);
874	+	replacement_map.stm[10824] = vecval;
875	+	vecval.clear();
876	+	vecval.push_back(10826);
877	+	replacement_map.stm[10825] = vecval;
878	+	vecval.clear();
879	+	vecval.push_back(10827);
880	+	replacement_map.stm[10826] = vecval;
881	+	vecval.clear();
882	+	vecval.push_back(10828);
883	+	replacement_map.stm[10827] = vecval;
884	+	vecval.clear();
885	+	vecval.push_back(10829);
886	+	replacement_map.stm[10828] = vecval;
887	+	vecval.clear();
888	+	vecval.push_back(10830);
889	+	replacement_map.stm[10829] = vecval;
890	+	vecval.clear();
891	+	vecval.push_back(10831);
892	+	replacement_map.stm[10830] = vecval;
893	+	vecval.clear();
894	+	vecval.push_back(10832);
895	+	replacement_map.stm[10831] = vecval;
896	+	vecval.clear();
897	+	vecval.push_back(10833);
898	+	replacement_map.stm[10832] = vecval;
899	+	vecval.clear();
900	+	vecval.push_back(10834);
901	+	replacement_map.stm[10833] = vecval;
902	+	vecval.clear();
903	+	vecval.push_back(10835);
904	+	replacement_map.stm[10834] = vecval;
905	+	vecval.clear();
906	+	vecval.push_back(10836);
907	+	replacement_map.stm[10835] = vecval;
908	+	vecval.clear();
909	+	vecval.push_back(10837);
910	+	replacement_map.stm[10836] = vecval;
911	+	vecval.clear();
912	+	vecval.push_back(10838);
913	+	replacement_map.stm[10837] = vecval;
914	+	vecval.clear();
915	+	vecval.push_back(10839);
916	+	replacement_map.stm[10838] = vecval;
917	+	vecval.clear();
918	+	vecval.push_back(10840);
919	+	replacement_map.stm[10839] = vecval;
920	+	vecval.clear();
921	+	vecval.push_back(10841);
922	+	replacement_map.stm[10840] = vecval;
923	+	vecval.clear();
924	+	vecval.push_back(10842);
925	+	replacement_map.stm[10841] = vecval;
926	+	vecval.clear();
927	+	vecval.push_back(10843);
928	+	replacement_map.stm[10842] = vecval;
929	+	vecval.clear();
930	+	vecval.push_back(10844);
931	+	replacement_map.stm[10843] = vecval;
932	+	vecval.clear();
933	+	vecval.push_back(10845);
934	+	replacement_map.stm[10844] = vecval;
935	+	vecval.clear();
936	+	vecval.push_back(10846);
937	+	replacement_map.stm[10845] = vecval;
938	+	vecval.clear();
939	+	vecval.push_back(10847);
940	+	replacement_map.stm[10846] = vecval;
941	+	vecval.clear();
942	+	vecval.push_back(10848);
943	+	replacement_map.stm[10847] = vecval;
944	+	vecval.clear();
945	+	vecval.push_back(10849);
946	+	replacement_map.stm[10848] = vecval;
947	+	vecval.clear();
948	+	vecval.push_back(10850);
949	+	replacement_map.stm[10849] = vecval;
950	+	vecval.clear();
951	+	vecval.push_back(10851);
952	+	replacement_map.stm[10850] = vecval;
953	+	vecval.clear();
954	+	vecval.push_back(10852);
955	+	replacement_map.stm[10851] = vecval;
956	+	vecval.clear();
957	+	vecval.push_back(10853);
958	+	replacement_map.stm[10852] = vecval;
959	+	vecval.clear();
960	+	vecval.push_back(10854);
961	+	replacement_map.stm[10853] = vecval;
962	+	vecval.clear();
963	+	vecval.push_back(10855);
964	+	replacement_map.stm[10854] = vecval;
965	+	vecval.clear();
966	+	vecval.push_back(10856);
967	+	replacement_map.stm[10855] = vecval;
968	+	vecval.clear();
969	+	vecval.push_back(10857);
970	+	replacement_map.stm[10856] = vecval;
971	+	vecval.clear();
972	+	vecval.push_back(10858);
973	+	replacement_map.stm[10857] = vecval;
974	+	vecval.clear();
975	+	vecval.push_back(10859);
976	+	replacement_map.stm[10858] = vecval;
977	+	vecval.clear();
978	+	vecval.push_back(10860);
979	+	replacement_map.stm[10859] = vecval;
980	+	vecval.clear();
981	+	vecval.push_back(10861);
982	+	replacement_map.stm[10860] = vecval;
983	+	vecval.clear();
984	+	vecval.push_back(10862);
985	+	replacement_map.stm[10861] = vecval;
986	+	vecval.clear();
987	+	vecval.push_back(10863);
988	+	replacement_map.stm[10862] = vecval;
989	+	vecval.clear();
990	+	vecval.push_back(10864);
991	+	replacement_map.stm[10863] = vecval;
992	+	vecval.clear();
993	+	vecval.push_back(10865);
994	+	replacement_map.stm[10864] = vecval;
995	+	vecval.clear();
996	+	vecval.push_back(10866);
997	+	replacement_map.stm[10865] = vecval;
998	+	vecval.clear();
999	+	vecval.push_back(10867);
1000	+	replacement_map.stm[10866] = vecval;
1001	+	vecval.clear();
1002	+	vecval.push_back(10868);
1003	+	replacement_map.stm[10867] = vecval;
1004	+	vecval.clear();
1005	+	vecval.push_back(10869);
1006	+	replacement_map.stm[10868] = vecval;
1007	+	vecval.clear();
1008	+	vecval.push_back(10870);
1009	+	replacement_map.stm[10869] = vecval;
1010	+	vecval.clear();
1011	+	vecval.push_back(10871);
1012	+	replacement_map.stm[10870] = vecval;
1013	+	vecval.clear();
1014	+	vecval.push_back(10872);
1015	+	replacement_map.stm[10871] = vecval;
1016	+	vecval.clear();
1017	+	vecval.push_back(10873);
1018	+	replacement_map.stm[10872] = vecval;
1019	+	vecval.clear();
1020	+	vecval.push_back(10874);
1021	+	replacement_map.stm[10873] = vecval;
1022	+	vecval.clear();
1023	+	vecval.push_back(10875);
1024	+	replacement_map.stm[10874] = vecval;
1025	+	vecval.clear();
1026	+	vecval.push_back(10876);
1027	+	replacement_map.stm[10875] = vecval;
1028	+	vecval.clear();
1029	+	vecval.push_back(10877);
1030	+	replacement_map.stm[10876] = vecval;
1031	+	vecval.clear();
1032	+	vecval.push_back(10878);
1033	+	replacement_map.stm[10877] = vecval;
1034	+	vecval.clear();
1035	+	vecval.push_back(10879);
1036	+	replacement_map.stm[10878] = vecval;
1037	+	vecval.clear();
1038	+	vecval.push_back(10880);
1039	+	replacement_map.stm[10879] = vecval;
1040	+	vecval.clear();
1041	+	vecval.push_back(10881);
1042	+	replacement_map.stm[10880] = vecval;
1043	+	vecval.clear();
1044	+	vecval.push_back(10882);
1045	+	replacement_map.stm[10881] = vecval;
1046	+	vecval.clear();
1047	+	vecval.push_back(10883);
1048	+	replacement_map.stm[10882] = vecval;
1049	+	vecval.clear();
1050	+	vecval.push_back(10884);
1051	+	replacement_map.stm[10883] = vecval;
1052	+	vecval.clear();
1053	+	vecval.push_back(10885);
1054	+	replacement_map.stm[10884] = vecval;
1055	+	vecval.clear();
1056	+	vecval.push_back(10886);
1057	+	replacement_map.stm[10885] = vecval;
1058	+	vecval.clear();
1059	+	vecval.push_back(10887);
1060	+	replacement_map.stm[10886] = vecval;
1061	+	vecval.clear();
1062	+	vecval.push_back(10888);
1063	+	replacement_map.stm[10887] = vecval;
1064	+	vecval.clear();
1065	+	vecval.push_back(10889);
1066	+	replacement_map.stm[10888] = vecval;
1067	+	vecval.clear();
1068	+	vecval.push_back(10890);
1069	+	replacement_map.stm[10889] = vecval;
1070	+	vecval.clear();
1071	+	vecval.push_back(10891);
1072	+	replacement_map.stm[10890] = vecval;
1073	+	vecval.clear();
1074	+	vecval.push_back(10892);
1075	+	replacement_map.stm[10891] = vecval;
1076	+	vecval.clear();
1077	+	vecval.push_back(10893);
1078	+	replacement_map.stm[10892] = vecval;
1079	+	vecval.clear();
1080	+	vecval.push_back(10894);
1081	+	replacement_map.stm[10893] = vecval;
1082	+	vecval.clear();
1083	+	vecval.push_back(10895);
1084	+	replacement_map.stm[10894] = vecval;
1085	+	vecval.clear();
1086	+	vecval.push_back(10896);
1087	+	replacement_map.stm[10895] = vecval;
1088	+	vecval.clear();
1089	+	vecval.push_back(10897);
1090	+	replacement_map.stm[10896] = vecval;
1091	+	vecval.clear();
1092	+	vecval.push_back(10898);
1093	+	replacement_map.stm[10897] = vecval;
1094	+	vecval.clear();
1095	+	vecval.push_back(10899);
1096	+	replacement_map.stm[10898] = vecval;
1097	+	vecval.clear();
1098	+	vecval.push_back(10900);
1099	+	replacement_map.stm[10899] = vecval;
1100	+	vecval.clear();
1101	+	vecval.push_back(10901);
1102	+	replacement_map.stm[10900] = vecval;
1103	+	vecval.clear();
1104	+	vecval.push_back(10902);
1105	+	replacement_map.stm[10901] = vecval;
1106	+	vecval.clear();
1107	+	vecval.push_back(10903);
1108	+	replacement_map.stm[10902] = vecval;
1109	+	vecval.clear();
1110	+	vecval.push_back(10904);
1111	+	replacement_map.stm[10903] = vecval;
1112	+	vecval.clear();
1113	+	vecval.push_back(10905);
1114	+	replacement_map.stm[10904] = vecval;
1115	+	vecval.clear();
1116	+	vecval.push_back(10906);
1117	+	replacement_map.stm[10905] = vecval;
1118	+	vecval.clear();
1119	+	vecval.push_back(10907);
1120	+	replacement_map.stm[10906] = vecval;
1121	+	vecval.clear();
1122	+	vecval.push_back(10908);
1123	+	replacement_map.stm[10907] = vecval;
1124	+	vecval.clear();
1125	+	vecval.push_back(10909);
1126	+	replacement_map.stm[10908] = vecval;
1127	+	vecval.clear();
1128	+	vecval.push_back(10910);
1129	+	replacement_map.stm[10909] = vecval;
1130	+	vecval.clear();
1131	+	vecval.push_back(10911);
1132	+	replacement_map.stm[10910] = vecval;
1133	+	vecval.clear();
1134	+	vecval.push_back(10912);
1135	+	replacement_map.stm[10911] = vecval;
1136	+	vecval.clear();
1137	+	vecval.push_back(10913);
1138	+	replacement_map.stm[10912] = vecval;
1139	+	vecval.clear();
1140	+	vecval.push_back(10914);
1141	+	replacement_map.stm[10913] = vecval;
1142	+	vecval.clear();
1143	+	vecval.push_back(10915);
1144	+	replacement_map.stm[10914] = vecval;
1145	+	vecval.clear();
1146	+	vecval.push_back(10916);
1147	+	replacement_map.stm[10915] = vecval;
1148	+	vecval.clear();
1149	+	vecval.push_back(10917);
1150	+	replacement_map.stm[10916] = vecval;
1151	+	vecval.clear();
1152	+	vecval.push_back(10918);
1153	+	replacement_map.stm[10917] = vecval;
1154	+	vecval.clear();
1155	+	vecval.push_back(10919);
1156	+	replacement_map.stm[10918] = vecval;
1157	+	vecval.clear();
1158	+	vecval.push_back(10920);
1159	+	replacement_map.stm[10919] = vecval;
1160	+	vecval.clear();
1161	+	vecval.push_back(10921);
1162	+	replacement_map.stm[10920] = vecval;
1163	+	vecval.clear();
1164	+	vecval.push_back(10922);
1165	+	replacement_map.stm[10921] = vecval;
1166	+	vecval.clear();
1167	+	vecval.push_back(10923);
1168	+	replacement_map.stm[10922] = vecval;
1169	+	vecval.clear();
1170	+	vecval.push_back(10924);
1171	+	replacement_map.stm[10923] = vecval;
1172	+	vecval.clear();
1173	+	vecval.push_back(10925);
1174	+	replacement_map.stm[10924] = vecval;
1175	+	vecval.clear();
1176	+	vecval.push_back(10926);
1177	+	replacement_map.stm[10925] = vecval;
1178	+	vecval.clear();
1179	+	vecval.push_back(10927);
1180	+	replacement_map.stm[10926] = vecval;
1181	+	vecval.clear();
1182	+	vecval.push_back(10928);
1183	+	replacement_map.stm[10927] = vecval;
1184	+	vecval.clear();
1185	+	vecval.push_back(10929);
1186	+	replacement_map.stm[10928] = vecval;
1187	+	vecval.clear();
1188	+	vecval.push_back(10930);
1189	+	replacement_map.stm[10929] = vecval;
1190	+	vecval.clear();
1191	+	vecval.push_back(10931);
1192	+	replacement_map.stm[10930] = vecval;
1193	+	vecval.clear();
1194	+	vecval.push_back(10932);
1195	+	replacement_map.stm[10931] = vecval;
1196	+	vecval.clear();
1197	+	vecval.push_back(10933);
1198	+	replacement_map.stm[10932] = vecval;
1199	+	vecval.clear();
1200	+	vecval.push_back(10934);
1201	+	replacement_map.stm[10933] = vecval;
1202	+	vecval.clear();
1203	+	vecval.push_back(10935);
1204	+	replacement_map.stm[10934] = vecval;
1205	+	vecval.clear();
1206	+	vecval.push_back(10936);
1207	+	replacement_map.stm[10935] = vecval;
1208	+	vecval.clear();
1209	+	vecval.push_back(10937);
1210	+	replacement_map.stm[10936] = vecval;
1211	+	vecval.clear();
1212	+	vecval.push_back(10938);
1213	+	replacement_map.stm[10937] = vecval;
1214	+	vecval.clear();
1215	+	vecval.push_back(10939);
1216	+	replacement_map.stm[10938] = vecval;
1217	+	vecval.clear();
1218	+	vecval.push_back(10940);
1219	+	replacement_map.stm[10939] = vecval;
1220	+	vecval.clear();
1221	+	vecval.push_back(10941);
1222	+	replacement_map.stm[10940] = vecval;
1223	+	vecval.clear();
1224	+	vecval.push_back(10942);
1225	+	replacement_map.stm[10941] = vecval;
1226	+	vecval.clear();
1227	+	vecval.push_back(10943);
1228	+	replacement_map.stm[10942] = vecval;
1229	+	vecval.clear();
1230	+	vecval.push_back(10944);
1231	+	replacement_map.stm[10943] = vecval;
1232	+	vecval.clear();
1233	+	vecval.push_back(10945);
1234	+	replacement_map.stm[10944] = vecval;
1235	+	vecval.clear();
1236	+	vecval.push_back(10946);
1237	+	replacement_map.stm[10945] = vecval;
1238	+	vecval.clear();
1239	+	vecval.push_back(10947);
1240	+	replacement_map.stm[10946] = vecval;
1241	+	vecval.clear();
1242	+	vecval.push_back(10948);
1243	+	replacement_map.stm[10947] = vecval;
1244	+	vecval.clear();
1245	+	vecval.push_back(10949);
1246	+	replacement_map.stm[10948] = vecval;
1247	+	vecval.clear();
1248	+	vecval.push_back(10950);
1249	+	replacement_map.stm[10949] = vecval;
1250	+	vecval.clear();
1251	+	vecval.push_back(10951);
1252	+	replacement_map.stm[10950] = vecval;
1253	+	vecval.clear();
1254	+	vecval.push_back(10952);
1255	+	replacement_map.stm[10951] = vecval;
1256	+	vecval.clear();
1257	+	vecval.push_back(10953);
1258	+	replacement_map.stm[10952] = vecval;
1259	+	vecval.clear();
1260	+	vecval.push_back(10954);
1261	+	replacement_map.stm[10953] = vecval;
1262	+	vecval.clear();
1263	+	vecval.push_back(10955);
1264	+	replacement_map.stm[10954] = vecval;
1265	+	vecval.clear();
1266	+	vecval.push_back(10956);
1267	+	replacement_map.stm[10955] = vecval;
1268	+	vecval.clear();
1269	+	vecval.push_back(10957);
1270	+	replacement_map.stm[10956] = vecval;
1271	+	vecval.clear();
1272	+	vecval.push_back(10958);
1273	+	replacement_map.stm[10957] = vecval;
1274	+	vecval.clear();
1275	+	vecval.push_back(10959);
1276	+	replacement_map.stm[10958] = vecval;
1277	+	vecval.clear();
1278	+	vecval.push_back(10960);
1279	+	replacement_map.stm[10959] = vecval;
1280	+	vecval.clear();
1281	+	vecval.push_back(10961);
1282	+	replacement_map.stm[10960] = vecval;
1283	+	vecval.clear();
1284	+	vecval.push_back(10962);
1285	+	replacement_map.stm[10961] = vecval;
1286	+	vecval.clear();
1287	+	vecval.push_back(10963);
1288	+	replacement_map.stm[10962] = vecval;
1289	+	vecval.clear();
1290	+	vecval.push_back(10964);
1291	+	replacement_map.stm[10963] = vecval;
1292	+	vecval.clear();
1293	+	vecval.push_back(10965);
1294	+	replacement_map.stm[10964] = vecval;
1295	+	vecval.clear();
1296	+	vecval.push_back(10966);
1297	+	replacement_map.stm[10965] = vecval;
1298	+	vecval.clear();
1299	+	vecval.push_back(10967);
1300	+	replacement_map.stm[10966] = vecval;
1301	+	vecval.clear();
1302	+	vecval.push_back(10968);
1303	+	replacement_map.stm[10967] = vecval;
1304	+	vecval.clear();
1305	+	vecval.push_back(10969);
1306	+	replacement_map.stm[10968] = vecval;
1307	+	vecval.clear();
1308	+	vecval.push_back(10970);
1309	+	replacement_map.stm[10969] = vecval;
1310	+	vecval.clear();
1311	+	vecval.push_back(10971);
1312	+	replacement_map.stm[10970] = vecval;
1313	+	vecval.clear();
1314	+	vecval.push_back(10972);
1315	+	replacement_map.stm[10971] = vecval;
1316	+	vecval.clear();
1317	+	vecval.push_back(10973);
1318	+	replacement_map.stm[10972] = vecval;
1319	+	vecval.clear();
1320	+	vecval.push_back(10974);
1321	+	replacement_map.stm[10973] = vecval;
1322	+	vecval.clear();
1323	+	vecval.push_back(10975);
1324	+	replacement_map.stm[10974] = vecval;
1325	+	vecval.clear();
1326	+	vecval.push_back(10976);
1327	+	replacement_map.stm[10975] = vecval;
1328	+	vecval.clear();
1329	+	vecval.push_back(10977);
1330	+	replacement_map.stm[10976] = vecval;
1331	+	vecval.clear();
1332	+	vecval.push_back(10978);
1333	+	replacement_map.stm[10977] = vecval;
1334	+	vecval.clear();
1335	+	vecval.push_back(10979);
1336	+	replacement_map.stm[10978] = vecval;
1337	+	vecval.clear();
1338	+	vecval.push_back(10980);
1339	+	replacement_map.stm[10979] = vecval;
1340	+	vecval.clear();
1341	+	vecval.push_back(10981);
1342	+	replacement_map.stm[10980] = vecval;
1343	+	vecval.clear();
1344	+	vecval.push_back(10982);
1345	+	replacement_map.stm[10981] = vecval;
1346	+	vecval.clear();
1347	+	vecval.push_back(10983);
1348	+	replacement_map.stm[10982] = vecval;
1349	+	vecval.clear();
1350	+	vecval.push_back(10984);
1351	+	replacement_map.stm[10983] = vecval;
1352	+	vecval.clear();
1353	+	vecval.push_back(10986);
1354	+	replacement_map.stm[10984] = vecval;
1355	+	vecval.clear();
1356	+	vecval.push_back(10987);
1357	+	replacement_map.stm[10985] = vecval;
1358	+	vecval.clear();
1359	+	vecval.push_back(10988);
1360	+	replacement_map.stm[10986] = vecval;
1361	+	vecval.clear();
1362	+	vecval.push_back(10989);
1363	+	replacement_map.stm[10987] = vecval;
1364	+	vecval.clear();
1365	+	vecval.push_back(10990);
1366	+	replacement_map.stm[10988] = vecval;
1367	+	vecval.clear();
1368	+	vecval.push_back(10991);
1369	+	replacement_map.stm[10989] = vecval;
1370	+	vecval.clear();
1371	+	vecval.push_back(10992);
1372	+	replacement_map.stm[10990] = vecval;
1373	+	vecval.clear();
1374	+	vecval.push_back(10993);
1375	+	replacement_map.stm[10991] = vecval;
1376	+	vecval.clear();
1377	+	vecval.push_back(10994);
1378	+	replacement_map.stm[10992] = vecval;
1379	+	vecval.clear();
1380	+	vecval.push_back(10995);
1381	+	replacement_map.stm[10993] = vecval;
1382	+	vecval.clear();
1383	+	vecval.push_back(10996);
1384	+	replacement_map.stm[10994] = vecval;
1385	+	vecval.clear();
1386	+	vecval.push_back(10997);
1387	+	replacement_map.stm[10995] = vecval;
1388	+	vecval.clear();
1389	+	vecval.push_back(10998);
1390	+	replacement_map.stm[10996] = vecval;
1391	+	vecval.clear();
1392	+	vecval.push_back(10999);
1393	+	replacement_map.stm[10997] = vecval;
1394	+	vecval.clear();
1395	+	vecval.push_back(11000);
1396	+	replacement_map.stm[10998] = vecval;
1397	+	vecval.clear();
1398	+	vecval.push_back(11001);
1399	+	replacement_map.stm[10999] = vecval;
1400	+	vecval.clear();
1401	+	vecval.push_back(11002);
1402	+	replacement_map.stm[11000] = vecval;
1403	+	vecval.clear();
1404	+	vecval.push_back(11003);
1405	+	replacement_map.stm[11001] = vecval;
1406	+	vecval.clear();
1407	+	vecval.push_back(11004);
1408	+	replacement_map.stm[11002] = vecval;
1409	+	vecval.clear();
1410	+	vecval.push_back(11005);
1411	+	replacement_map.stm[11003] = vecval;
1412	+	vecval.clear();
1413	+	vecval.push_back(11006);
1414	+	replacement_map.stm[11004] = vecval;
1415	+	vecval.clear();
1416	+	vecval.push_back(11007);
1417	+	replacement_map.stm[11005] = vecval;
1418	+	vecval.clear();
1419	+	vecval.push_back(11008);
1420	+	replacement_map.stm[11006] = vecval;
1421	+	vecval.clear();
1422	+	vecval.push_back(11009);
1423	+	replacement_map.stm[11007] = vecval;
1424	+	vecval.clear();
1425	+	vecval.push_back(11010);
1426	+	replacement_map.stm[11008] = vecval;
1427	+	vecval.clear();
1428	+	vecval.push_back(11011);
1429	+	replacement_map.stm[11009] = vecval;
1430	+	vecval.clear();
1431	+	vecval.push_back(11012);
1432	+	replacement_map.stm[11010] = vecval;
1433	+	vecval.clear();
1434	+	vecval.push_back(11013);
1435	+	replacement_map.stm[11011] = vecval;
1436	+	vecval.clear();
1437	+	vecval.push_back(11015);
1438	+	replacement_map.stm[11012] = vecval;
1439	+	vecval.clear();
1440	+	vecval.push_back(11016);
1441	+	replacement_map.stm[11013] = vecval;
1442	+	vecval.clear();
1443	+	vecval.push_back(11017);
1444	+	replacement_map.stm[11014] = vecval;
1445	+	vecval.clear();
1446	+	vecval.push_back(11018);
1447	+	replacement_map.stm[11015] = vecval;
1448	+	vecval.clear();
1449	+	vecval.push_back(11019);
1450	+	replacement_map.stm[11016] = vecval;
1451	+	vecval.clear();
1452	+	vecval.push_back(11020);
1453	+	replacement_map.stm[11017] = vecval;
1454	+	vecval.clear();
1455	+	vecval.push_back(11021);
1456	+	replacement_map.stm[11018] = vecval;
1457	+	vecval.clear();
1458	+	vecval.push_back(11022);
1459	+	replacement_map.stm[11019] = vecval;
1460	+	vecval.clear();
1461	+	vecval.push_back(11023);
1462	+	replacement_map.stm[11020] = vecval;
1463	+	vecval.clear();
1464	+	vecval.push_back(11024);
1465	+	replacement_map.stm[11021] = vecval;
1466	+	vecval.clear();
1467	+	vecval.push_back(11025);
1468	+	replacement_map.stm[11022] = vecval;
1469	+	vecval.clear();
1470	+	vecval.push_back(11026);
1471	+	replacement_map.stm[11023] = vecval;
1472	+	vecval.clear();
1473	+	vecval.push_back(11027);
1474	+	replacement_map.stm[11024] = vecval;
1475	+	vecval.clear();
1476	+	vecval.push_back(11028);
1477	+	replacement_map.stm[11025] = vecval;
1478	+	vecval.clear();
1479	+	vecval.push_back(11029);
1480	+	replacement_map.stm[11026] = vecval;
1481	+	vecval.clear();
1482	+	vecval.push_back(11030);
1483	+	replacement_map.stm[11027] = vecval;
1484	+	vecval.clear();
1485	+	vecval.push_back(11031);
1486	+	replacement_map.stm[11028] = vecval;
1487	+	vecval.clear();
1488	+	vecval.push_back(11032);
1489	+	replacement_map.stm[11029] = vecval;
1490	+	vecval.clear();
1491	+	vecval.push_back(11033);
1492	+	replacement_map.stm[11030] = vecval;
1493	+	vecval.clear();
1494	+	vecval.push_back(11034);
1495	+	replacement_map.stm[11031] = vecval;
1496	+	vecval.clear();
1497	+	vecval.push_back(11035);
1498	+	replacement_map.stm[11032] = vecval;
1499	+	vecval.clear();
1500	+	vecval.push_back(11036);
1501	+	replacement_map.stm[11033] = vecval;
1502	+	vecval.clear();
1503	+	vecval.push_back(11037);
1504	+	replacement_map.stm[11034] = vecval;
1505	+	vecval.clear();
1506	+	vecval.push_back(11038);
1507	+	replacement_map.stm[11035] = vecval;
1508	+	vecval.clear();
1509	+	vecval.push_back(11039);
1510	+	replacement_map.stm[11036] = vecval;
1511	+	vecval.clear();
1512	+	vecval.push_back(11040);
1513	+	replacement_map.stm[11037] = vecval;
1514	+	vecval.clear();
1515	+	vecval.push_back(11041);
1516	+	replacement_map.stm[11038] = vecval;
1517	+	vecval.clear();
1518	+	vecval.push_back(11042);
1519	+	replacement_map.stm[11039] = vecval;
1520	+	vecval.clear();
1521	+	vecval.push_back(11043);
1522	+	replacement_map.stm[11040] = vecval;
1523	+	vecval.clear();
1524	+	vecval.push_back(11044);
1525	+	replacement_map.stm[11041] = vecval;
1526	+	vecval.clear();
1527	+	vecval.push_back(11045);
1528	+	replacement_map.stm[11042] = vecval;
1529	+	vecval.clear();
1530	+	vecval.push_back(11046);
1531	+	replacement_map.stm[11043] = vecval;
1532	+	vecval.clear();
1533	+	vecval.push_back(11047);
1534	+	replacement_map.stm[11044] = vecval;
1535	+	vecval.clear();
1536	+	vecval.push_back(11048);
1537	+	replacement_map.stm[11045] = vecval;
1538	+	vecval.clear();
1539	+	vecval.push_back(11049);
1540	+	replacement_map.stm[11046] = vecval;
1541	+	vecval.clear();
1542	+	vecval.push_back(11050);
1543	+	replacement_map.stm[11047] = vecval;
1544	+	vecval.clear();
1545	+	vecval.push_back(11051);
1546	+	replacement_map.stm[11048] = vecval;
1547	+	vecval.clear();
1548	+	vecval.push_back(11052);
1549	+	replacement_map.stm[11049] = vecval;
1550	+	vecval.clear();
1551	+	vecval.push_back(11053);
1552	+	replacement_map.stm[11050] = vecval;
1553	+	vecval.clear();
1554	+	vecval.push_back(11054);
1555	+	replacement_map.stm[11051] = vecval;
1556	+	vecval.clear();
1557	+	vecval.push_back(11055);
1558	+	replacement_map.stm[11052] = vecval;
1559	+	vecval.clear();
1560	+	vecval.push_back(11056);
1561	+	replacement_map.stm[11053] = vecval;
1562	+	vecval.clear();
1563	+	vecval.push_back(11057);
1564	+	replacement_map.stm[11054] = vecval;
1565	+	vecval.clear();
1566	+	vecval.push_back(11058);
1567	+	replacement_map.stm[11055] = vecval;
1568	+	vecval.clear();
1569	+	vecval.push_back(11059);
1570	+	replacement_map.stm[11056] = vecval;
1571	+	vecval.clear();
1572	+	vecval.push_back(11060);
1573	+	replacement_map.stm[11057] = vecval;
1574	+	vecval.clear();
1575	+	vecval.push_back(11061);
1576	+	replacement_map.stm[11058] = vecval;
1577	+	vecval.clear();
1578	+	vecval.push_back(11062);
1579	+	replacement_map.stm[11059] = vecval;
1580	+	vecval.clear();
1581	+	vecval.push_back(11063);
1582	+	replacement_map.stm[11060] = vecval;
1583	+	vecval.clear();
1584	+	vecval.push_back(11064);
1585	+	replacement_map.stm[11061] = vecval;
1586	+	vecval.clear();
1587	+	vecval.push_back(11065);
1588	+	replacement_map.stm[11062] = vecval;
1589	+	vecval.clear();
1590	+	vecval.push_back(11066);
1591	+	replacement_map.stm[11063] = vecval;
1592	+	vecval.clear();
1593	+	vecval.push_back(11067);
1594	+	replacement_map.stm[11064] = vecval;
1595	+	vecval.clear();
1596	+	vecval.push_back(11068);
1597	+	replacement_map.stm[11065] = vecval;
1598	+	vecval.clear();
1599	+	vecval.push_back(11069);
1600	+	replacement_map.stm[11066] = vecval;
1601	+	vecval.clear();
1602	+	vecval.push_back(11070);
1603	+	replacement_map.stm[11067] = vecval;
1604	+	vecval.clear();
1605	+	vecval.push_back(11071);
1606	+	replacement_map.stm[11068] = vecval;
1607	+	vecval.clear();
1608	+	vecval.push_back(11072);
1609	+	replacement_map.stm[11069] = vecval;
1610	+	vecval.clear();
1611	+	vecval.push_back(11073);
1612	+	replacement_map.stm[11070] = vecval;
1613	+	vecval.clear();
1614	+	vecval.push_back(11074);
1615	+	replacement_map.stm[11071] = vecval;
1616	+	vecval.clear();
1617	+	vecval.push_back(11075);
1618	+	replacement_map.stm[11072] = vecval;
1619	+	vecval.clear();
1620	+	vecval.push_back(11076);
1621	+	replacement_map.stm[11073] = vecval;
1622	+	vecval.clear();
1623	+	vecval.push_back(11077);
1624	+	replacement_map.stm[11074] = vecval;
1625	+	vecval.clear();
1626	+	vecval.push_back(11078);
1627	+	replacement_map.stm[11075] = vecval;
1628	+	vecval.clear();
1629	+	vecval.push_back(11079);
1630	+	replacement_map.stm[11076] = vecval;
1631	+	vecval.clear();
1632	+	vecval.push_back(11080);
1633	+	replacement_map.stm[11077] = vecval;
1634	+	vecval.clear();
1635	+	vecval.push_back(11081);
1636	+	replacement_map.stm[11078] = vecval;
1637	+	vecval.clear();
1638	+	vecval.push_back(11082);
1639	+	replacement_map.stm[11079] = vecval;
1640	+	vecval.clear();
1641	+	vecval.push_back(11083);
1642	+	replacement_map.stm[11080] = vecval;
1643	+	vecval.clear();
1644	+	vecval.push_back(11084);
1645	+	replacement_map.stm[11081] = vecval;
1646	+	vecval.clear();
1647	+	vecval.push_back(11085);
1648	+	replacement_map.stm[11082] = vecval;
1649	+	vecval.clear();
1650	+	vecval.push_back(11086);
1651	+	replacement_map.stm[11083] = vecval;
1652	+	vecval.clear();
1653	+	vecval.push_back(11087);
1654	+	replacement_map.stm[11084] = vecval;
1655	+	vecval.clear();
1656	+	vecval.push_back(11088);
1657	+	replacement_map.stm[11085] = vecval;
1658	+	vecval.clear();
1659	+	vecval.push_back(11089);
1660	+	replacement_map.stm[11086] = vecval;
1661	+	vecval.clear();
1662	+	vecval.push_back(11090);
1663	+	replacement_map.stm[11087] = vecval;
1664	+	vecval.clear();
1665	+	vecval.push_back(11091);
1666	+	replacement_map.stm[11088] = vecval;
1667	+	vecval.clear();
1668	+	vecval.push_back(11092);
1669	+	replacement_map.stm[11089] = vecval;
1670	+	vecval.clear();
1671	+	vecval.push_back(11093);
1672	+	replacement_map.stm[11090] = vecval;
1673	+	vecval.clear();
1674	+	vecval.push_back(11094);
1675	+	replacement_map.stm[11091] = vecval;
1676	+	vecval.clear();
1677	+	vecval.push_back(11095);
1678	+	replacement_map.stm[11092] = vecval;
1679	+	vecval.clear();
1680	+	vecval.push_back(11096);
1681	+	replacement_map.stm[11093] = vecval;
1682	+	vecval.clear();
1683	+	vecval.push_back(11097);
1684	+	replacement_map.stm[11094] = vecval;
1685	+	vecval.clear();
1686	+	vecval.push_back(11098);
1687	+	replacement_map.stm[11095] = vecval;
1688	+	vecval.clear();
1689	+	vecval.push_back(11099);
1690	+	replacement_map.stm[11096] = vecval;
1691	+	vecval.clear();
1692	+	vecval.push_back(11100);
1693	+	replacement_map.stm[11097] = vecval;
1694	+	vecval.clear();
1695	+	vecval.push_back(11101);
1696	+	replacement_map.stm[11098] = vecval;
1697	+	vecval.clear();
1698	+	vecval.push_back(11102);
1699	+	replacement_map.stm[11099] = vecval;
1700	+	vecval.clear();
1701	+	vecval.push_back(11103);
1702	+	replacement_map.stm[11100] = vecval;
1703	+	vecval.clear();
1704	+	vecval.push_back(11104);
1705	+	replacement_map.stm[11101] = vecval;
1706	+	vecval.clear();
1707	+	vecval.push_back(11106);
1708	+	replacement_map.stm[11102] = vecval;
1709	+	vecval.clear();
1710	+	vecval.push_back(11107);
1711	+	replacement_map.stm[11103] = vecval;
1712	+	vecval.clear();
1713	+	vecval.push_back(11108);
1714	+	replacement_map.stm[11104] = vecval;
1715	+	vecval.clear();
1716	+	vecval.push_back(11109);
1717	+	replacement_map.stm[11105] = vecval;
1718	+	vecval.clear();
1719	+	vecval.push_back(11110);
1720	+	replacement_map.stm[11106] = vecval;
1721	+	vecval.clear();
1722	+	vecval.push_back(11111);
1723	+	replacement_map.stm[11107] = vecval;
1724	+	vecval.clear();
1725	+	vecval.push_back(11112);
1726	+	replacement_map.stm[11108] = vecval;
1727	+	vecval.clear();
1728	+	vecval.push_back(11113);
1729	+	replacement_map.stm[11109] = vecval;
1730	+	vecval.clear();
1731	+	vecval.push_back(11114);
1732	+	replacement_map.stm[11110] = vecval;
1733	+	vecval.clear();
1734	+	vecval.push_back(11115);
1735	+	replacement_map.stm[11111] = vecval;
1736	+	vecval.clear();
1737	+	vecval.push_back(11116);
1738	+	replacement_map.stm[11112] = vecval;
1739	+	vecval.clear();
1740	+	vecval.push_back(11117);
1741	+	replacement_map.stm[11113] = vecval;
1742	+	vecval.clear();
1743	+	vecval.push_back(11118);
1744	+	replacement_map.stm[11114] = vecval;
1745	+	vecval.clear();
1746	+	vecval.push_back(11119);
1747	+	replacement_map.stm[11115] = vecval;
1748	+	vecval.clear();
1749	+	vecval.push_back(11122);
1750	+	replacement_map.stm[11116] = vecval;
1751	+	vecval.clear();
1752	+	vecval.push_back(11123);
1753	+	replacement_map.stm[11117] = vecval;
1754	+	vecval.clear();
1755	+	vecval.push_back(11124);
1756	+	replacement_map.stm[11118] = vecval;
1757	+	vecval.clear();
1758	+	vecval.push_back(11125);
1759	+	replacement_map.stm[11119] = vecval;
1760	+	vecval.clear();
1761	+	vecval.push_back(11126);
1762	+	replacement_map.stm[11120] = vecval;
1763	+	vecval.clear();
1764	+	vecval.push_back(11127);
1765	+	replacement_map.stm[11121] = vecval;
1766	+	vecval.clear();
1767	+	vecval.push_back(11128);
1768	+	replacement_map.stm[11122] = vecval;
1769	+	vecval.clear();
1770	+	vecval.push_back(11129);
1771	+	replacement_map.stm[11123] = vecval;
1772	+	vecval.clear();
1773	+	vecval.push_back(11130);
1774	+	replacement_map.stm[11124] = vecval;
1775	+	vecval.clear();
1776	+	vecval.push_back(11131);
1777	+	replacement_map.stm[11125] = vecval;
1778	+	vecval.clear();
1779	+	vecval.push_back(11132);
1780	+	replacement_map.stm[11126] = vecval;
1781	+	vecval.clear();
1782	+	vecval.push_back(11133);
1783	+	replacement_map.stm[11127] = vecval;
1784	+	vecval.clear();
1785	+	vecval.push_back(11134);
1786	+	replacement_map.stm[11128] = vecval;
1787	+	vecval.clear();
1788	+	vecval.push_back(11135);
1789	+	replacement_map.stm[11129] = vecval;
1790	+	vecval.clear();
1791	+	vecval.push_back(11136);
1792	+	replacement_map.stm[11130] = vecval;
1793	+	vecval.clear();
1794	+	vecval.push_back(11137);
1795	+	replacement_map.stm[11131] = vecval;
1796	+	vecval.clear();
1797	+	vecval.push_back(11138);
1798	+	replacement_map.stm[11132] = vecval;
1799	+	vecval.clear();
1800	+	vecval.push_back(11139);
1801	+	replacement_map.stm[11133] = vecval;
1802	+	vecval.clear();
1803	+	vecval.push_back(11140);
1804	+	replacement_map.stm[11134] = vecval;
1805	+	vecval.clear();
1806	+	vecval.push_back(11141);
1807	+	replacement_map.stm[11135] = vecval;
1808	+	vecval.clear();
1809	+	vecval.push_back(11142);
1810	+	replacement_map.stm[11136] = vecval;
1811	+	vecval.clear();
1812	+	vecval.push_back(11143);
1813	+	replacement_map.stm[11137] = vecval;
1814	+	vecval.clear();
1815	+	vecval.push_back(11144);
1816	+	replacement_map.stm[11138] = vecval;
1817	+	vecval.clear();
1818	+	vecval.push_back(11145);
1819	+	replacement_map.stm[11139] = vecval;
1820	+	vecval.clear();
1821	+	vecval.push_back(11146);
1822	+	replacement_map.stm[11140] = vecval;
1823	+	vecval.clear();
1824	+	vecval.push_back(11147);
1825	+	replacement_map.stm[11141] = vecval;
1826	+	vecval.clear();
1827	+	vecval.push_back(11148);
1828	+	replacement_map.stm[11142] = vecval;
1829	+	vecval.clear();
1830	+	vecval.push_back(11149);
1831	+	replacement_map.stm[11143] = vecval;
1832	+	vecval.clear();
1833	+	vecval.push_back(11150);
1834	+	replacement_map.stm[11144] = vecval;
1835	+	vecval.clear();
1836	+	vecval.push_back(11151);
1837	+	replacement_map.stm[11145] = vecval;
1838	+	vecval.clear();
1839	+	vecval.push_back(11152);
1840	+	replacement_map.stm[11146] = vecval;
1841	+	vecval.clear();
1842	+	vecval.push_back(11153);
1843	+	replacement_map.stm[11147] = vecval;
1844	+	vecval.clear();
1845	+	vecval.push_back(11154);
1846	+	replacement_map.stm[11148] = vecval;
1847	+	vecval.clear();
1848	+	vecval.push_back(11155);
1849	+	replacement_map.stm[11149] = vecval;
1850	+	vecval.clear();
1851	+	vecval.push_back(11156);
1852	+	replacement_map.stm[11150] = vecval;
1853	+	vecval.clear();
1854	+	vecval.push_back(11157);
1855	+	replacement_map.stm[11151] = vecval;
1856	+	vecval.clear();
1857	+	vecval.push_back(11158);
1858	+	replacement_map.stm[11152] = vecval;
1859	+	vecval.clear();
1860	+	vecval.push_back(11159);
1861	+	replacement_map.stm[11153] = vecval;
1862	+	vecval.clear();
1863	+	vecval.push_back(11160);
1864	+	replacement_map.stm[11154] = vecval;
1865	+	vecval.clear();
1866	+	vecval.push_back(11161);
1867	+	replacement_map.stm[11155] = vecval;
1868	+	vecval.clear();
1869	+	vecval.push_back(11162);
1870	+	replacement_map.stm[11156] = vecval;
1871	+	vecval.clear();
1872	+	vecval.push_back(11163);
1873	+	replacement_map.stm[11157] = vecval;
1874	+	vecval.clear();
1875	+	vecval.push_back(11164);
1876	+	replacement_map.stm[11158] = vecval;
1877	+	vecval.clear();
1878	+	vecval.push_back(11165);
1879	+	replacement_map.stm[11159] = vecval;
1880	+	vecval.clear();
1881	+	vecval.push_back(11166);
1882	+	replacement_map.stm[11160] = vecval;
1883	+	vecval.clear();
1884	+	vecval.push_back(11167);
1885	+	replacement_map.stm[11161] = vecval;
1886	+	vecval.clear();
1887	+	vecval.push_back(11168);
1888	+	replacement_map.stm[11162] = vecval;
1889	+	vecval.clear();
1890	+	vecval.push_back(11169);
1891	+	replacement_map.stm[11163] = vecval;
1892	+	vecval.clear();
1893	+	vecval.push_back(11170);
1894	+	replacement_map.stm[11164] = vecval;
1895	+	vecval.clear();
1896	+	vecval.push_back(11171);
1897	+	replacement_map.stm[11165] = vecval;
1898	+	vecval.clear();
1899	+	vecval.push_back(11172);
1900	+	replacement_map.stm[11166] = vecval;
1901	+	vecval.clear();
1902	+	vecval.push_back(11173);
1903	+	replacement_map.stm[11167] = vecval;
1904	+	vecval.clear();
1905	+	vecval.push_back(11174);
1906	+	replacement_map.stm[11168] = vecval;
1907	+	vecval.clear();
1908	+	vecval.push_back(11175);
1909	+	replacement_map.stm[11169] = vecval;
1910	+	vecval.clear();
1911	+	vecval.push_back(11176);
1912	+	replacement_map.stm[11170] = vecval;
1913	+	vecval.clear();
1914	+	vecval.push_back(11177);
1915	+	replacement_map.stm[11171] = vecval;
1916	+	vecval.clear();
1917	+	vecval.push_back(11178);
1918	+	replacement_map.stm[11172] = vecval;
1919	+	vecval.clear();
1920	+	vecval.push_back(11179);
1921	+	replacement_map.stm[11173] = vecval;
1922	+	vecval.clear();
1923	+	vecval.push_back(11180);
1924	+	replacement_map.stm[11174] = vecval;
1925	+	vecval.clear();
1926	+	vecval.push_back(11181);
1927	+	replacement_map.stm[11175] = vecval;
1928	+	vecval.clear();
1929	+	vecval.push_back(11182);
1930	+	replacement_map.stm[11176] = vecval;
1931	+	vecval.clear();
1932	+	vecval.push_back(11183);
1933	+	replacement_map.stm[11177] = vecval;
1934	+	vecval.clear();
1935	+	vecval.push_back(11184);
1936	+	replacement_map.stm[11178] = vecval;
1937	+	vecval.clear();
1938	+	vecval.push_back(11185);
1939	+	replacement_map.stm[11179] = vecval;
1940	+	vecval.clear();
1941	+	vecval.push_back(11186);
1942	+	replacement_map.stm[11180] = vecval;
1943	+	vecval.clear();
1944	+	vecval.push_back(11187);
1945	+	replacement_map.stm[11181] = vecval;
1946	+	vecval.clear();
1947	+	vecval.push_back(11188);
1948	+	replacement_map.stm[11182] = vecval;
1949	+	vecval.clear();
1950	+	vecval.push_back(11189);
1951	+	replacement_map.stm[11183] = vecval;
1952	+	vecval.clear();
1953	+	vecval.push_back(11190);
1954	+	replacement_map.stm[11184] = vecval;
1955	+	vecval.clear();
1956	+	vecval.push_back(11191);
1957	+	replacement_map.stm[11185] = vecval;
1958	+	vecval.clear();
1959	+	vecval.push_back(11192);
1960	+	replacement_map.stm[11186] = vecval;
1961	+	vecval.clear();
1962	+	vecval.push_back(11193);
1963	+	replacement_map.stm[11187] = vecval;
1964	+	vecval.clear();
1965	+	vecval.push_back(11194);
1966	+	replacement_map.stm[11188] = vecval;
1967	+	vecval.clear();
1968	+	vecval.push_back(11195);
1969	+	replacement_map.stm[11189] = vecval;
1970	+	vecval.clear();
1971	+	vecval.push_back(11196);
1972	+	replacement_map.stm[11190] = vecval;
1973	+	vecval.clear();
1974	+	vecval.push_back(11197);
1975	+	replacement_map.stm[11191] = vecval;
1976	+	vecval.clear();
1977	+	vecval.push_back(11198);
1978	+	replacement_map.stm[11192] = vecval;
1979	+	vecval.clear();
1980	+	vecval.push_back(11199);
1981	+	replacement_map.stm[11193] = vecval;
1982	+	vecval.clear();
1983	+	vecval.push_back(11200);
1984	+	replacement_map.stm[11194] = vecval;
1985	+	vecval.clear();
1986	+	vecval.push_back(11201);
1987	+	replacement_map.stm[11195] = vecval;
1988	+	vecval.clear();
1989	+	vecval.push_back(11202);
1990	+	replacement_map.stm[11196] = vecval;
1991	+	vecval.clear();
1992	+	vecval.push_back(11203);
1993	+	replacement_map.stm[11197] = vecval;
1994	+	vecval.clear();
1995	+	vecval.push_back(11204);
1996	+	replacement_map.stm[11198] = vecval;
1997	+	vecval.clear();
1998	+	vecval.push_back(11205);
1999	+	replacement_map.stm[11199] = vecval;
2000	+	vecval.clear();
2001	+	vecval.push_back(11206);
2002	+	replacement_map.stm[11200] = vecval;
2003	+	vecval.clear();
2004	+	vecval.push_back(11207);
2005	+	replacement_map.stm[11201] = vecval;
2006	+	vecval.clear();
2007	+	vecval.push_back(11208);
2008	+	replacement_map.stm[11202] = vecval;
2009	+	vecval.clear();
2010	+	vecval.push_back(11209);
2011	+	replacement_map.stm[11203] = vecval;
2012	+	vecval.clear();
2013	+	vecval.push_back(11210);
2014	+	replacement_map.stm[11204] = vecval;
2015	+	vecval.clear();
2016	+	vecval.push_back(11211);
2017	+	replacement_map.stm[11205] = vecval;
2018	+	vecval.clear();
2019	+	vecval.push_back(11212);
2020	+	replacement_map.stm[11206] = vecval;
2021	+	vecval.clear();
2022	+	vecval.push_back(11213);
2023	+	replacement_map.stm[11207] = vecval;
2024	+	vecval.clear();
2025	+	vecval.push_back(11214);
2026	+	replacement_map.stm[11208] = vecval;
2027	+	vecval.clear();
2028	+	vecval.push_back(11215);
2029	+	replacement_map.stm[11209] = vecval;
2030	+	vecval.clear();
2031	+	vecval.push_back(11216);
2032	+	replacement_map.stm[11210] = vecval;
2033	+	vecval.clear();
2034	+	vecval.push_back(11217);
2035	+	replacement_map.stm[11211] = vecval;
2036	+	vecval.clear();
2037	+	vecval.push_back(11218);
2038	+	replacement_map.stm[11212] = vecval;
2039	+	vecval.clear();
2040	+	vecval.push_back(11219);
2041	+	replacement_map.stm[11213] = vecval;
2042	+	vecval.clear();
2043	+	vecval.push_back(11220);
2044	+	replacement_map.stm[11214] = vecval;
2045	+	vecval.clear();
2046	+	vecval.push_back(11221);
2047	+	replacement_map.stm[11215] = vecval;
2048	+	vecval.clear();
2049	+	vecval.push_back(11222);
2050	+	replacement_map.stm[11216] = vecval;
2051	+	vecval.clear();
2052	+	vecval.push_back(11223);
2053	+	replacement_map.stm[11217] = vecval;
2054	+	vecval.clear();
2055	+	vecval.push_back(11224);
2056	+	replacement_map.stm[11218] = vecval;
2057	+	vecval.clear();
2058	+	vecval.push_back(11225);
2059	+	replacement_map.stm[11219] = vecval;
2060	+	vecval.clear();
2061	+	vecval.push_back(11226);
2062	+	replacement_map.stm[11220] = vecval;
2063	+	vecval.clear();
2064	+	vecval.push_back(11227);
2065	+	replacement_map.stm[11221] = vecval;
2066	+	vecval.clear();
2067	+	vecval.push_back(11228);
2068	+	replacement_map.stm[11222] = vecval;
2069	+	vecval.clear();
2070	+	vecval.push_back(11229);
2071	+	replacement_map.stm[11223] = vecval;
2072	+	vecval.clear();
2073	+	vecval.push_back(11230);
2074	+	replacement_map.stm[11224] = vecval;
2075	+	vecval.clear();
2076	+	vecval.push_back(11231);
2077	+	replacement_map.stm[11225] = vecval;
2078	+	vecval.clear();
2079	+	vecval.push_back(11232);
2080	+	replacement_map.stm[11226] = vecval;
2081	+	vecval.clear();
2082	+	vecval.push_back(11233);
2083	+	replacement_map.stm[11227] = vecval;
2084	+	vecval.clear();
2085	+	vecval.push_back(11234);
2086	+	replacement_map.stm[11228] = vecval;
2087	+	vecval.clear();
2088	+	vecval.push_back(11235);
2089	+	replacement_map.stm[11229] = vecval;
2090	+	vecval.clear();
2091	+	vecval.push_back(11236);
2092	+	replacement_map.stm[11230] = vecval;
2093	+	vecval.clear();
2094	+	vecval.push_back(11237);
2095	+	replacement_map.stm[11231] = vecval;
2096	+	vecval.clear();
2097	+	vecval.push_back(11238);
2098	+	replacement_map.stm[11232] = vecval;
2099	+	vecval.clear();
2100	+	vecval.push_back(11239);
2101	+	replacement_map.stm[11233] = vecval;
2102	+	vecval.clear();
2103	+	vecval.push_back(11240);
2104	+	replacement_map.stm[11234] = vecval;
2105	+	vecval.clear();
2106	+	vecval.push_back(11241);
2107	+	replacement_map.stm[11235] = vecval;
2108	+	vecval.clear();
2109	+	vecval.push_back(11242);
2110	+	replacement_map.stm[11236] = vecval;
2111	+	vecval.clear();
2112	+	vecval.push_back(11243);
2113	+	replacement_map.stm[11237] = vecval;
2114	+	vecval.clear();
2115	+	vecval.push_back(11244);
2116	+	replacement_map.stm[11238] = vecval;
2117	+	vecval.clear();
2118	+	vecval.push_back(11245);
2119	+	replacement_map.stm[11239] = vecval;
2120	+	vecval.clear();
2121	+	vecval.push_back(11246);
2122	+	replacement_map.stm[11240] = vecval;
2123	+	vecval.clear();
2124	+	vecval.push_back(11247);
2125	+	replacement_map.stm[11241] = vecval;
2126	+	vecval.clear();
2127	+	vecval.push_back(11248);
2128	+	replacement_map.stm[11242] = vecval;
2129	+	vecval.clear();
2130	+	vecval.push_back(11249);
2131	+	replacement_map.stm[11243] = vecval;
2132	+	vecval.clear();
2133	+	vecval.push_back(11250);
2134	+	replacement_map.stm[11244] = vecval;
2135	+	vecval.clear();
2136	+	vecval.push_back(11251);
2137	+	replacement_map.stm[11245] = vecval;
2138	+	vecval.clear();
2139	+	vecval.push_back(11252);
2140	+	replacement_map.stm[11246] = vecval;
2141	+	vecval.clear();
2142	+	vecval.push_back(11253);
2143	+	replacement_map.stm[11247] = vecval;
2144	+	vecval.clear();
2145	+	vecval.push_back(11254);
2146	+	replacement_map.stm[11248] = vecval;
2147	+	vecval.clear();
2148	+	vecval.push_back(11255);
2149	+	replacement_map.stm[11249] = vecval;
2150	+	vecval.clear();
2151	+	vecval.push_back(11256);
2152	+	replacement_map.stm[11250] = vecval;
2153	+	vecval.clear();
2154	+	vecval.push_back(11257);
2155	+	replacement_map.stm[11251] = vecval;
2156	+	vecval.clear();
2157	+	vecval.push_back(11258);
2158	+	replacement_map.stm[11252] = vecval;
2159	+	vecval.clear();
2160	+	vecval.push_back(11259);
2161	+	replacement_map.stm[11253] = vecval;
2162	+	vecval.clear();
2163	+	vecval.push_back(11260);
2164	+	replacement_map.stm[11254] = vecval;
2165	+	vecval.clear();
2166	+	vecval.push_back(11261);
2167	+	replacement_map.stm[11255] = vecval;
2168	+	vecval.clear();
2169	+	vecval.push_back(11262);
2170	+	replacement_map.stm[11256] = vecval;
2171	+	vecval.clear();
2172	+	vecval.push_back(11263);
2173	+	replacement_map.stm[11257] = vecval;
2174	+	vecval.clear();
2175	+	vecval.push_back(11264);
2176	+	replacement_map.stm[11258] = vecval;
2177	+	vecval.clear();
2178	+	vecval.push_back(11265);
2179	+	replacement_map.stm[11259] = vecval;
2180	+	vecval.clear();
2181	+	vecval.push_back(11266);
2182	+	replacement_map.stm[11260] = vecval;
2183	+	vecval.clear();
2184	+	vecval.push_back(11267);
2185	+	replacement_map.stm[11261] = vecval;
2186	+	vecval.clear();
2187	+	vecval.push_back(11268);
2188	+	replacement_map.stm[11262] = vecval;
2189	+	vecval.clear();
2190	+	vecval.push_back(11269);
2191	+	replacement_map.stm[11263] = vecval;
2192	+	vecval.clear();
2193	+	vecval.push_back(11270);
2194	+	replacement_map.stm[11264] = vecval;
2195	+	vecval.clear();
2196	+	vecval.push_back(11271);
2197	+	replacement_map.stm[11265] = vecval;
2198	+	vecval.clear();
2199	+	vecval.push_back(11272);
2200	+	replacement_map.stm[11266] = vecval;
2201	+	vecval.clear();
2202	+	vecval.push_back(11273);
2203	+	replacement_map.stm[11267] = vecval;
2204	+	vecval.clear();
2205	+	vecval.push_back(11274);
2206	+	replacement_map.stm[11268] = vecval;
2207	+	vecval.clear();
2208	+	vecval.push_back(11275);
2209	+	replacement_map.stm[11269] = vecval;
2210	+	vecval.clear();
2211	+	vecval.push_back(11276);
2212	+	replacement_map.stm[11270] = vecval;
2213	+	vecval.clear();
2214	+	vecval.push_back(11277);
2215	+	replacement_map.stm[11271] = vecval;
2216	+	vecval.clear();
2217	+	vecval.push_back(11278);
2218	+	replacement_map.stm[11272] = vecval;
2219	+	vecval.clear();
2220	+	vecval.push_back(11279);
2221	+	replacement_map.stm[11273] = vecval;
2222	+	vecval.clear();
2223	+	vecval.push_back(11280);
2224	+	replacement_map.stm[11274] = vecval;
2225	+	vecval.clear();
2226	+	vecval.push_back(11281);
2227	+	replacement_map.stm[11275] = vecval;
2228	+	vecval.clear();
2229	+	vecval.push_back(11282);
2230	+	replacement_map.stm[11276] = vecval;
2231	+	vecval.clear();
2232	+	vecval.push_back(11283);
2233	+	replacement_map.stm[11277] = vecval;
2234	+	vecval.clear();
2235	+	vecval.push_back(11284);
2236	+	replacement_map.stm[11278] = vecval;
2237	+	vecval.clear();
2238	+	vecval.push_back(11285);
2239	+	replacement_map.stm[11279] = vecval;
2240	+	vecval.clear();
2241	+	vecval.push_back(11286);
2242	+	replacement_map.stm[11280] = vecval;
2243	+	vecval.clear();
2244	+	vecval.push_back(11287);
2245	+	replacement_map.stm[11281] = vecval;
2246	+	vecval.clear();
2247	+	vecval.push_back(11288);
2248	+	replacement_map.stm[11282] = vecval;
2249	+	vecval.clear();
2250	+	vecval.push_back(11289);
2251	+	replacement_map.stm[11283] = vecval;
2252	+	vecval.clear();
2253	+	vecval.push_back(11290);
2254	+	replacement_map.stm[11284] = vecval;
2255	+	vecval.clear();
2256	+	vecval.push_back(11291);
2257	+	replacement_map.stm[11285] = vecval;
2258	+	vecval.clear();
2259	+	vecval.push_back(11292);
2260	+	replacement_map.stm[11286] = vecval;
2261	+	vecval.clear();
2262	+	vecval.push_back(11293);
2263	+	replacement_map.stm[11287] = vecval;
2264	+	vecval.clear();
2265	+	vecval.push_back(11294);
2266	+	replacement_map.stm[11288] = vecval;
2267	+	vecval.clear();
2268	+	vecval.push_back(11295);
2269	+	replacement_map.stm[11289] = vecval;
2270	+	vecval.clear();
2271	+	vecval.push_back(11296);
2272	+	replacement_map.stm[11290] = vecval;
2273	+	vecval.clear();
2274	+	vecval.push_back(11297);
2275	+	replacement_map.stm[11291] = vecval;
2276	+	vecval.clear();
2277	+	vecval.push_back(11298);
2278	+	replacement_map.stm[11292] = vecval;
2279	+	vecval.clear();
2280	+	vecval.push_back(11299);
2281	+	replacement_map.stm[11293] = vecval;
2282	+	vecval.clear();
2283	+	vecval.push_back(11300);
2284	+	replacement_map.stm[11294] = vecval;
2285	+	vecval.clear();
2286	+	vecval.push_back(11301);
2287	+	replacement_map.stm[11295] = vecval;
2288	+	vecval.clear();
2289	+	vecval.push_back(11302);
2290	+	replacement_map.stm[11296] = vecval;
2291	+	vecval.clear();
2292	+	vecval.push_back(11303);
2293	+	replacement_map.stm[11297] = vecval;
2294	+	vecval.clear();
2295	+	vecval.push_back(11304);
2296	+	replacement_map.stm[11298] = vecval;
2297	+	vecval.clear();
2298	+	vecval.push_back(11305);
2299	+	replacement_map.stm[11299] = vecval;
2300	+	vecval.clear();
2301	+	vecval.push_back(11306);
2302	+	replacement_map.stm[11300] = vecval;
2303	+	vecval.clear();
2304	+	vecval.push_back(11307);
2305	+	replacement_map.stm[11301] = vecval;
2306	+	vecval.clear();
2307	+	vecval.push_back(11308);
2308	+	replacement_map.stm[11302] = vecval;
2309	+	vecval.clear();
2310	+	vecval.push_back(11309);
2311	+	replacement_map.stm[11303] = vecval;
2312	+	vecval.clear();
2313	+	vecval.push_back(11310);
2314	+	replacement_map.stm[11304] = vecval;
2315	+	vecval.clear();
2316	+	vecval.push_back(11311);
2317	+	replacement_map.stm[11305] = vecval;
2318	+	vecval.clear();
2319	+	vecval.push_back(11312);
2320	+	replacement_map.stm[11306] = vecval;
2321	+	vecval.clear();
2322	+	vecval.push_back(11313);
2323	+	replacement_map.stm[11307] = vecval;
2324	+	vecval.clear();
2325	+	vecval.push_back(11314);
2326	+	replacement_map.stm[11308] = vecval;
2327	+	vecval.clear();
2328	+	vecval.push_back(11315);
2329	+	replacement_map.stm[11309] = vecval;
2330	+	vecval.clear();
2331	+	vecval.push_back(11316);
2332	+	replacement_map.stm[11310] = vecval;
2333	+	vecval.clear();
2334	+	vecval.push_back(11317);
2335	+	replacement_map.stm[11311] = vecval;
2336	+	vecval.clear();
2337	+	vecval.push_back(11318);
2338	+	replacement_map.stm[11312] = vecval;
2339	+	vecval.clear();
2340	+	vecval.push_back(11319);
2341	+	replacement_map.stm[11313] = vecval;
2342	+	vecval.clear();
2343	+	vecval.push_back(11320);
2344	+	replacement_map.stm[11314] = vecval;
2345	+	vecval.clear();
2346	+	vecval.push_back(11321);
2347	+	replacement_map.stm[11315] = vecval;
2348	+	vecval.clear();
2349	+	vecval.push_back(11322);
2350	+	replacement_map.stm[11316] = vecval;
2351	+	vecval.clear();
2352	+	vecval.push_back(11323);
2353	+	replacement_map.stm[11317] = vecval;
2354	+	vecval.clear();
2355	+	vecval.push_back(11324);
2356	+	replacement_map.stm[11318] = vecval;
2357	+	vecval.clear();
2358	+	vecval.push_back(11325);
2359	+	replacement_map.stm[11319] = vecval;
2360	+	vecval.clear();
2361	+	vecval.push_back(11326);
2362	+	replacement_map.stm[11320] = vecval;
2363	+	vecval.clear();
2364	+	vecval.push_back(11327);
2365	+	replacement_map.stm[11321] = vecval;
2366	+	vecval.clear();
2367	+	vecval.push_back(11328);
2368	+	replacement_map.stm[11322] = vecval;
2369	+	vecval.clear();
2370	+	vecval.push_back(11329);
2371	+	replacement_map.stm[11323] = vecval;
2372	+	vecval.clear();
2373	+	vecval.push_back(11330);
2374	+	replacement_map.stm[11324] = vecval;
2375	+	vecval.clear();
2376	+	vecval.push_back(11331);
2377	+	replacement_map.stm[11325] = vecval;
2378	+	vecval.clear();
2379	+	vecval.push_back(11332);
2380	+	replacement_map.stm[11326] = vecval;
2381	+	vecval.clear();
2382	+	vecval.push_back(11333);
2383	+	replacement_map.stm[11327] = vecval;
2384	+	vecval.clear();
2385	+	vecval.push_back(11334);
2386	+	replacement_map.stm[11328] = vecval;
2387	+	vecval.clear();
2388	+	vecval.push_back(11335);
2389	+	replacement_map.stm[11329] = vecval;
2390	+	vecval.clear();
2391	+	vecval.push_back(11336);
2392	+	replacement_map.stm[11330] = vecval;
2393	+	vecval.clear();
2394	+	vecval.push_back(11337);
2395	+	replacement_map.stm[11331] = vecval;
2396	+	vecval.clear();
2397	+	vecval.push_back(11338);
2398	+	replacement_map.stm[11332] = vecval;
2399	+	vecval.clear();
2400	+	vecval.push_back(11339);
2401	+	replacement_map.stm[11333] = vecval;
2402	+	vecval.clear();
2403	+	vecval.push_back(11340);
2404	+	replacement_map.stm[11334] = vecval;
2405	+	vecval.clear();
2406	+	vecval.push_back(11341);
2407	+	replacement_map.stm[11335] = vecval;
2408	+	vecval.clear();
2409	+	vecval.push_back(11342);
2410	+	replacement_map.stm[11336] = vecval;
2411	+	vecval.clear();
2412	+	vecval.push_back(11343);
2413	+	replacement_map.stm[11337] = vecval;
2414	+	vecval.clear();
2415	+	vecval.push_back(11344);
2416	+	replacement_map.stm[11338] = vecval;
2417	+	vecval.clear();
2418	+	vecval.push_back(11345);
2419	+	replacement_map.stm[11339] = vecval;
2420	+	vecval.clear();
2421	+	vecval.push_back(11346);
2422	+	replacement_map.stm[11340] = vecval;
2423	+	vecval.clear();
2424	+	vecval.push_back(11347);
2425	+	replacement_map.stm[11341] = vecval;
2426	+	vecval.clear();
2427	+	vecval.push_back(11348);
2428	+	replacement_map.stm[11342] = vecval;
2429	+	vecval.clear();
2430	+	vecval.push_back(11349);
2431	+	replacement_map.stm[11343] = vecval;
2432	+	vecval.clear();
2433	+	vecval.push_back(11350);
2434	+	replacement_map.stm[11344] = vecval;
2435	+	vecval.clear();
2436	+	vecval.push_back(11351);
2437	+	replacement_map.stm[11345] = vecval;
2438	+	vecval.clear();
2439	+	vecval.push_back(11352);
2440	+	replacement_map.stm[11346] = vecval;
2441	+	vecval.clear();
2442	+	vecval.push_back(11353);
2443	+	replacement_map.stm[11347] = vecval;
2444	+	vecval.clear();
2445	+	vecval.push_back(11354);
2446	+	replacement_map.stm[11348] = vecval;
2447	+	vecval.clear();
2448	+	vecval.push_back(11355);
2449	+	replacement_map.stm[11349] = vecval;
2450	+	vecval.clear();
2451	+	vecval.push_back(11356);
2452	+	replacement_map.stm[11350] = vecval;
2453	+	vecval.clear();
2454	+	vecval.push_back(11357);
2455	+	replacement_map.stm[11351] = vecval;
2456	+	vecval.clear();
2457	+	vecval.push_back(11358);
2458	+	replacement_map.stm[11352] = vecval;
2459	+	vecval.clear();
2460	+	vecval.push_back(11359);
2461	+	replacement_map.stm[11353] = vecval;
2462	+	vecval.clear();
2463	+	vecval.push_back(11360);
2464	+	replacement_map.stm[11354] = vecval;
2465	+	vecval.clear();
2466	+	vecval.push_back(11361);
2467	+	replacement_map.stm[11355] = vecval;
2468	+	vecval.clear();
2469	+	vecval.push_back(11362);
2470	+	replacement_map.stm[11356] = vecval;
2471	+	vecval.clear();
2472	+	vecval.push_back(11363);
2473	+	replacement_map.stm[11357] = vecval;
2474	+	vecval.clear();
2475	+	vecval.push_back(11364);
2476	+	replacement_map.stm[11358] = vecval;
2477	+	vecval.clear();
2478	+	vecval.push_back(11365);
2479	+	replacement_map.stm[11359] = vecval;
2480	+	vecval.clear();
2481	+	vecval.push_back(11366);
2482	+	replacement_map.stm[11360] = vecval;
2483	+	vecval.clear();
2484	+	vecval.push_back(11367);
2485	+	replacement_map.stm[11361] = vecval;
2486	+	vecval.clear();
2487	+	vecval.push_back(11368);
2488	+	replacement_map.stm[11362] = vecval;
2489	+	vecval.clear();
2490	+	vecval.push_back(11369);
2491	+	replacement_map.stm[11363] = vecval;
2492	+	vecval.clear();
2493	+	vecval.push_back(11370);
2494	+	replacement_map.stm[11364] = vecval;
2495	+	vecval.clear();
2496	+	vecval.push_back(11371);
2497	+	replacement_map.stm[11365] = vecval;
2498	+	vecval.clear();
2499	+	vecval.push_back(11372);
2500	+	replacement_map.stm[11366] = vecval;
2501	+	vecval.clear();
2502	+	vecval.push_back(11373);
2503	+	replacement_map.stm[11367] = vecval;
2504	+	vecval.clear();
2505	+	vecval.push_back(11374);
2506	+	replacement_map.stm[11368] = vecval;
2507	+	vecval.clear();
2508	+	vecval.push_back(11375);
2509	+	replacement_map.stm[11369] = vecval;
2510	+	vecval.clear();
2511	+	vecval.push_back(11376);
2512	+	replacement_map.stm[11370] = vecval;
2513	+	vecval.clear();
2514	+	vecval.push_back(11377);
2515	+	replacement_map.stm[11371] = vecval;
2516	+	vecval.clear();
2517	+	vecval.push_back(11378);
2518	+	replacement_map.stm[11372] = vecval;
2519	+	vecval.clear();
2520	+	vecval.push_back(11379);
2521	+	replacement_map.stm[11373] = vecval;
2522	+	vecval.clear();
2523	+	vecval.push_back(11380);
2524	+	replacement_map.stm[11374] = vecval;
2525	+	vecval.clear();
2526	+	vecval.push_back(11381);
2527	+	replacement_map.stm[11375] = vecval;
2528	+	vecval.clear();
2529	+	vecval.push_back(11382);
2530	+	replacement_map.stm[11376] = vecval;
2531	+	vecval.clear();
2532	+	vecval.push_back(11383);
2533	+	replacement_map.stm[11377] = vecval;
2534	+	vecval.clear();
2535	+	vecval.push_back(11384);
2536	+	replacement_map.stm[11378] = vecval;
2537	+	vecval.clear();
2538	+	vecval.push_back(11385);
2539	+	replacement_map.stm[11379] = vecval;
2540	+	vecval.clear();
2541	+	vecval.push_back(11386);
2542	+	replacement_map.stm[11380] = vecval;
2543	+	vecval.clear();
2544	+	vecval.push_back(11387);
2545	+	replacement_map.stm[11381] = vecval;
2546	+	vecval.clear();
2547	+	vecval.push_back(11388);
2548	+	replacement_map.stm[11382] = vecval;
2549	+	vecval.clear();
2550	+	vecval.push_back(11389);
2551	+	replacement_map.stm[11383] = vecval;
2552	+	vecval.clear();
2553	+	vecval.push_back(11390);
2554	+	replacement_map.stm[11384] = vecval;
2555	+	vecval.clear();
2556	+	vecval.push_back(11391);
2557	+	replacement_map.stm[11385] = vecval;
2558	+	vecval.clear();
2559	+	vecval.push_back(11392);
2560	+	replacement_map.stm[11386] = vecval;
2561	+	vecval.clear();
2562	+	vecval.push_back(11393);
2563	+	replacement_map.stm[11387] = vecval;
2564	+	vecval.clear();
2565	+	vecval.push_back(11394);
2566	+	replacement_map.stm[11388] = vecval;
2567	+
2568	+	return replacement_map;
2569	+	}