How to use set method in Cypress

Best JavaScript code snippet using cypress

Run Cypress automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

stringset.js

Source: stringset.js Github

copy
1// Copyright 2009 The Closure Library Authors. All Rights Reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//      http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS-IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15/**
16 * @fileoverview Data structure for set of strings.
17 *
18 *
19 * This class implements a set data structure for strings. Adding and removing
20 * is O(1). It doesn't contain any bloat from {@link goog.structs.Set}, i.e.
21 * it isn't optimized for IE6 garbage collector (see the description of
22 * {@link goog.structs.Map#keys_} for details), and it distinguishes its
23 * elements by their string value not by hash code.
24 */
25
26goog.provide('goog.structs.StringSet');
27
28goog.require('goog.iter');
29
30
31
32/**
33 * Creates a set of strings.
34 * @param {!Array=} opt_elements Elements to add to the set. The non-string
35 *     items will be converted to strings, so 15 and '15' will mean the same.
36 * @constructor
37 */
38goog.structs.StringSet = function(opt_elements) {
39  /**
40   * An object storing the escaped elements of the set in its keys.
41   * @type {!Object}
42   * @private
43   */
44  this.elements_ = {};
45
46  if (opt_elements) {
47    for (var i = 0; i < opt_elements.length; i++) {
48      this.elements_[this.encode(opt_elements[i])] = null;
49    }
50  }
51};
52
53
54/**
55 * Empty object. Referring to it is faster than creating a new empty object in
56 * {@link #encode}.
57 * @type {Object}
58 * @private
59 */
60goog.structs.StringSet.EMPTY_OBJECT_ = {};
61
62
63/**
64 * The '__proto__' and the '__count__' keys aren't enumerable in Firefox, and
65 * 'toString', 'valueOf', 'constructor', etc. aren't enumerable in IE so they
66 * have to be escaped before they are added to the internal object.
67 * NOTE: When a new set is created, 50-80% of the CPU time is spent in encode.
68 * @param {*} element The element to escape.
69 * @return {*} The escaped element or the element itself if it doesn't have to
70 *     be escaped.
71 * @protected
72 */
73goog.structs.StringSet.prototype.encode = function(element) {
74  return element in goog.structs.StringSet.EMPTY_OBJECT_ ||
75      String(element).charCodeAt(0) == 32 ? ' ' + element : element;
76};
77
78
79/**
80 * Inverse function of {@link #encode}.
81 * NOTE: forEach would be 30% faster in FF if the compiler inlined decode.
82 * @param {string} key The escaped element used as the key of the internal
83 *     object.
84 * @return {string} The unescaped element.
85 * @protected
86 */
87goog.structs.StringSet.prototype.decode = function(key) {
88  return key.charCodeAt(0) == 32 ? key.substr(1) : key;
89};
90
91
92/**
93 * Adds a single element to the set.
94 * @param {*} element The element to add. It will be converted to string.
95 */
96goog.structs.StringSet.prototype.add = function(element) {
97  this.elements_[this.encode(element)] = null;
98};
99
100
101/**
102 * Adds a the elements of an array to this set.
103 * @param {!Array} arr The array to add the elements of.
104 */
105goog.structs.StringSet.prototype.addArray = function(arr) {
106  for (var i = 0; i < arr.length; i++) {
107    this.elements_[this.encode(arr[i])] = null;
108  }
109};
110
111
112/**
113 * Adds the elements which are in {@code set1} but not in {@code set2} to this
114 * set.
115 * @param {!goog.structs.StringSet} set1 First set.
116 * @param {!goog.structs.StringSet} set2 Second set.
117 * @private
118 */
119goog.structs.StringSet.prototype.addDifference_ = function(set1, set2) {
120  for (var key in set1.elements_) {
121    if (set1.elements_.hasOwnProperty(key) &&
122        !set2.elements_.hasOwnProperty(key)) {
123      this.elements_[key] = null;
124    }
125  }
126};
127
128
129/**
130 * Adds a the elements of a set to this set.
131 * @param {!goog.structs.StringSet} stringSet The set to add the elements of.
132 */
133goog.structs.StringSet.prototype.addSet = function(stringSet) {
134  for (var key in stringSet.elements_) {
135    if (stringSet.elements_.hasOwnProperty(key)) {
136      this.elements_[key] = null;
137    }
138  }
139};
140
141
142/**
143 * Removes all elements of the set.
144 */
145goog.structs.StringSet.prototype.clear = function() {
146  this.elements_ = {};
147};
148
149
150/**
151 * @return {!goog.structs.StringSet} Clone of the set.
152 */
153goog.structs.StringSet.prototype.clone = function() {
154  var ret = new goog.structs.StringSet;
155  ret.addSet(this);
156  return ret;
157};
158
159
160/**
161 * Tells if the set contains the given element.
162 * @param {*} element The element to check.
163 * @return {boolean} Whether it is in the set.
164 */
165goog.structs.StringSet.prototype.contains = function(element) {
166  return this.elements_.hasOwnProperty(this.encode(element));
167};
168
169
170/**
171 * Tells if the set contains all elements of the array.
172 * @param {!Array} arr The elements to check.
173 * @return {boolean} Whether they are in the set.
174 */
175goog.structs.StringSet.prototype.containsArray = function(arr) {
176  for (var i = 0; i < arr.length; i++) {
177    if (!this.elements_.hasOwnProperty(this.encode(arr[i]))) {
178      return false;
179    }
180  }
181  return true;
182};
183
184
185/**
186 * Tells if this set has the same elements as the given set.
187 * @param {!goog.structs.StringSet} stringSet The other set.
188 * @return {boolean} Whether they have the same elements.
189 */
190goog.structs.StringSet.prototype.equals = function(stringSet) {
191  return this.isSubsetOf(stringSet) && stringSet.isSubsetOf(this);
192};
193
194
195/**
196 * Calls a function for each element in the set.
197 * @param {function(string, undefined, !goog.structs.StringSet)} f The function
198 *     to call for every element. It takes the element, undefined (because sets
199 *     have no notion of keys), and the set.
200 * @param {Object=} opt_obj The object to be used as the value of 'this'
201 *     within {@code f}.
202 */
203goog.structs.StringSet.prototype.forEach = function(f, opt_obj) {
204  for (var key in this.elements_) {
205    if (this.elements_.hasOwnProperty(key)) {
206      f.call(opt_obj, this.decode(key), undefined, this);
207    }
208  }
209};
210
211
212/**
213 * Counts the number of elements in the set in linear time.
214 * NOTE: getCount is always called at most once per set instance in google3.
215 * If this usage pattern won't change, the linear getCount implementation is
216 * better, because
217 * <li>populating a set and getting the number of elements in it takes the same
218 * amount of time as keeping a count_ member up to date and getting its value;
219 * <li>if getCount is not called, adding and removing elements have no overhead.
220 * @return {number} The number of elements in the set.
221 */
222goog.structs.StringSet.prototype.getCount = function() {
223  var count = 0;
224  for (var key in this.elements_) {
225    if (this.elements_.hasOwnProperty(key)) {
226      count++;
227    }
228  }
229  return count;
230};
231
232
233/**
234 * Calculates the difference of two sets.
235 * @param {!goog.structs.StringSet} stringSet The set to subtract from this set.
236 * @return {!goog.structs.StringSet} {@code this} minus {@code stringSet}.
237 */
238goog.structs.StringSet.prototype.getDifference = function(stringSet) {
239  var ret = new goog.structs.StringSet;
240  ret.addDifference_(this, stringSet);
241  return ret;
242};
243
244
245/**
246 * Calculates the intersection of this set with another set.
247 * @param {!goog.structs.StringSet} stringSet The set to take the intersection
248 *     with.
249 * @return {!goog.structs.StringSet} A new set with the common elements.
250 */
251goog.structs.StringSet.prototype.getIntersection = function(stringSet) {
252  var ret = new goog.structs.StringSet;
253  for (var key in this.elements_) {
254    if (stringSet.elements_.hasOwnProperty(key) &&
255        this.elements_.hasOwnProperty(key)) {
256      ret.elements_[key] = null;
257    }
258  }
259  return ret;
260};
261
262
263/**
264 * Calculates the symmetric difference of two sets.
265 * @param {!goog.structs.StringSet} stringSet The other set.
266 * @return {!goog.structs.StringSet} A new set with the elements in exactly one
267 *     of {@code this} and {@code stringSet}.
268 */
269goog.structs.StringSet.prototype.getSymmetricDifference = function(stringSet) {
270  var ret = new goog.structs.StringSet;
271  ret.addDifference_(this, stringSet);
272  ret.addDifference_(stringSet, this);
273  return ret;
274};
275
276
277/**
278 * Calculates the union of this set and another set.
279 * @param {!goog.structs.StringSet} stringSet The set to take the union with.
280 * @return {!goog.structs.StringSet} A new set with the union of elements.
281 */
282goog.structs.StringSet.prototype.getUnion = function(stringSet) {
283  var ret = this.clone();
284  ret.addSet(stringSet);
285  return ret;
286};
287
288
289/**
290 * @return {!Array.<string>} The elements of the set.
291 */
292goog.structs.StringSet.prototype.getValues = function() {
293  var ret = [];
294  for (var key in this.elements_) {
295    if (this.elements_.hasOwnProperty(key)) {
296      ret.push(this.decode(key));
297    }
298  }
299  return ret;
300};
301
302
303/**
304 * Tells if this set and the given set are disjoint.
305 * @param {!goog.structs.StringSet} stringSet The other set.
306 * @return {boolean} True iff they don't have common elements.
307 */
308goog.structs.StringSet.prototype.isDisjoint = function(stringSet) {
309  for (var key in this.elements_) {
310    if (stringSet.elements_.hasOwnProperty(key) &&
311        this.elements_.hasOwnProperty(key)) {
312      return false;
313    }
314  }
315  return true;
316};
317
318
319/**
320 * @return {boolean} Whether the set is empty.
321 */
322goog.structs.StringSet.prototype.isEmpty = function() {
323  for (var key in this.elements_) {
324    if (this.elements_.hasOwnProperty(key)) {
325      return false;
326    }
327  }
328  return true;
329};
330
331
332/**
333 * Tells if this set is the subset of the given set.
334 * @param {!goog.structs.StringSet} stringSet The other set.
335 * @return {boolean} Whether this set if the subset of that.
336 */
337goog.structs.StringSet.prototype.isSubsetOf = function(stringSet) {
338  for (var key in this.elements_) {
339    if (!stringSet.elements_.hasOwnProperty(key) &&
340        this.elements_.hasOwnProperty(key)) {
341      return false;
342    }
343  }
344  return true;
345};
346
347
348/**
349 * Tells if this set is the superset of the given set.
350 * @param {!goog.structs.StringSet} stringSet The other set.
351 * @return {boolean} Whether this set if the superset of that.
352 */
353goog.structs.StringSet.prototype.isSupersetOf = function(stringSet) {
354  return this.isSubsetOf.call(stringSet, this);
355};
356
357
358/**
359 * Removes a single element from the set.
360 * @param {*} element The element to remove.
361 * @return {boolean} Whether the element was in the set.
362 */
363goog.structs.StringSet.prototype.remove = function(element) {
364  var key = this.encode(element);
365  if (this.elements_.hasOwnProperty(key)) {
366    delete this.elements_[key];
367    return true;
368  }
369  return false;
370};
371
372
373/**
374 * Removes all elements of the given array from this set.
375 * @param {!Array} arr The elements to remove.
376 */
377goog.structs.StringSet.prototype.removeArray = function(arr) {
378  for (var i = 0; i < arr.length; i++) {
379    delete this.elements_[this.encode(arr[i])];
380  }
381};
382
383
384/**
385 * Removes all elements of the given set from this set.
386 * @param {!goog.structs.StringSet} stringSet The set of elements to remove.
387 */
388goog.structs.StringSet.prototype.removeSet = function(stringSet) {
389  for (var key in stringSet.elements_) {
390    delete this.elements_[key];
391  }
392};
393
394
395/**
396 * Returns an iterator that iterates over the elements in the set.
397 * NOTE: creating the iterator copies the whole set so use {@link #forEach} when
398 * possible.
399 * @param {boolean=} opt_keys Ignored for sets.
400 * @return {!goog.iter.Iterator} An iterator over the elements in the set.
401 */
402goog.structs.StringSet.prototype.__iterator__ = function(opt_keys) {
403  return goog.iter.toIterator(this.getValues());
404};
405
Full Screen

editor.js

Source: editor.js Github

copy
1export const SET_PHRASE = 'editor/setPhrase';
2export const SET_TITLE = 'editor/setTitle';
3export const SET_INTERVAL = 'editor/setInterval';
4export const SET_LIKED = 'editor/setLiked';
5
6export const SET_X = 'editor/setX';
7export const SET_WIDTH = 'editor/setWidth';
8export const SET_ANCHOR = 'editor/setAnchor';
9export const SET_CURSOR = 'editor/setCursor';
10export const SET_NOTE = 'editor/setNote';
11export const SET_NOTES = 'editor/setNotes';
12
13export const APPEND_NOTES = 'editor/appendNotes';
14export const REMOVE_NOTES = 'editor/removeNotes';
15export const RESET_NOTES = 'editor/resetNotes';
16
17export const APPEND_OPERATION = 'editor/appendOperation';
18export const SET_POINTER = 'editor/setPointer';
19
20export const SET_DRAWING = 'editor/setDrawing';
21export const SET_HOVERING = 'editor/setHovering';
22export const SET_PLAYING = 'editor/setPlaying';
23export const SET_SAVING = 'editor/setSaving';
24
25export const RESET_EDITOR = 'editor/resetEditor';
26
27export function setPhrase(phrase) {
28  return { type: SET_PHRASE, payload: { phrase } };
29}
30
31export function setTitle(title) {
32  return { type: SET_TITLE, payload: { title } };
33}
34
35export function setInterval(interval) {
36  return { type: SET_INTERVAL, payload: { interval } };
37}
38
39export function setLiked(liked) {
40  return { type: SET_LIKED, payload: { liked } };
41}
42
43export function setX(x) {
44  return { type: SET_X, payload: { x } };
45}
46
47export function setWidth(width) {
48  return { type: SET_WIDTH, payload: { width } };
49}
50
51export function setAnchor(anchor) {
52  return { type: SET_ANCHOR, payload: { anchor } };
53}
54
55export function setCursor(cursor) {
56  return { type: SET_CURSOR, payload: { cursor } };
57}
58
59export function setNote(note) {
60  return { type: SET_NOTE, payload: { note } };
61}
62
63export function setNotes(notes) {
64  return { type: SET_NOTES, payload: { notes } };
65}
66
67export function appendNotes(notes) {
68  return { type: APPEND_NOTES, payload: { notes } };
69}
70
71export function removeNotes(notes) {
72  return { type: REMOVE_NOTES, payload: { notes } };
73}
74
75export function resetNotes() {
76  return { type: RESET_NOTES };
77}
78
79export function appendOperation(index, operation) {
80  return { type: APPEND_OPERATION, payload: { index, operation } };
81}
82
83export function setPointer(pointer) {
84  return { type: SET_POINTER, payload: { pointer } };
85}
86
87export function setDrawing(drawing) {
88  return { type: SET_DRAWING, payload: { drawing } };
89}
90
91export function setHovering(hovering) {
92  return { type: SET_HOVERING, payload: { hovering } };
93}
94
95export function setPlaying(playing) {
96  return { type: SET_PLAYING, payload: { playing } };
97}
98
99export function setSaving(saving) {
100  return { type: SET_SAVING, payload: { saving } };
101}
102
103export function resetEditor() {
104  return { type: RESET_EDITOR };
105}
106
Full Screen

keys.js

Source: keys.js Github

copy
1var predefinedDecHash = new Map();
2var predefinedEncHash = new Map();
3
4predefinedDecHash.set(0, "D");
5predefinedDecHash.set(1, "q");
6predefinedDecHash.set(2, "6");
7predefinedDecHash.set(3, "/");
8predefinedDecHash.set(4, "V");
9predefinedDecHash.set(5, "G");
10predefinedDecHash.set(6, "h");
11predefinedDecHash.set(7, "l");
12predefinedDecHash.set(8, "I");
13predefinedDecHash.set(9, "F");
14predefinedDecHash.set(10, "F");
15predefinedDecHash.set(11, "1");
16predefinedDecHash.set(12, "a");
17predefinedDecHash.set(13, "W");
18predefinedDecHash.set(14, "N");
19predefinedDecHash.set(15, "r");
20predefinedDecHash.set(16, "I");
21predefinedDecHash.set(17, "F");
22predefinedDecHash.set(18, "J");
23predefinedDecHash.set(19, "l");
24predefinedDecHash.set(20, "Z");
25predefinedDecHash.set(21, "C");
26predefinedDecHash.set(22, "B");
27predefinedDecHash.set(23, "G");
28predefinedDecHash.set(24, "b");
29predefinedDecHash.set(25, "3");
30predefinedDecHash.set(26, "g");
31predefinedDecHash.set(27, "g");
32predefinedDecHash.set(28, "S");
33predefinedDecHash.set(29, "n");
34predefinedDecHash.set(30, "V");
35predefinedDecHash.set(31, "t");
36predefinedDecHash.set(32, "c");
37predefinedDecHash.set(33, "G");
38predefinedDecHash.set(34, "V");
39predefinedDecHash.set(35, "k");
40predefinedDecHash.set(36, "I");
41predefinedDecHash.set(37, "E");
42predefinedDecHash.set(38, "9");
43predefinedDecHash.set(39, "2");
44predefinedDecHash.set(40, "Z");
45predefinedDecHash.set(41, "X");
46predefinedDecHash.set(42, "I");
47predefinedDecHash.set(43, "g");
48predefinedDecHash.set(44, "d");
49predefinedDecHash.set(45, "G");
50predefinedDecHash.set(46, "h");
51predefinedDecHash.set(47, "l");
52predefinedDecHash.set(48, "I");
53predefinedDecHash.set(49, "E");
54predefinedDecHash.set(50, "x");
55predefinedDecHash.set(51, "h");
56predefinedDecHash.set(52, "e");
57predefinedDecHash.set(53, "n");
58predefinedDecHash.set(54, "k");
59predefinedDecHash.set(55, "g");
60predefinedDecHash.set(56, "Q");
61predefinedDecHash.set(57, "n");
62predefinedDecHash.set(58, "J");
63predefinedDecHash.set(59, "v");
64predefinedDecHash.set(60, "d");
65predefinedDecHash.set(61, "2");
66predefinedDecHash.set(62, "4");
67predefinedDecHash.set(63, "g");
68predefinedDecHash.set(64, "R");
69predefinedDecHash.set(65, "G");
70predefinedDecHash.set(66, "9");
71predefinedDecHash.set(67, "n");
72predefinedDecHash.set(68, "L");
73predefinedDecHash.set(69, "i");
74predefinedDecHash.set(70, "A");
75predefinedDecHash.set(71, "8");
76predefinedDecHash.set(72, "P");
77predefinedDecHash.set(73, "i");
78predefinedDecHash.set(74, "w");
79predefinedDecHash.set(75, "u");
80predefinedDecHash.set(76, "P");
81predefinedDecHash.set(77, "z");
82predefinedDecHash.set(78, "o");
83predefinedDecHash.set(79, "7");
84predefinedDecHash.set(80, "f");
85predefinedDecHash.set(81, "H");
86predefinedDecHash.set(82, "t");
87predefinedDecHash.set(83, "9");
88predefinedDecHash.set(84, "W");
89predefinedDecHash.set(85, "1");
90predefinedDecHash.set(86, "1");
91predefinedDecHash.set(87, "+");
92predefinedDecHash.set(88, "I");
93predefinedDecHash.set(89, "U");
94predefinedDecHash.set(90, "A");
95predefinedDecHash.set(91, "j");
96predefinedDecHash.set(92, "J");
97predefinedDecHash.set(93, "C");
98predefinedDecHash.set(94, "V");
99predefinedDecHash.set(95, "e");
100predefinedDecHash.set(96, "J");
101predefinedDecHash.set(97, "i");
102predefinedDecHash.set(98, "o");
103predefinedDecHash.set(99, "o");
104predefinedDecHash.set(100, "K");
105predefinedDecHash.set(101, "V");
106predefinedDecHash.set(102, "8");
107predefinedDecHash.set(103, "r");
108predefinedDecHash.set(104, "P");
109predefinedDecHash.set(105, "S");
110predefinedDecHash.set(106, "0");
111predefinedDecHash.set(107, "w");
112predefinedDecHash.set(108, "O");
113predefinedDecHash.set(109, "T");
114predefinedDecHash.set(110, "g");
115predefinedDecHash.set(111, "3");
116predefinedDecHash.set(112, "N");
117predefinedDecHash.set(113, "j");
118predefinedDecHash.set(114, "U");
119predefinedDecHash.set(115, "0");
120predefinedDecHash.set(116, "M");
121predefinedDecHash.set(117, "z");
122predefinedDecHash.set(118, "I");
123predefinedDecHash.set(119, "x");
124predefinedDecHash.set(120, "Y");
125predefinedDecHash.set(121, "E");
126predefinedDecHash.set(122, "x");
127predefinedDecHash.set(123, "v");
128predefinedDecHash.set(124, "c");
129predefinedDecHash.set(125, "m");
130predefinedDecHash.set(126, "V");
131predefinedDecHash.set(127, "t");
132predefinedDecHash.set(128, "I");
133predefinedDecHash.set(129, "G");
134predefinedDecHash.set(130, "l");
135predefinedDecHash.set(131, "w");
136predefinedDecHash.set(132, "c");
137predefinedDecHash.set(133, "3");
138predefinedDecHash.set(134, "V");
139predefinedDecHash.set(135, "t");
140predefinedDecHash.set(136, "I");
141predefinedDecHash.set(137, "G");
142predefinedDecHash.set(138, "R");
143predefinedDecHash.set(139, "v");
144predefinedDecHash.set(140, "b");
145predefinedDecHash.set(141, "G");
146predefinedDecHash.set(142, "9");
147predefinedDecHash.set(143, "y");
148predefinedDecHash.set(144, "I");
149predefinedDecHash.set(145, "H");
150predefinedDecHash.set(146, "N");
151predefinedDecHash.set(147, "p");
152predefinedDecHash.set(148, "d");
153predefinedDecHash.set(149, "C");
154predefinedDecHash.set(150, "B");
155predefinedDecHash.set(151, "h");
156predefinedDecHash.set(152, "b");
157predefinedDecHash.set(153, "W");
158predefinedDecHash.set(154, "V");
159predefinedDecHash.set(155, "0");
160predefinedDecHash.set(156, "L");
161predefinedDecHash.set(157, "C");
162predefinedDecHash.set(158, "B");
163predefinedDecHash.set(159, "j");
164predefinedDecHash.set(160, "b");
165predefinedDecHash.set(161, "2");
166predefinedDecHash.set(162, "5");
167predefinedDecHash.set(163, "z");
168predefinedDecHash.set(164, "Z");
169predefinedDecHash.set(165, "W");
170predefinedDecHash.set(166, "N");
171predefinedDecHash.set(167, "0");
172predefinedDecHash.set(168, "Z");
173predefinedDecHash.set(169, "X");
174predefinedDecHash.set(170, "R");
175predefinedDecHash.set(171, "1");
176predefinedDecHash.set(172, "c");
177predefinedDecHash.set(173, "i");
178predefinedDecHash.set(174, "B");
179predefinedDecHash.set(175, "h");
180predefinedDecHash.set(176, "Z");
181predefinedDecHash.set(177, "G");
182predefinedDecHash.set(178, "l");
183predefinedDecHash.set(179, "w");
184predefinedDecHash.set(180, "a");
185predefinedDecHash.set(181, "X");
186predefinedDecHash.set(182, "N");
187predefinedDecHash.set(183, "j");
188predefinedDecHash.set(184, "a");
189predefinedDecHash.set(185, "W");
190predefinedDecHash.set(186, "5");
191predefinedDecHash.set(187, "n");
192predefinedDecHash.set(188, "I");
193predefinedDecHash.set(189, "G");
194predefinedDecHash.set(190, "V");
195predefinedDecHash.set(191, "s");
196predefinedDecHash.set(192, "a");
197predefinedDecHash.set(193, "X");
198predefinedDecHash.set(194, "Q");
199predefinedDecHash.set(195, "s");
200predefinedDecHash.set(196, "I");
201predefinedDecHash.set(197, "H");
202predefinedDecHash.set(198, "N");
203predefinedDecHash.set(199, "l");
204predefinedDecHash.set(200, "Z");
205predefinedDecHash.set(201, "C");
206predefinedDecHash.set(202, "B");
207predefinedDecHash.set(203, "k");
208predefinedDecHash.set(204, "b");
209predefinedDecHash.set(205, "y");
210predefinedDecHash.set(206, "B");
211predefinedDecHash.set(207, "l");
212predefinedDecHash.set(208, "a");
213predefinedDecHash.set(209, "X");
214predefinedDecHash.set(210, "V");
215predefinedDecHash.set(211, "z");
216predefinedDecHash.set(212, "b");
217predefinedDecHash.set(213, "W");
218predefinedDecHash.set(214, "9");
219predefinedDecHash.set(215, "k");
220predefinedDecHash.set(216, "I");
221predefinedDecHash.set(217, "H");
222predefinedDecHash.set(218, "R");
223predefinedDecHash.set(219, "l");
224predefinedDecHash.set(220, "b");
225predefinedDecHash.set(221, "X");
226predefinedDecHash.set(222, "B");
227predefinedDecHash.set(223, "v");
228predefinedDecHash.set(224, "c");
229predefinedDecHash.set(225, "i");
230predefinedDecHash.set(226, "B");
231predefinedDecHash.set(227, "p");
232predefinedDecHash.set(228, "b");
233predefinedDecHash.set(229, "m");
234predefinedDecHash.set(230, "N");
235predefinedDecHash.set(231, "p");
236predefinedDecHash.set(232, "Z");
237predefinedDecHash.set(233, "G");
238predefinedDecHash.set(234, "l");
239predefinedDecHash.set(235, "k");
240predefinedDecHash.set(236, "d");
241predefinedDecHash.set(237, "W");
242predefinedDecHash.set(238, "5");
243predefinedDecHash.set(239, "0");
244predefinedDecHash.set(240, "I");
245predefinedDecHash.set(241, "H");
246predefinedDecHash.set(242, "V");
247predefinedDecHash.set(243, "0");
248predefinedDecHash.set(244, "I");
249predefinedDecHash.set(245, "G");
250predefinedDecHash.set(246, "x");
251predefinedDecHash.set(247, "h");
252predefinedDecHash.set(248, "Y");
253predefinedDecHash.set(249, "m");
254predefinedDecHash.set(250, "9");
255predefinedDecHash.set(251, "y");
256predefinedDecHash.set(252, "Z");
257predefinedDecHash.set(253, "S");
258predefinedDecHash.set(254, "B");
259predefinedDecHash.set(255, "l");
260predefinedDecHash.set(256, "d");
261predefinedDecHash.set(257, "C");
262predefinedDecHash.set(258, "B");
263predefinedDecHash.set(259, "k");
264predefinedDecHash.set(260, "b");
265predefinedDecHash.set(261, "2");
266predefinedDecHash.set(262, "x");
267predefinedDecHash.set(263, "v");
268predefinedDecHash.set(264, "c");
269predefinedDecHash.set(265, "m");
270predefinedDecHash.set(266, "U");
271predefinedDecHash.set(267, "g");
272predefinedDecHash.set(268, "b");
273predefinedDecHash.set(269, "W");
274predefinedDecHash.set(270, "F");
275predefinedDecHash.set(271, "n");
276predefinedDecHash.set(272, "b");
277predefinedDecHash.set(273, "m");
278predefinedDecHash.set(274, "E");
279predefinedDecHash.set(275, "g");
280predefinedDecHash.set(276, "Y");
281predefinedDecHash.set(277, "W");
282predefinedDecHash.set(278, "x");
283predefinedDecHash.set(279, "p");
284predefinedDecHash.set(280, "c");
285predefinedDecHash.set(281, "X");
286predefinedDecHash.set(282, "V");
287predefinedDecHash.set(283, "h");
288predefinedDecHash.set(284, "L");
289predefinedDecHash.set(285, "i");
290predefinedDecHash.set(286, "B");
291predefinedDecHash.set(287, "V");
292predefinedDecHash.set(288, "d");
293predefinedDecHash.set(289, "C");
294predefinedDecHash.set(290, "B");
295predefinedDecHash.set(291, "l");
296predefinedDecHash.set(292, "b");
297predefinedDecHash.set(293, "m");
298predefinedDecHash.set(294, "l");
299predefinedDecHash.set(295, "t");
300predefinedDecHash.set(296, "I");
301predefinedDecHash.set(297, "G");
302predefinedDecHash.set(298, "F");
303predefinedDecHash.set(299, "k");
304predefinedDecHash.set(300, "I");
305predefinedDecHash.set(301, "G");
306predefinedDecHash.set(302, "1");
307predefinedDecHash.set(303, "p");
308predefinedDecHash.set(304, "b");
309predefinedDecHash.set(305, "m");
310predefinedDecHash.set(306, "l");
311predefinedDecHash.set(307, "t");
312predefinedDecHash.set(308, "I");
313predefinedDecHash.set(309, "H");
314predefinedDecHash.set(310, "Z");
315predefinedDecHash.set(311, "l");
316predefinedDecHash.set(312, "b");
317predefinedDecHash.set(313, "m");
318predefinedDecHash.set(314, "l");
319predefinedDecHash.set(315, "h");
320predefinedDecHash.set(316, "b");
321predefinedDecHash.set(317, "S");
322predefinedDecHash.set(318, "w");
323predefinedDecHash.set(319, "g");
324predefinedDecHash.set(320, "c");
325predefinedDecHash.set(321, "X");
326predefinedDecHash.set(322, "V");
327predefinedDecHash.set(323, "p");
328predefinedDecHash.set(324, "c");
329predefinedDecHash.set(325, "y");
330predefinedDecHash.set(326, "B");
331predefinedDecHash.set(327, "u");
332predefinedDecHash.set(328, "b");
333predefinedDecHash.set(329, "3");
334predefinedDecHash.set(330, "N");
335predefinedDecHash.set(331, "0");
336predefinedDecHash.set(332, "c");
337predefinedDecHash.set(333, "n");
338predefinedDecHash.set(334, "V");
339predefinedDecHash.set(335, "k");
340predefinedDecHash.set(336, "I");
341predefinedDecHash.set(337, "G");
342predefinedDecHash.set(338, "V");
343predefinedDecHash.set(339, "4");
344predefinedDecHash.set(340, "Z");
345predefinedDecHash.set(341, "X");
346predefinedDecHash.set(342, "J");
347predefinedDecHash.set(343, "j");
348predefinedDecHash.set(344, "a");
349predefinedDecHash.set(345, "X");
350predefinedDecHash.set(346, "R");
351predefinedDecHash.set(347, "h");
352predefinedDecHash.set(348, "d");
353predefinedDecHash.set(349, "G");
354predefinedDecHash.set(350, "l");
355predefinedDecHash.set(351, "v");
356predefinedDecHash.set(352, "b");
357predefinedDecHash.set(353, "i");
358predefinedDecHash.set(354, "B");
359predefinedDecHash.set(355, "1");
360predefinedDecHash.set(356, "b");
361predefinedDecHash.set(357, "G");
362predefinedDecHash.set(358, "x");
363predefinedDecHash.set(359, "h");
364predefinedDecHash.set(360, "b");
365predefinedDecHash.set(361, "W");
366predefinedDecHash.set(362, "N");
367predefinedDecHash.set(363, "v");
368predefinedDecHash.set(364, "I");
369predefinedDecHash.set(365, "G");
370predefinedDecHash.set(366, "x");
371predefinedDecHash.set(367, "h");
372predefinedDecHash.set(368, "Y");
373predefinedDecHash.set(369, "m");
374predefinedDecHash.set(370, "9");
375predefinedDecHash.set(371, "y");
376predefinedDecHash.set(372, "a");
377predefinedDecHash.set(373, "X");
378predefinedDecHash.set(374, "M");
379predefinedDecHash.set(375, "g");
380predefinedDecHash.set(376, "b");
381predefinedDecHash.set(377, "m");
382predefinedDecHash.set(378, "l");
383predefinedDecHash.set(379, "z");
384predefinedDecHash.set(380, "a");
385predefinedDecHash.set(381, "S");
386predefinedDecHash.set(382, "B");
387predefinedDecHash.set(383, "1");
388predefinedDecHash.set(384, "d");
389predefinedDecHash.set(385, "C");
390predefinedDecHash.set(386, "B");
391predefinedDecHash.set(387, "h");
392predefinedDecHash.set(388, "b");
393predefinedDecHash.set(389, "G");
394predefinedDecHash.set(390, "l");
395predefinedDecHash.set(391, "x");
396predefinedDecHash.set(392, "d");
397predefinedDecHash.set(393, "W");
398predefinedDecHash.set(394, "l");
399predefinedDecHash.set(395, "w");
400predefinedDecHash.set(396, "I");
401predefinedDecHash.set(397, "G");
402predefinedDecHash.set(398, "V");
403predefinedDecHash.set(399, "4");
404predefinedDecHash.set(400, "I");
405predefinedDecHash.set(401, "G");
406predefinedDecHash.set(402, "V");
407predefinedDecHash.set(403, "h");
408predefinedDecHash.set(404, "I");
409predefinedDecHash.set(405, "G");
410predefinedDecHash.set(406, "N");
411predefinedDecHash.set(407, "v");
412predefinedDecHash.set(408, "b");
413predefinedDecHash.set(409, "W");
414predefinedDecHash.set(410, "1");
415predefinedDecHash.set(411, "v");
416predefinedDecHash.set(412, "Z");
417predefinedDecHash.set(413, "G");
418predefinedDecHash.set(414, "8");
419predefinedDecHash.set(415, "g");
420predefinedDecHash.set(416, "Y");
421predefinedDecHash.set(417, "2");
422predefinedDecHash.set(418, "9");
423predefinedDecHash.set(419, "u");
424predefinedDecHash.set(420, "c");
425predefinedDecHash.set(421, "2");
426predefinedDecHash.set(422, "V");
427predefinedDecHash.set(423, "x");
428predefinedDecHash.set(424, "d");
429predefinedDecHash.set(425, "W");
430predefinedDecHash.set(426, "F");
431predefinedDecHash.set(427, "0");
432predefinedDecHash.set(428, "L");
433predefinedDecHash.set(429, "i");
434predefinedDecHash.set(430, "B");
435predefinedDecHash.set(431, "E");
436predefinedDecHash.set(432, "d");
437predefinedDecHash.set(433, "W");
438predefinedDecHash.set(434, "l");
439predefinedDecHash.set(435, "z");
440predefinedDecHash.set(436, "I");
441predefinedDecHash.set(437, "G");
442predefinedDecHash.set(438, "F");
443predefinedDecHash.set(439, "1");
444predefinedDecHash.set(440, "d");
445predefinedDecHash.set(441, "G");
446predefinedDecHash.set(442, "U");
447predefinedDecHash.set(443, "g");
448predefinedDecHash.set(444, "a");
449predefinedDecHash.set(445, "X");
450predefinedDecHash.set(446, "J");
451predefinedDecHash.set(447, "1");
452predefinedDecHash.set(448, "c");
453predefinedDecHash.set(449, "m");
454predefinedDecHash.set(450, "U");
455predefinedDecHash.set(451, "g");
456predefinedDecHash.set(452, "Z");
457predefinedDecHash.set(453, "G");
458predefinedDecHash.set(454, "9");
459predefinedDecHash.set(455, "s");
460predefinedDecHash.set(456, "b");
461predefinedDecHash.set(457, "3");
462predefinedDecHash.set(458, "I");
463predefinedDecHash.set(459, "g");
464predefinedDecHash.set(460, "a");
465predefinedDecHash.set(461, "W");
466predefinedDecHash.set(462, "4");
467predefinedDecHash.set(463, "g");
468predefinedDecHash.set(464, "c");
469predefinedDecHash.set(465, "m");
470predefinedDecHash.set(466, "V");
471predefinedDecHash.set(467, "w");
472predefinedDecHash.set(468, "c");
473predefinedDecHash.set(469, "m");
474predefinedDecHash.set(470, "V");
475predefinedDecHash.set(471, "o");
476predefinedDecHash.set(472, "Z");
477predefinedDecHash.set(473, "W");
478predefinedDecHash.set(474, "5");
479predefinedDecHash.set(475, "k");
480predefinedDecHash.set(476, "Z");
481predefinedDecHash.set(477, "X");
482predefinedDecHash.set(478, "J");
483predefinedDecHash.set(479, "p");
484predefinedDecHash.set(480, "d");
485predefinedDecHash.set(481, "C");
486predefinedDecHash.set(482, "B");
487predefinedDecHash.set(483, "p");
488predefinedDecHash.set(484, "b");
489predefinedDecHash.set(485, "i");
490predefinedDecHash.set(486, "B");
491predefinedDecHash.set(487, "2");
492predefinedDecHash.set(488, "b");
493predefinedDecHash.set(489, "2");
494predefinedDecHash.set(490, "x");
495predefinedDecHash.set(491, "1");
496predefinedDecHash.set(492, "c");
497predefinedDecHash.set(493, "H");
498predefinedDecHash.set(494, "R");
499predefinedDecHash.set(495, "h");
500predefinedDecHash.set(496, "d");
501predefinedDecHash.set(497, "G");
502predefinedDecHash.set(498, "U");
503predefinedDecHash.set(499, "g");
504predefinedDecHash.set(500, "d");
505predefinedDecHash.set(501, "m");
506predefinedDecHash.set(502, "V");
507predefinedDecHash.set(503, "s");
508predefinedDecHash.set(504, "a");
509predefinedDecHash.set(505, "X");
510predefinedDecHash.set(506, "Q");
511predefinedDecHash.set(507, "g");
512predefinedDecHash.set(508, "Z");
513predefinedDecHash.set(509, "X");
514predefinedDecHash.set(510, "N");
515predefinedDecHash.set(511, "z");
516predefinedDecHash.set(512, "Z");
517predefinedDecHash.set(513, "S");
518predefinedDecHash.set(514, "B");
519predefinedDecHash.set(515, "j");
520predefinedDecHash.set(516, "a");
521predefinedDecHash.set(517, "W");
522predefinedDecHash.set(518, "x");
523predefinedDecHash.set(519, "s");
524predefinedDecHash.set(520, "d");
525predefinedDecHash.set(521, "W");
526predefinedDecHash.set(522, "0");
527predefinedDecHash.set(523, "g");
528predefinedDecHash.set(524, "Z");
529predefinedDecHash.set(525, "G");
530predefinedDecHash.set(526, "9");
531predefinedDecHash.set(527, "s");
532predefinedDecHash.set(528, "b");
533predefinedDecHash.set(529, "3");
534predefinedDecHash.set(530, "J");
535predefinedDecHash.set(531, "l");
536predefinedDecHash.set(532, "I");
537predefinedDecHash.set(533, "G");
538predefinedDecHash.set(534, "V");
539predefinedDecHash.set(535, "1");
540predefinedDecHash.set(536, "I");
541predefinedDecHash.set(537, "G");
542predefinedDecHash.set(538, "Z");
543predefinedDecHash.set(539, "1");
544predefinedDecHash.set(540, "Z");
545predefinedDecHash.set(541, "2");
546predefinedDecHash.set(542, "l");
547predefinedDecHash.set(543, "h");
548predefinedDecHash.set(544, "d");
549predefinedDecHash.set(545, "C");
550predefinedDecHash.set(546, "B");
551predefinedDecHash.set(547, "u");
552predefinedDecHash.set(548, "d");
553predefinedDecHash.set(549, "W");
554predefinedDecHash.set(550, "x");
555predefinedDecHash.set(551, "s");
556predefinedDecHash.set(552, "Y");
557predefinedDecHash.set(553, "S");
558predefinedDecHash.set(554, "B");
559predefinedDecHash.set(555, "w");
560predefinedDecHash.set(556, "Y");
561predefinedDecHash.set(557, "X");
562predefinedDecHash.set(558, "J");
563predefinedDecHash.set(559, "p");
564predefinedDecHash.set(560, "Y");
565predefinedDecHash.set(561, "X");
566predefinedDecHash.set(562, "R");
567predefinedDecHash.set(563, "1");
568predefinedDecHash.set(564, "c");
569predefinedDecHash.set(565, "i");
570predefinedDecHash.set(566, "4");
571predefinedDecHash.set(567, "g");
572predefinedDecHash.set(568, "R");
573predefinedDecHash.set(569, "X");
574predefinedDecHash.set(570, "h");
575predefinedDecHash.set(571, "j");
576predefinedDecHash.set(572, "Z");
577predefinedDecHash.set(573, "X");
578predefinedDecHash.set(574, "B");
579predefinedDecHash.set(575, "0");
580predefinedDecHash.set(576, "Z");
581predefinedDecHash.set(577, "X");
582predefinedDecHash.set(578, "V");
583predefinedDecHash.set(579, "y");
584predefinedDecHash.set(580, "I");
585predefinedDecHash.set(581, "H");
586predefinedDecHash.set(582, "N");
587predefinedDecHash.set(583, "p");
588predefinedDecHash.set(584, "b");
589predefinedDecHash.set(585, "n");
590predefinedDecHash.set(586, "Q");
591predefinedDecHash.set(587, "g");
592predefinedDecHash.set(588, "b");
593predefinedDecHash.set(589, "2");
594predefinedDecHash.set(590, "N");
595predefinedDecHash.set(591, "j");
596predefinedDecHash.set(592, "Y");
597predefinedDecHash.set(593, "W");
598predefinedDecHash.set(594, "V");
599predefinedDecHash.set(595, "j");
600predefinedDecHash.set(596, "Y");
601predefinedDecHash.set(597, "X");
602predefinedDecHash.set(598, "Q");
603predefinedDecHash.set(599, "g");
604predefinedDecHash.set(600, "Y");
605predefinedDecHash.set(601, "3");
606predefinedDecHash.set(602, "V");
607predefinedDecHash.set(603, "w");
608predefinedDecHash.set(604, "a");
609predefinedDecHash.set(605, "W");
610predefinedDecHash.set(606, "R");
611predefinedDecHash.set(607, "h");
612predefinedDecHash.set(608, "d");
613predefinedDecHash.set(609, "G");
614predefinedDecHash.set(610, "F");
615predefinedDecHash.set(611, "0");
616predefinedDecHash.set(612, "I");
617predefinedDecHash.set(613, "G");
618predefinedDecHash.set(614, "5");
619predefinedDecHash.set(615, "v");
620predefinedDecHash.set(616, "b");
621predefinedDecHash.set(617, "i");
622predefinedDecHash.set(618, "B");
623predefinedDecHash.set(619, "w");
624predefinedDecHash.set(620, "c");
625predefinedDecHash.set(621, "m");
626predefinedDecHash.set(622, "9");
627predefinedDecHash.set(623, "p");
628predefinedDecHash.set(624, "Z");
629predefinedDecHash.set(625, "G");
630predefinedDecHash.set(626, "V");
631predefinedDecHash.set(627, "u");
632predefinedDecHash.set(628, "d");
633predefinedDecHash.set(629, "C");
634predefinedDecHash.set(630, "w");
635predefinedDecHash.set(631, "g");
636predefinedDecHash.set(632, "c");
637predefinedDecHash.set(633, "3");
638predefinedDecHash.set(634, "V");
639predefinedDecHash.set(635, "u");
640predefinedDecHash.set(636, "d");
641predefinedDecHash.set(637, "C");
642predefinedDecHash.set(638, "B");
643predefinedDecHash.set(639, "p");
644predefinedDecHash.set(640, "b");
645predefinedDecHash.set(641, "i");
646predefinedDecHash.set(642, "B");
647predefinedDecHash.set(643, "j");
648predefinedDecHash.set(644, "d");
649predefinedDecHash.set(645, "W");
650predefinedDecHash.set(646, "x");
651predefinedDecHash.set(647, "w");
652predefinedDecHash.set(648, "Y");
653predefinedDecHash.set(649, "S");
654predefinedDecHash.set(650, "B");
655predefinedDecHash.set(651, "x");
656predefinedDecHash.set(652, "d");
657predefinedDecHash.set(653, "W");
658predefinedDecHash.set(654, "k");
659predefinedDecHash.set(655, "g");
660predefinedDecHash.set(656, "b");
661predefinedDecHash.set(657, "2");
662predefinedDecHash.set(658, "Z");
663predefinedDecHash.set(659, "m");
664predefinedDecHash.set(660, "a");
665predefinedDecHash.set(661, "W");
666predefinedDecHash.set(662, "N");
667predefinedDecHash.set(663, "p");
668predefinedDecHash.set(664, "Y");
669predefinedDecHash.set(665, "S");
670predefinedDecHash.set(666, "B");
671predefinedDecHash.set(667, "k");
672predefinedDecHash.set(668, "Z");
673predefinedDecHash.set(669, "X");
674predefinedDecHash.set(670, "N");
675predefinedDecHash.set(671, "l");
676predefinedDecHash.set(672, "c");
677predefinedDecHash.set(673, "n");
678predefinedDecHash.set(674, "V");
679predefinedDecHash.set(675, "u");
680predefinedDecHash.set(676, "d");
681predefinedDecHash.set(677, "C");
682predefinedDecHash.set(678, "B");
683predefinedDecHash.set(679, "t");
684predefinedDecHash.set(680, "b");
685predefinedDecHash.set(681, "2");
686predefinedDecHash.set(682, "x");
687predefinedDecHash.set(683, "s");
688predefinedDecHash.set(684, "a");
689predefinedDecHash.set(685, "X");
690predefinedDecHash.set(686, "Q");
691predefinedDecHash.set(687, "g");
692predefinedDecHash.set(688, "Y");
693predefinedDecHash.set(689, "W");
694predefinedDecHash.set(690, "5");
695predefinedDecHash.set(691, "p");
696predefinedDecHash.set(692, "b");
697predefinedDecHash.set(693, "S");
698predefinedDecHash.set(694, "B");
699predefinedDecHash.set(695, "p");
700predefinedDecHash.set(696, "Z");
701predefinedDecHash.set(697, "C");
702predefinedDecHash.set(698, "B");
703predefinedDecHash.set(699, "l");
704predefinedDecHash.set(700, "c");
705predefinedDecHash.set(701, "3");
706predefinedDecHash.set(702, "Q");
707predefinedDecHash.set(703, "g");
708predefinedDecHash.set(704, "b");
709predefinedDecHash.set(705, "G");
710predefinedDecHash.set(706, "F");
711predefinedDecHash.set(707, "i");
712predefinedDecHash.set(708, "b");
713predefinedDecHash.set(709, "3");
714predefinedDecHash.set(710, "J");
715predefinedDecHash.set(711, "1");
716predefinedDecHash.set(712, "b");
717predefinedDecHash.set(713, "S");
718predefinedDecHash.set(714, "4");
719predefinedDecHash.set(715, "D");
720predefinedDecHash.set(716, "q");
721predefinedDecHash.set(717, "6");
722predefinedDecHash.set(718, "/");
723
724predefinedEncHash.set("A", [70,90]);
725predefinedEncHash.set("B", [22,150,158,174,202,206,222,226,254,258,286,290,326,354,382,386,430,482,486,514,546,554,574,618,638,642,650,666,678,694,698]);
726predefinedEncHash.set("C", [21,93,149,157,201,257,289,385,481,545,629,637,677,697]);
727predefinedEncHash.set("D", [0,715]);
728predefinedEncHash.set("E", [37,49,121,274,431]);
729predefinedEncHash.set("F", [9,10,17,270,298,426,438,610,706]);
730predefinedEncHash.set("G", [5,23,33,45,65,129,137,141,177,189,233,245,297,301,337,349,357,365,389,397,401,405,413,437,441,453,497,525,533,537,609,613,625,705]);
731predefinedEncHash.set("H", [81,145,197,217,241,309,493,581]);
732predefinedEncHash.set("I", [8,16,36,42,48,88,118,128,136,144,188,196,216,240,244,296,300,308,336,364,396,400,404,436,458,532,536,580,612]);
733predefinedEncHash.set("J", [18,58,92,96,342,446,478,530,558,710]);
734predefinedEncHash.set("K", [100]);
735predefinedEncHash.set("L", [68,156,284,428]);
736predefinedEncHash.set("M", [116,374]);
737predefinedEncHash.set("N", [14,112,146,166,182,198,230,330,362,406,510,582,590,662,670]);
738predefinedEncHash.set("O", [108]);
739predefinedEncHash.set("P", [72,76,104]);
740predefinedEncHash.set("Q", [56,194,506,586,598,686,702]);
741predefinedEncHash.set("R", [64,138,170,218,346,494,562,568,606]);
742predefinedEncHash.set("S", [28,105,253,317,381,513,553,649,665,693,713]);
743predefinedEncHash.set("T", [109]);
744predefinedEncHash.set("U", [89,114,266,442,450,498]);
745predefinedEncHash.set("V", [4,30,34,94,101,126,134,154,190,210,242,282,287,322,334,338,398,402,422,466,470,502,534,578,594,602,626,634,674]);
746predefinedEncHash.set("W", [13,84,153,165,185,213,237,269,277,361,393,409,425,433,461,473,517,521,549,593,605,645,653,661,689]);
747predefinedEncHash.set("X", [41,169,181,193,209,221,281,321,341,345,373,445,477,505,509,557,561,569,573,577,597,669,685]);
748predefinedEncHash.set("Y", [120,248,276,368,416,552,556,560,592,596,600,648,664,688]);
749predefinedEncHash.set("Z", [20,40,164,168,176,200,232,252,310,340,412,452,472,476,508,512,524,538,540,572,576,624,658,668,696]);
750predefinedEncHash.set("a", [12,180,184,192,208,344,372,380,444,460,504,516,604,660,684]);
751predefinedEncHash.set("b", [24,140,152,160,204,212,220,228,260,268,272,292,304,312,316,328,352,356,360,376,388,408,456,484,488,528,584,588,616,640,656,680,692,704,708,712]);
752predefinedEncHash.set("c", [32,124,132,172,224,264,280,320,324,332,420,448,464,468,492,564,620,632,672,700]);
753predefinedEncHash.set("d", [44,60,148,236,256,288,348,384,392,424,432,440,480,496,500,520,544,548,608,628,636,644,652,676]);
754predefinedEncHash.set("e", [52,95]);
755predefinedEncHash.set("f", [80]);
756predefinedEncHash.set("g", [26,27,43,55,63,110,267,275,319,375,415,443,451,459,463,499,507,523,567,587,599,631,655,687,703]);
757predefinedEncHash.set("h", [6,46,51,151,175,247,283,315,347,359,367,387,403,495,543,570,607]);
758predefinedEncHash.set("i", [69,73,97,173,225,285,353,429,485,565,617,641,707]);
759predefinedEncHash.set("j", [91,113,159,183,343,515,571,591,595,643]);
760predefinedEncHash.set("k", [35,54,203,215,235,259,299,335,475,654,667]);
761predefinedEncHash.set("l", [7,19,47,130,178,199,207,219,234,255,291,294,306,311,314,350,378,390,394,434,531,542,671,699]);
762predefinedEncHash.set("m", [125,229,249,265,273,293,305,313,369,377,449,465,469,501,621,659]);
763predefinedEncHash.set("n", [29,53,57,67,187,271,333,585,673]);
764predefinedEncHash.set("o", [78,98,99,471]);
765predefinedEncHash.set("p", [147,227,231,279,303,323,479,483,559,583,623,639,663,691,695]);
766predefinedEncHash.set("q", [1,716]);
767predefinedEncHash.set("r", [15,103]);
768predefinedEncHash.set("s", [191,195,455,503,519,527,551,683]);
769predefinedEncHash.set("t", [31,82,127,135,295,307,679]);
770predefinedEncHash.set("u", [75,327,419,547,627,635,675]);
771predefinedEncHash.set("v", [59,123,139,223,263,351,363,407,411,615]);
772predefinedEncHash.set("w", [74,107,131,179,318,395,467,555,603,619,630,647]);
773predefinedEncHash.set("x", [50,119,122,246,262,278,358,366,391,423,490,518,550,646,651,682]);
774predefinedEncHash.set("y", [143,205,251,325,371,579]);
775predefinedEncHash.set("z", [77,117,163,211,379,435,511]);
776predefinedEncHash.set("0", [106,115,155,167,239,243,331,427,522,575,611]);
777predefinedEncHash.set("1", [11,85,86,171,302,355,383,410,439,447,491,535,539,563,711]);
778predefinedEncHash.set("2", [39,61,161,261,417,421,487,489,541,589,657,681]);
779predefinedEncHash.set("3", [25,111,133,329,457,529,601,633,701,709]);
780predefinedEncHash.set("4", [62,339,399,462,566,714]);
781predefinedEncHash.set("5", [162,186,238,474,614,690]);
782predefinedEncHash.set("6", [2,717]);
783predefinedEncHash.set("7", [79]);
784predefinedEncHash.set("8", [71,102,414]);
785predefinedEncHash.set("9", [38,66,83,142,214,250,370,418,454,526,622]);
786predefinedEncHash.set("+", [87]);
787predefinedEncHash.set("/", [3,718]);
Full Screen

mockData.js

Source: mockData.js Github

copy
1export const fakeComments = [
2  {
3    comment: 'This is nice!',
4    creation_date: '2021-01-10',
5    username: 'John',
6  },
7  {
8    comment: 'Great content!',
9    creation_date: '2021-02-10',
10    username: 'Jane',
11  },
12];
13
14export const fakeCards = [
15  {
16    id: 23771716,
17    name: '7 Colored Fish',
18    type: 'Normal Monster',
19    desc: 'A rare rainbow fish that has never been caught by mortal man.',
20    atk: 1800,
21    def: 800,
22    level: 4,
23    race: 'Fish',
24    attribute: 'WATER',
25    card_sets: [
26      {
27        set_name: 'Gold Series',
28        set_code: 'GLD1-EN001',
29        set_rarity: 'Common',
30        set_rarity_code: '(C)',
31        set_price: '0.74',
32      },
33      {
34        set_name: 'Metal Raiders',
35        set_code: 'MRD-098',
36        set_rarity: 'Common',
37        set_rarity_code: '(C)',
38        set_price: '1.06',
39      },
40      {
41        set_name: 'Metal Raiders',
42        set_code: 'MRD-E098',
43        set_rarity: 'Common',
44        set_rarity_code: '(C)',
45        set_price: '2.63',
46      },
47      {
48        set_name: 'Metal Raiders',
49        set_code: 'MRD-EN098',
50        set_rarity: 'Common',
51        set_rarity_code: '(C)',
52        set_price: '2.95',
53      },
54      {
55        set_name: 'Starter Deck: Joey',
56        set_code: 'SDJ-008',
57        set_rarity: 'Common',
58        set_rarity_code: '(C)',
59        set_price: '1.02',
60      },
61      {
62        set_name: 'Structure Deck: Fury from the Deep',
63        set_code: 'SD4-EN002',
64        set_rarity: 'Common',
65        set_rarity_code: '(C)',
66        set_price: '1.12',
67      },
68    ],
69    card_images: [
70      {
71        id: 23771716,
72        image_url: 'https://storage.googleapis.com/ygoprodeck.com/pics/23771716.jpg',
73        image_url_small: 'https://storage.googleapis.com/ygoprodeck.com/pics_small/23771716.jpg',
74      },
75    ],
76    card_prices: [
77      {
78        cardmarket_price: '0.07',
79        tcgplayer_price: '0.23',
80        ebay_price: '1.75',
81        amazon_price: '0.25',
82        coolstuffinc_price: '0.25',
83      },
84    ],
85  },
86  {
87    id: 42431843,
88    name: 'Ancient Brain',
89    type: 'Normal Monster',
90    desc: 'A fallen fairy that is powerful in the dark.',
91    atk: 1000,
92    def: 700,
93    level: 3,
94    race: 'Fiend',
95    attribute: 'DARK',
96    card_sets: [
97      {
98        set_name: 'Metal Raiders',
99        set_code: 'MRD-082',
100        set_rarity: 'Common',
101        set_rarity_code: '(C)',
102        set_price: '1.03',
103      },
104      {
105        set_name: 'Metal Raiders',
106        set_code: 'MRD-E082',
107        set_rarity: 'Common',
108        set_rarity_code: '(C)',
109        set_price: '13.17',
110      },
111      {
112        set_name: 'Metal Raiders',
113        set_code: 'MRD-EN082',
114        set_rarity: 'Common',
115        set_rarity_code: '(C)',
116        set_price: '2.95',
117      },
118      {
119        set_name: 'Speed Duel: Trials of the Kingdom',
120        set_code: 'SBTK-EN004',
121        set_rarity: 'Common',
122        set_rarity_code: '(C)',
123        set_price: '0.96',
124      },
125    ],
126    card_images: [
127      {
128        id: 42431843,
129        image_url: 'https://storage.googleapis.com/ygoprodeck.com/pics/42431843.jpg',
130        image_url_small: 'https://storage.googleapis.com/ygoprodeck.com/pics_small/42431843.jpg',
131      },
132    ],
133    card_prices: [
134      {
135        cardmarket_price: '0.09',
136        tcgplayer_price: '0.13',
137        ebay_price: '6.49',
138        amazon_price: '1.28',
139        coolstuffinc_price: '0.25',
140      },
141    ],
142  },
143  {
144    id: 93221206,
145    name: 'Ancient Elf',
146    type: 'Normal Monster',
147    desc: 'This elf is rumored to have lived for thousands of years. He leads an army of spirits against his enemies.',
148    atk: 1450,
149    def: 1200,
150    level: 4,
151    race: 'Spellcaster',
152    attribute: 'LIGHT',
153    card_sets: [
154      {
155        set_name: 'Metal Raiders',
156        set_code: 'MRD-037',
157        set_rarity: 'Common',
158        set_rarity_code: '(C)',
159        set_price: '1.07',
160      },
161      {
162        set_name: 'Metal Raiders',
163        set_code: 'MRD-E037',
164        set_rarity: 'Common',
165        set_rarity_code: '(C)',
166        set_price: '9.17',
167      },
168      {
169        set_name: 'Metal Raiders',
170        set_code: 'MRD-EN037',
171        set_rarity: 'Common',
172        set_rarity_code: '(C)',
173        set_price: '0.00',
174      },
175      {
176        set_name: 'Starter Deck: Yugi',
177        set_code: 'SDY-024',
178        set_rarity: 'Common',
179        set_rarity_code: '(C)',
180        set_price: '1.01',
181      },
182      {
183        set_name: 'Starter Deck: Yugi',
184        set_code: 'SDY-E022',
185        set_rarity: 'Common',
186        set_rarity_code: '(C)',
187        set_price: '23.28',
188      },
189    ],
190    card_images: [
191      {
192        id: 93221206,
193        image_url: 'https://storage.googleapis.com/ygoprodeck.com/pics/93221206.jpg',
194        image_url_small: 'https://storage.googleapis.com/ygoprodeck.com/pics_small/93221206.jpg',
195      },
196    ],
197    card_prices: [
198      {
199        cardmarket_price: '0.03',
200        tcgplayer_price: '0.20',
201        ebay_price: '0.99',
202        amazon_price: '0.68',
203        coolstuffinc_price: '0.25',
204      },
205    ],
206  },
207  {
208    id: 43230671,
209    name: 'Ancient Lizard Warrior',
210    type: 'Normal Monster',
211    desc: 'Before the dawn of man, this lizard warrior ruled supreme.',
212    atk: 1400,
213    def: 1100,
214    level: 4,
215    race: 'Reptile',
216    attribute: 'EARTH',
217    card_sets: [
218      {
219        set_name: 'Metal Raiders',
220        set_code: 'MRD-050',
221        set_rarity: 'Common',
222        set_rarity_code: '(C)',
223        set_price: '0.95',
224      },
225      {
226        set_name: 'Metal Raiders',
227        set_code: 'MRD-E050',
228        set_rarity: 'Common',
229        set_rarity_code: '(C)',
230        set_price: '9.74',
231      },
232      {
233        set_name: 'Metal Raiders',
234        set_code: 'MRD-EN050',
235        set_rarity: 'Common',
236        set_rarity_code: '(C)',
237        set_price: '1.72',
238      },
239    ],
240    card_images: [
241      {
242        id: 43230671,
243        image_url: 'https://storage.googleapis.com/ygoprodeck.com/pics/43230671.jpg',
244        image_url_small: 'https://storage.googleapis.com/ygoprodeck.com/pics_small/43230671.jpg',
245      },
246    ],
247    card_prices: [
248      {
249        cardmarket_price: '0.16',
250        tcgplayer_price: '0.17',
251        ebay_price: '0.99',
252        amazon_price: '0.80',
253        coolstuffinc_price: '0.25',
254      },
255    ],
256  },
257  {
258    id: 15480588,
259    name: 'Armored Lizard',
260    type: 'Normal Monster',
261    desc: 'A lizard with a very tough hide and a vicious bite.',
262    atk: 1500,
263    def: 1200,
264    level: 4,
265    race: 'Reptile',
266    attribute: 'EARTH',
267    card_sets: [
268      {
269        set_name: 'Dark Beginning 1',
270        set_code: 'DB1-EN143',
271        set_rarity: 'Common',
272        set_rarity_code: '(C)',
273        set_price: '1.01',
274      },
275      {
276        set_name: 'Metal Raiders',
277        set_code: 'MRD-005',
278        set_rarity: 'Common',
279        set_rarity_code: '(C)',
280        set_price: '0.96',
281      },
282      {
283        set_name: 'Metal Raiders',
284        set_code: 'MRD-E005',
285        set_rarity: 'Common',
286        set_rarity_code: '(C)',
287        set_price: '4.89',
288      },
289      {
290        set_name: 'Metal Raiders',
291        set_code: 'MRD-EN005',
292        set_rarity: 'Common',
293        set_rarity_code: '(C)',
294        set_price: '2.95',
295      },
296      {
297        set_name: 'Starter Deck: Joey',
298        set_code: 'SDJ-009',
299        set_rarity: 'Common',
300        set_rarity_code: '(C)',
301        set_price: '0.98',
302      },
303    ],
304    card_images: [
305      {
306        id: 15480588,
307        image_url: 'https://storage.googleapis.com/ygoprodeck.com/pics/15480588.jpg',
308        image_url_small: 'https://storage.googleapis.com/ygoprodeck.com/pics_small/15480588.jpg',
309      },
310    ],
311    card_prices: [
312      {
313        cardmarket_price: '0.09',
314        tcgplayer_price: '0.13',
315        ebay_price: '0.99',
316        amazon_price: '0.69',
317        coolstuffinc_price: '0.25',
318      },
319    ],
320  },
321];
Full Screen

LudiPQ.js

Source: LudiPQ.js Github

copy
1/**
2 * @author : Eric
3 * @script: LudiPQ
4 * @func: Ludibrium PQ (101st Eos Tower)
5*/
6
7var stg6_combo = Array("0", "1", "2", "3", "4", "5", "6", "7", "8", "9");
8var minPlayers = 3;
9
10function init() {
11    em.setProperty("state", "0");
12}
13
14function setup(level, leaderid) {
15    em.setProperty("state", "1");
16	em.setProperty("portal1", "1");
17	em.setProperty("portal2", "1");
18	em.setProperty("portal3", "1");
19	em.setProperty("portal4", "1");
20	em.setProperty("portal5", "1");
21	em.setProperty("portal6", "1");
22	em.setProperty("portal7", "1");
23	em.setProperty("portal8", "1");
24	em.setProperty("portal9", "1");
25	em.setProperty("portal10", "1");
26    var eim = em.newInstance("LudiPQ");
27    eim.setProperty("stage2", "0");
28    var map = eim.setInstanceMap(922010100);
29    map.resetPQ(level);
30    map = eim.setInstanceMap(922010400);
31    map.resetPQ(level);
32    eim.setInstanceMap(922010401).resetPQ(level);
33    eim.setInstanceMap(922010402).resetPQ(level);
34    eim.setInstanceMap(922010403).resetPQ(level);
35    eim.setInstanceMap(922010404).resetPQ(level);
36    eim.setInstanceMap(922010405).resetPQ(level);
37    map = eim.setInstanceMap(922010700);
38	map.resetPQ(level);
39	map.getPortal("next00").setScriptName("lpq7");
40	eim.setInstanceMap(922010800).getPortal("next00").setScriptName("lpq8");
41    eim.setInstanceMap(922010900).resetPQ(level);
42	// TODO: Remastered portal calculations.
43	for (var b = 0; b < stg6_combo.length; b++) { //stage6_001
44		for (var y = 0; y < 3; y++) { //stage number
45			em.setProperty("stage6_" + stg6_combo[b] + "" + y + "", "0");
46		}
47	}
48	for (var b = 0; b < stg6_combo.length; b++) { //stage6_001	
49		var found = false;
50		while (!found) {
51			for (var x = 0; x < 3; x++) {
52				if (!found) {
53					var founded = false;
54					for (var z = 0; z < 3; z++) { //check if any other stages have this value set already.
55						if (em.getProperty("stage6_" + stg6_combo[b] + "" + (z) + "") == null) {
56							em.setProperty("stage6_" + stg6_combo[b] + "" + (z) + "", "0");
57						} else if (em.getProperty("stage6_" + stg6_combo[b] + "" + (z) + "").equals("1")) {
58							founded = true;
59							break;
60						}
61					}
62					if (!founded && java.lang.Math.random() < 0.33) {
63						em.setProperty("stage6_" + stg6_combo[b] + "" + (x) + "", "1");
64						found = true;
65						break;
66					}
67				}
68			}
69		}
70	}
71    eim.startEventTimer(1200000); //20 mins
72    return eim;
73}
74
75function monsterValue(eim, mobId) {
76    return 1;
77}
78
79function scheduledTimeout(eim) {
80    eim.disposeIfPlayerBelow(100, 922010000);
81    em.setProperty("state", "0");
82	em.setProperty("portal1", "1");
83	em.setProperty("portal2", "1");
84	em.setProperty("portal3", "1");
85	em.setProperty("portal4", "1");
86	em.setProperty("portal5", "1");
87	em.setProperty("portal6", "1");
88	em.setProperty("portal7", "1");
89	em.setProperty("portal8", "1");
90	em.setProperty("portal9", "1");
91	em.setProperty("portal10", "1");
92}
93
94function changedMap(eim, player, mapid) {
95    switch (mapid) {
96		case 922010100: // Stage 1
97		case 922010200: // Stage 2
98		case 922010201: // Stage 2 - Tower's Trap'
99		case 922010300: // Stage 3
100		case 922010400: //stage 4
101		case 922010401: //darkness in stage 4
102		case 922010402: //darkness in stage 4
103		case 922010403: //darkness in stage 4
104		case 922010404: //darkness in stage 4
105		case 922010405: //darkness in stage 4
106		case 922010500: //stage 5
107		case 922010501: //tower's maze in stage 5
108		case 922010502: //tower's maze in stage 5
109		case 922010503: //tower's maze in stage 5
110		case 922010504: //tower's maze in stage 5
111		case 922010505: //tower's maze in stage 5
112		case 922010506: //tower's maze in stage 5
113		case 922010600:
114		case 922010700: //stage 7
115		case 922010800:
116		case 922010900: //crack on the wall
117		case 922011000: //bonus
118			return;
119    }
120    eim.unregisterPlayer(player);
121    if (eim.disposeIfPlayerBelow(0, 0)) {
122		em.setProperty("state", "0");
123		em.setProperty("portal1", "1");
124		em.setProperty("portal2", "1");
125		em.setProperty("portal3", "1");
126		em.setProperty("portal4", "1");
127		em.setProperty("portal5", "1");
128		em.setProperty("portal6", "1");
129		em.setProperty("portal7", "1");
130		em.setProperty("portal8", "1");
131		em.setProperty("portal9", "1");
132		em.setProperty("portal10", "1");
133    }
134}
135
136function playerEntry(eim, player) {
137    var map = em.getMapFactory().getMap(922010100);
138    player.changeMap(map, map.getPortal(0));
139    player.tryPartyQuest(1202);
140}
141
142function playerDisconnected(eim, player) {
143	return -3;
144}
145
146function leftParty(eim, player) {			
147    if (eim.disposeIfPlayerBelow(minPlayers, 922010000)) {
148		em.setProperty("state", "0");
149		em.setProperty("portal1", "1");
150		em.setProperty("portal2", "1");
151		em.setProperty("portal3", "1");
152		em.setProperty("portal4", "1");
153		em.setProperty("portal5", "1");
154		em.setProperty("portal6", "1");
155		em.setProperty("portal7", "1");
156		em.setProperty("portal8", "1");
157		em.setProperty("portal9", "1");
158		em.setProperty("portal10", "1");
159    } else {
160		playerExit(eim, player);
161    }
162}
163
164function disbandParty(eim) {
165    eim.disposeIfPlayerBelow(100, 922010000);
166    em.setProperty("state", "0");
167	em.setProperty("portal1", "1");
168	em.setProperty("portal2", "1");
169	em.setProperty("portal3", "1");
170	em.setProperty("portal4", "1");
171	em.setProperty("portal5", "1");
172	em.setProperty("portal6", "1");
173	em.setProperty("portal7", "1");
174	em.setProperty("portal8", "1");
175	em.setProperty("portal9", "1");
176	em.setProperty("portal10", "1");
177}
178
179function playerExit(eim, player) {
180    var map = em.getMapFactory().getMap(922010000);
181    eim.unregisterPlayer(player);
182    player.changeMap(map, map.getPortal(0));
183}
184
185function removePlayer(eim, player) {
186    eim.unregisterPlayer(player);
187}
188
189function clearPQ(eim) {
190    eim.disposeIfPlayerBelow(100, 922010000);
191    em.setProperty("state", "0");
192	em.setProperty("portal1", "1");
193	em.setProperty("portal2", "1");
194	em.setProperty("portal3", "1");
195	em.setProperty("portal4", "1");
196	em.setProperty("portal5", "1");
197	em.setProperty("portal6", "1");
198	em.setProperty("portal7", "1");
199	em.setProperty("portal8", "1");
200	em.setProperty("portal9", "1");
201	em.setProperty("portal10", "1");
202}
203
204function finish(eim) {
205    eim.disposeIfPlayerBelow(100, 922010000);
206    em.setProperty("state", "0");
207	em.setProperty("portal1", "1");
208	em.setProperty("portal2", "1");
209	em.setProperty("portal3", "1");
210	em.setProperty("portal4", "1");
211	em.setProperty("portal5", "1");
212	em.setProperty("portal6", "1");
213	em.setProperty("portal7", "1");
214	em.setProperty("portal8", "1");
215	em.setProperty("portal9", "1");
216	em.setProperty("portal10", "1");
217}
218
219function timeOut(eim) {
220    eim.disposeIfPlayerBelow(100, 922010000);
221    em.setProperty("state", "0");
222	em.setProperty("portal1", "1");
223	em.setProperty("portal2", "1");
224	em.setProperty("portal3", "1");
225	em.setProperty("portal4", "1");
226	em.setProperty("portal5", "1");
227	em.setProperty("portal6", "1");
228	em.setProperty("portal7", "1");
229	em.setProperty("portal8", "1");
230	em.setProperty("portal9", "1");
231	em.setProperty("portal10", "1");
232}
233
234function cancelSchedule() {}
235function playerDead() {}
236function allMonstersDead(eim) {}
237function playerRevive(eim, player) {}
Full Screen

Accelerate Your Automation Test Cycles With LambdaTest

Leverage LambdaTest’s cloud-based platform to execute your automation tests in parallel and trim down your test execution time significantly. Your first 100 automation testing minutes are on us.

Try LambdaTest

Run JavaScript Tests on LambdaTest Cloud Grid

Execute automation tests with Cypress on a cloud-based Grid of 3000+ real browsers and operating systems for both web and mobile applications.

Test now for Free
LambdaTestX

We use cookies to give you the best experience. Cookies help to provide a more personalized experience and relevant advertising for you, and web analytics for us. Learn More in our Cookies policy, Privacy & Terms of service

Allow Cookie
Sarah

I hope you find the best code examples for your project.

If you want to accelerate automated browser testing, try LambdaTest. Your first 100 automation testing minutes are FREE.

Sarah Elson (Product & Growth Lead)