11596 lines
448 KiB
JavaScript
11596 lines
448 KiB
JavaScript
// Copyright 2012 the V8 project authors. All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
// Simple framework for running the benchmark suites and
|
|
// computing a score based on the timing measurements.
|
|
|
|
if (typeof print == "undefined")
|
|
|
|
print = console.log;
|
|
|
|
// A benchmark has a name (string) and a function that will be run to
|
|
// do the performance measurement. The optional setup and tearDown
|
|
// arguments are functions that will be invoked before and after
|
|
// running the benchmark, but the running time of these functions will
|
|
// not be accounted for in the benchmark score.
|
|
function Benchmark(name, run, setup, tearDown) {
|
|
this.name = name;
|
|
this.run = run;
|
|
this.Setup = setup ? setup : function() { };
|
|
this.TearDown = tearDown ? tearDown : function() { };
|
|
}
|
|
|
|
|
|
// Benchmark results hold the benchmark and the measured time used to
|
|
// run the benchmark. The benchmark score is computed later once a
|
|
// full benchmark suite has run to completion.
|
|
function BenchmarkResult(benchmark, time) {
|
|
this.benchmark = benchmark;
|
|
this.time = time;
|
|
}
|
|
|
|
|
|
// Automatically convert results to numbers. Used by the geometric
|
|
// mean computation.
|
|
BenchmarkResult.prototype.valueOf = function() {
|
|
return this.time;
|
|
}
|
|
|
|
|
|
// Suites of benchmarks consist of a name and the set of benchmarks in
|
|
// addition to the reference timing that the final score will be based
|
|
// on. This way, all scores are relative to a reference run and higher
|
|
// scores implies better performance.
|
|
function BenchmarkSuite(name, reference, benchmarks) {
|
|
this.name = name;
|
|
this.reference = reference;
|
|
this.benchmarks = benchmarks;
|
|
BenchmarkSuite.suites.push(this);
|
|
}
|
|
|
|
|
|
// Keep track of all declared benchmark suites.
|
|
BenchmarkSuite.suites = [];
|
|
|
|
|
|
// Scores are not comparable across versions. Bump the version if
|
|
// you're making changes that will affect that scores, e.g. if you add
|
|
// a new benchmark or change an existing one.
|
|
BenchmarkSuite.version = '7';
|
|
|
|
|
|
// To make the benchmark results predictable, we replace Math.random
|
|
// with a 100% deterministic alternative.
|
|
Math.random = (function() {
|
|
var seed = 49734321;
|
|
return function() {
|
|
// Robert Jenkins' 32 bit integer hash function.
|
|
seed = ((seed + 0x7ed55d16) + (seed << 12)) & 0xffffffff;
|
|
seed = ((seed ^ 0xc761c23c) ^ (seed >>> 19)) & 0xffffffff;
|
|
seed = ((seed + 0x165667b1) + (seed << 5)) & 0xffffffff;
|
|
seed = ((seed + 0xd3a2646c) ^ (seed << 9)) & 0xffffffff;
|
|
seed = ((seed + 0xfd7046c5) + (seed << 3)) & 0xffffffff;
|
|
seed = ((seed ^ 0xb55a4f09) ^ (seed >>> 16)) & 0xffffffff;
|
|
return (seed & 0xfffffff) / 0x10000000;
|
|
};
|
|
})();
|
|
|
|
|
|
// Runs all registered benchmark suites and optionally yields between
|
|
// each individual benchmark to avoid running for too long in the
|
|
// context of browsers. Once done, the final score is reported to the
|
|
// runner.
|
|
BenchmarkSuite.RunSuites = function(runner) {
|
|
var continuation = null;
|
|
var suites = BenchmarkSuite.suites;
|
|
var length = suites.length;
|
|
BenchmarkSuite.scores = [];
|
|
var index = 0;
|
|
function RunStep() {
|
|
while (continuation || index < length) {
|
|
if (continuation) {
|
|
continuation = continuation();
|
|
} else {
|
|
var suite = suites[index++];
|
|
if (runner.NotifyStart) runner.NotifyStart(suite.name);
|
|
continuation = suite.RunStep(runner);
|
|
}
|
|
if (continuation && typeof window != 'undefined' && window.setTimeout) {
|
|
window.setTimeout(RunStep, 25);
|
|
return;
|
|
}
|
|
}
|
|
if (runner.NotifyScore) {
|
|
var score = BenchmarkSuite.GeometricMean(BenchmarkSuite.scores);
|
|
var formatted = BenchmarkSuite.FormatScore(100 * score);
|
|
runner.NotifyScore(formatted);
|
|
}
|
|
}
|
|
RunStep();
|
|
}
|
|
|
|
|
|
// Counts the total number of registered benchmarks. Useful for
|
|
// showing progress as a percentage.
|
|
BenchmarkSuite.CountBenchmarks = function() {
|
|
var result = 0;
|
|
var suites = BenchmarkSuite.suites;
|
|
for (var i = 0; i < suites.length; i++) {
|
|
result += suites[i].benchmarks.length;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// Computes the geometric mean of a set of numbers.
|
|
BenchmarkSuite.GeometricMean = function(numbers) {
|
|
var log = 0;
|
|
for (var i = 0; i < numbers.length; i++) {
|
|
log += Math.log(numbers[i]);
|
|
}
|
|
return Math.pow(Math.E, log / numbers.length);
|
|
}
|
|
|
|
|
|
// Converts a score value to a string with at least three significant
|
|
// digits.
|
|
BenchmarkSuite.FormatScore = function(value) {
|
|
if (value > 100) {
|
|
return value.toFixed(0);
|
|
} else {
|
|
return value.toPrecision(3);
|
|
}
|
|
}
|
|
|
|
// Notifies the runner that we're done running a single benchmark in
|
|
// the benchmark suite. This can be useful to report progress.
|
|
BenchmarkSuite.prototype.NotifyStep = function(result) {
|
|
this.results.push(result);
|
|
if (this.runner.NotifyStep) this.runner.NotifyStep(result.benchmark.name);
|
|
}
|
|
|
|
|
|
// Notifies the runner that we're done with running a suite and that
|
|
// we have a result which can be reported to the user if needed.
|
|
BenchmarkSuite.prototype.NotifyResult = function() {
|
|
var mean = BenchmarkSuite.GeometricMean(this.results);
|
|
var score = this.reference / mean;
|
|
BenchmarkSuite.scores.push(score);
|
|
if (this.runner.NotifyResult) {
|
|
var formatted = BenchmarkSuite.FormatScore(100 * score);
|
|
this.runner.NotifyResult(this.name, formatted);
|
|
}
|
|
}
|
|
|
|
|
|
// Notifies the runner that running a benchmark resulted in an error.
|
|
BenchmarkSuite.prototype.NotifyError = function(error) {
|
|
if (this.runner.NotifyError) {
|
|
this.runner.NotifyError(this.name, error);
|
|
}
|
|
if (this.runner.NotifyStep) {
|
|
this.runner.NotifyStep(this.name);
|
|
}
|
|
}
|
|
|
|
|
|
// Runs a single benchmark for at least a second and computes the
|
|
// average time it takes to run a single iteration.
|
|
BenchmarkSuite.prototype.RunSingleBenchmark = function(benchmark, data) {
|
|
// run the garbage collector, to give more reproducible conditions to each test
|
|
gc()
|
|
|
|
function Measure(data) {
|
|
var elapsed = 0;
|
|
var start = new Date();
|
|
for (var n = 0; elapsed < 1000; n++) {
|
|
benchmark.run();
|
|
elapsed = new Date() - start;
|
|
}
|
|
if (data != null) {
|
|
data.runs += n;
|
|
data.elapsed += elapsed;
|
|
}
|
|
}
|
|
|
|
if (data == null) {
|
|
// Measure the benchmark once for warm up and throw the result
|
|
// away. Return a fresh data object.
|
|
Measure(null);
|
|
return { runs: 0, elapsed: 0 };
|
|
} else {
|
|
Measure(data);
|
|
// If we've run too few iterations, we continue for another second.
|
|
if (data.runs < 32) return data;
|
|
var usec = (data.elapsed * 1000) / data.runs;
|
|
this.NotifyStep(new BenchmarkResult(benchmark, usec));
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
// This function starts running a suite, but stops between each
|
|
// individual benchmark in the suite and returns a continuation
|
|
// function which can be invoked to run the next benchmark. Once the
|
|
// last benchmark has been executed, null is returned.
|
|
BenchmarkSuite.prototype.RunStep = function(runner) {
|
|
this.results = [];
|
|
this.runner = runner;
|
|
var length = this.benchmarks.length;
|
|
var index = 0;
|
|
var suite = this;
|
|
var data;
|
|
|
|
// Run the setup, the actual benchmark, and the tear down in three
|
|
// separate steps to allow the framework to yield between any of the
|
|
// steps.
|
|
|
|
function RunNextSetup() {
|
|
if (index < length) {
|
|
try {
|
|
suite.benchmarks[index].Setup();
|
|
} catch (e) {
|
|
suite.NotifyError(e);
|
|
return null;
|
|
}
|
|
return RunNextBenchmark;
|
|
}
|
|
suite.NotifyResult();
|
|
return null;
|
|
}
|
|
|
|
function RunNextBenchmark() {
|
|
try {
|
|
data = suite.RunSingleBenchmark(suite.benchmarks[index], data);
|
|
} catch (e) {
|
|
suite.NotifyError(e);
|
|
return null;
|
|
}
|
|
// If data is null, we're done with this benchmark.
|
|
return (data == null) ? RunNextTearDown : RunNextBenchmark();
|
|
}
|
|
|
|
function RunNextTearDown() {
|
|
try {
|
|
suite.benchmarks[index++].TearDown();
|
|
} catch (e) {
|
|
suite.NotifyError(e);
|
|
return null;
|
|
}
|
|
return RunNextSetup;
|
|
}
|
|
|
|
// Start out running the setup.
|
|
return RunNextSetup();
|
|
}
|
|
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
// This is a JavaScript implementation of the Richards
|
|
// benchmark from:
|
|
//
|
|
// http://www.cl.cam.ac.uk/~mr10/Bench.html
|
|
//
|
|
// The benchmark was originally implemented in BCPL by
|
|
// Martin Richards.
|
|
|
|
|
|
var Richards = new BenchmarkSuite('Richards', 35302, [
|
|
new Benchmark("Richards", runRichards)
|
|
]);
|
|
|
|
|
|
/**
|
|
* The Richards benchmark simulates the task dispatcher of an
|
|
* operating system.
|
|
**/
|
|
function runRichards() {
|
|
var scheduler = new Scheduler();
|
|
scheduler.addIdleTask(ID_IDLE, 0, null, COUNT);
|
|
|
|
var queue = new Packet(null, ID_WORKER, KIND_WORK);
|
|
queue = new Packet(queue, ID_WORKER, KIND_WORK);
|
|
scheduler.addWorkerTask(ID_WORKER, 1000, queue);
|
|
|
|
queue = new Packet(null, ID_DEVICE_A, KIND_DEVICE);
|
|
queue = new Packet(queue, ID_DEVICE_A, KIND_DEVICE);
|
|
queue = new Packet(queue, ID_DEVICE_A, KIND_DEVICE);
|
|
scheduler.addHandlerTask(ID_HANDLER_A, 2000, queue);
|
|
|
|
queue = new Packet(null, ID_DEVICE_B, KIND_DEVICE);
|
|
queue = new Packet(queue, ID_DEVICE_B, KIND_DEVICE);
|
|
queue = new Packet(queue, ID_DEVICE_B, KIND_DEVICE);
|
|
scheduler.addHandlerTask(ID_HANDLER_B, 3000, queue);
|
|
|
|
scheduler.addDeviceTask(ID_DEVICE_A, 4000, null);
|
|
|
|
scheduler.addDeviceTask(ID_DEVICE_B, 5000, null);
|
|
|
|
scheduler.schedule();
|
|
|
|
if (scheduler.queueCount != EXPECTED_QUEUE_COUNT ||
|
|
scheduler.holdCount != EXPECTED_HOLD_COUNT) {
|
|
var msg =
|
|
"Error during execution: queueCount = " + scheduler.queueCount +
|
|
", holdCount = " + scheduler.holdCount + ".";
|
|
throw new Error(msg);
|
|
}
|
|
}
|
|
|
|
var COUNT = 1000;
|
|
|
|
/**
|
|
* These two constants specify how many times a packet is queued and
|
|
* how many times a task is put on hold in a correct run of richards.
|
|
* They don't have any meaning a such but are characteristic of a
|
|
* correct run so if the actual queue or hold count is different from
|
|
* the expected there must be a bug in the implementation.
|
|
**/
|
|
var EXPECTED_QUEUE_COUNT = 2322;
|
|
var EXPECTED_HOLD_COUNT = 928;
|
|
|
|
|
|
/**
|
|
* A scheduler can be used to schedule a set of tasks based on their relative
|
|
* priorities. Scheduling is done by maintaining a list of task control blocks
|
|
* which holds tasks and the data queue they are processing.
|
|
* @constructor
|
|
*/
|
|
function Scheduler() {
|
|
this.queueCount = 0;
|
|
this.holdCount = 0;
|
|
this.blocks = new Array(NUMBER_OF_IDS);
|
|
this.list = null;
|
|
this.currentTcb = null;
|
|
this.currentId = null;
|
|
}
|
|
|
|
var ID_IDLE = 0;
|
|
var ID_WORKER = 1;
|
|
var ID_HANDLER_A = 2;
|
|
var ID_HANDLER_B = 3;
|
|
var ID_DEVICE_A = 4;
|
|
var ID_DEVICE_B = 5;
|
|
var NUMBER_OF_IDS = 6;
|
|
|
|
var KIND_DEVICE = 0;
|
|
var KIND_WORK = 1;
|
|
|
|
/**
|
|
* Add an idle task to this scheduler.
|
|
* @param {int} id the identity of the task
|
|
* @param {int} priority the task's priority
|
|
* @param {Packet} queue the queue of work to be processed by the task
|
|
* @param {int} count the number of times to schedule the task
|
|
*/
|
|
Scheduler.prototype.addIdleTask = function (id, priority, queue, count) {
|
|
this.addRunningTask(id, priority, queue, new IdleTask(this, 1, count));
|
|
};
|
|
|
|
/**
|
|
* Add a work task to this scheduler.
|
|
* @param {int} id the identity of the task
|
|
* @param {int} priority the task's priority
|
|
* @param {Packet} queue the queue of work to be processed by the task
|
|
*/
|
|
Scheduler.prototype.addWorkerTask = function (id, priority, queue) {
|
|
this.addTask(id, priority, queue, new WorkerTask(this, ID_HANDLER_A, 0));
|
|
};
|
|
|
|
/**
|
|
* Add a handler task to this scheduler.
|
|
* @param {int} id the identity of the task
|
|
* @param {int} priority the task's priority
|
|
* @param {Packet} queue the queue of work to be processed by the task
|
|
*/
|
|
Scheduler.prototype.addHandlerTask = function (id, priority, queue) {
|
|
this.addTask(id, priority, queue, new HandlerTask(this));
|
|
};
|
|
|
|
/**
|
|
* Add a handler task to this scheduler.
|
|
* @param {int} id the identity of the task
|
|
* @param {int} priority the task's priority
|
|
* @param {Packet} queue the queue of work to be processed by the task
|
|
*/
|
|
Scheduler.prototype.addDeviceTask = function (id, priority, queue) {
|
|
this.addTask(id, priority, queue, new DeviceTask(this))
|
|
};
|
|
|
|
/**
|
|
* Add the specified task and mark it as running.
|
|
* @param {int} id the identity of the task
|
|
* @param {int} priority the task's priority
|
|
* @param {Packet} queue the queue of work to be processed by the task
|
|
* @param {Task} task the task to add
|
|
*/
|
|
Scheduler.prototype.addRunningTask = function (id, priority, queue, task) {
|
|
this.addTask(id, priority, queue, task);
|
|
this.currentTcb.setRunning();
|
|
};
|
|
|
|
/**
|
|
* Add the specified task to this scheduler.
|
|
* @param {int} id the identity of the task
|
|
* @param {int} priority the task's priority
|
|
* @param {Packet} queue the queue of work to be processed by the task
|
|
* @param {Task} task the task to add
|
|
*/
|
|
Scheduler.prototype.addTask = function (id, priority, queue, task) {
|
|
this.currentTcb = new TaskControlBlock(this.list, id, priority, queue, task);
|
|
this.list = this.currentTcb;
|
|
this.blocks[id] = this.currentTcb;
|
|
};
|
|
|
|
/**
|
|
* Execute the tasks managed by this scheduler.
|
|
*/
|
|
Scheduler.prototype.schedule = function () {
|
|
this.currentTcb = this.list;
|
|
while (this.currentTcb != null) {
|
|
if (this.currentTcb.isHeldOrSuspended()) {
|
|
this.currentTcb = this.currentTcb.link;
|
|
} else {
|
|
this.currentId = this.currentTcb.id;
|
|
this.currentTcb = this.currentTcb.run();
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Release a task that is currently blocked and return the next block to run.
|
|
* @param {int} id the id of the task to suspend
|
|
*/
|
|
Scheduler.prototype.release = function (id) {
|
|
var tcb = this.blocks[id];
|
|
if (tcb == null) return tcb;
|
|
tcb.markAsNotHeld();
|
|
if (tcb.priority > this.currentTcb.priority) {
|
|
return tcb;
|
|
} else {
|
|
return this.currentTcb;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Block the currently executing task and return the next task control block
|
|
* to run. The blocked task will not be made runnable until it is explicitly
|
|
* released, even if new work is added to it.
|
|
*/
|
|
Scheduler.prototype.holdCurrent = function () {
|
|
this.holdCount++;
|
|
this.currentTcb.markAsHeld();
|
|
return this.currentTcb.link;
|
|
};
|
|
|
|
/**
|
|
* Suspend the currently executing task and return the next task control block
|
|
* to run. If new work is added to the suspended task it will be made runnable.
|
|
*/
|
|
Scheduler.prototype.suspendCurrent = function () {
|
|
this.currentTcb.markAsSuspended();
|
|
return this.currentTcb;
|
|
};
|
|
|
|
/**
|
|
* Add the specified packet to the end of the worklist used by the task
|
|
* associated with the packet and make the task runnable if it is currently
|
|
* suspended.
|
|
* @param {Packet} packet the packet to add
|
|
*/
|
|
Scheduler.prototype.queue = function (packet) {
|
|
var t = this.blocks[packet.id];
|
|
if (t == null) return t;
|
|
this.queueCount++;
|
|
packet.link = null;
|
|
packet.id = this.currentId;
|
|
return t.checkPriorityAdd(this.currentTcb, packet);
|
|
};
|
|
|
|
/**
|
|
* A task control block manages a task and the queue of work packages associated
|
|
* with it.
|
|
* @param {TaskControlBlock} link the preceding block in the linked block list
|
|
* @param {int} id the id of this block
|
|
* @param {int} priority the priority of this block
|
|
* @param {Packet} queue the queue of packages to be processed by the task
|
|
* @param {Task} task the task
|
|
* @constructor
|
|
*/
|
|
function TaskControlBlock(link, id, priority, queue, task) {
|
|
this.link = link;
|
|
this.id = id;
|
|
this.priority = priority;
|
|
this.queue = queue;
|
|
this.task = task;
|
|
if (queue == null) {
|
|
this.state = STATE_SUSPENDED;
|
|
} else {
|
|
this.state = STATE_SUSPENDED_RUNNABLE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The task is running and is currently scheduled.
|
|
*/
|
|
var STATE_RUNNING = 0;
|
|
|
|
/**
|
|
* The task has packets left to process.
|
|
*/
|
|
var STATE_RUNNABLE = 1;
|
|
|
|
/**
|
|
* The task is not currently running. The task is not blocked as such and may
|
|
* be started by the scheduler.
|
|
*/
|
|
var STATE_SUSPENDED = 2;
|
|
|
|
/**
|
|
* The task is blocked and cannot be run until it is explicitly released.
|
|
*/
|
|
var STATE_HELD = 4;
|
|
|
|
var STATE_SUSPENDED_RUNNABLE = STATE_SUSPENDED | STATE_RUNNABLE;
|
|
var STATE_NOT_HELD = ~STATE_HELD;
|
|
|
|
TaskControlBlock.prototype.setRunning = function () {
|
|
this.state = STATE_RUNNING;
|
|
};
|
|
|
|
TaskControlBlock.prototype.markAsNotHeld = function () {
|
|
this.state = this.state & STATE_NOT_HELD;
|
|
};
|
|
|
|
TaskControlBlock.prototype.markAsHeld = function () {
|
|
this.state = this.state | STATE_HELD;
|
|
};
|
|
|
|
TaskControlBlock.prototype.isHeldOrSuspended = function () {
|
|
return (this.state & STATE_HELD) != 0 || (this.state == STATE_SUSPENDED);
|
|
};
|
|
|
|
TaskControlBlock.prototype.markAsSuspended = function () {
|
|
this.state = this.state | STATE_SUSPENDED;
|
|
};
|
|
|
|
TaskControlBlock.prototype.markAsRunnable = function () {
|
|
this.state = this.state | STATE_RUNNABLE;
|
|
};
|
|
|
|
/**
|
|
* Runs this task, if it is ready to be run, and returns the next task to run.
|
|
*/
|
|
TaskControlBlock.prototype.run = function () {
|
|
var packet;
|
|
if (this.state == STATE_SUSPENDED_RUNNABLE) {
|
|
packet = this.queue;
|
|
this.queue = packet.link;
|
|
if (this.queue == null) {
|
|
this.state = STATE_RUNNING;
|
|
} else {
|
|
this.state = STATE_RUNNABLE;
|
|
}
|
|
} else {
|
|
packet = null;
|
|
}
|
|
return this.task.run(packet);
|
|
};
|
|
|
|
/**
|
|
* Adds a packet to the worklist of this block's task, marks this as runnable if
|
|
* necessary, and returns the next runnable object to run (the one
|
|
* with the highest priority).
|
|
*/
|
|
TaskControlBlock.prototype.checkPriorityAdd = function (task, packet) {
|
|
if (this.queue == null) {
|
|
this.queue = packet;
|
|
this.markAsRunnable();
|
|
if (this.priority > task.priority) return this;
|
|
} else {
|
|
this.queue = packet.addTo(this.queue);
|
|
}
|
|
return task;
|
|
};
|
|
|
|
TaskControlBlock.prototype.toString = function () {
|
|
return "tcb { " + this.task + "@" + this.state + " }";
|
|
};
|
|
|
|
/**
|
|
* An idle task doesn't do any work itself but cycles control between the two
|
|
* device tasks.
|
|
* @param {Scheduler} scheduler the scheduler that manages this task
|
|
* @param {int} v1 a seed value that controls how the device tasks are scheduled
|
|
* @param {int} count the number of times this task should be scheduled
|
|
* @constructor
|
|
*/
|
|
function IdleTask(scheduler, v1, count) {
|
|
this.scheduler = scheduler;
|
|
this.v1 = v1;
|
|
this.count = count;
|
|
}
|
|
|
|
IdleTask.prototype.run = function (packet) {
|
|
this.count--;
|
|
if (this.count == 0) return this.scheduler.holdCurrent();
|
|
if ((this.v1 & 1) == 0) {
|
|
this.v1 = this.v1 >> 1;
|
|
return this.scheduler.release(ID_DEVICE_A);
|
|
} else {
|
|
this.v1 = (this.v1 >> 1) ^ 0xD008;
|
|
return this.scheduler.release(ID_DEVICE_B);
|
|
}
|
|
};
|
|
|
|
IdleTask.prototype.toString = function () {
|
|
return "IdleTask"
|
|
};
|
|
|
|
/**
|
|
* A task that suspends itself after each time it has been run to simulate
|
|
* waiting for data from an external device.
|
|
* @param {Scheduler} scheduler the scheduler that manages this task
|
|
* @constructor
|
|
*/
|
|
function DeviceTask(scheduler) {
|
|
this.scheduler = scheduler;
|
|
this.v1 = null;
|
|
}
|
|
|
|
DeviceTask.prototype.run = function (packet) {
|
|
if (packet == null) {
|
|
if (this.v1 == null) return this.scheduler.suspendCurrent();
|
|
var v = this.v1;
|
|
this.v1 = null;
|
|
return this.scheduler.queue(v);
|
|
} else {
|
|
this.v1 = packet;
|
|
return this.scheduler.holdCurrent();
|
|
}
|
|
};
|
|
|
|
DeviceTask.prototype.toString = function () {
|
|
return "DeviceTask";
|
|
};
|
|
|
|
/**
|
|
* A task that manipulates work packets.
|
|
* @param {Scheduler} scheduler the scheduler that manages this task
|
|
* @param {int} v1 a seed used to specify how work packets are manipulated
|
|
* @param {int} v2 another seed used to specify how work packets are manipulated
|
|
* @constructor
|
|
*/
|
|
function WorkerTask(scheduler, v1, v2) {
|
|
this.scheduler = scheduler;
|
|
this.v1 = v1;
|
|
this.v2 = v2;
|
|
}
|
|
|
|
WorkerTask.prototype.run = function (packet) {
|
|
if (packet == null) {
|
|
return this.scheduler.suspendCurrent();
|
|
} else {
|
|
if (this.v1 == ID_HANDLER_A) {
|
|
this.v1 = ID_HANDLER_B;
|
|
} else {
|
|
this.v1 = ID_HANDLER_A;
|
|
}
|
|
packet.id = this.v1;
|
|
packet.a1 = 0;
|
|
for (var i = 0; i < DATA_SIZE; i++) {
|
|
this.v2++;
|
|
if (this.v2 > 26) this.v2 = 1;
|
|
packet.a2[i] = this.v2;
|
|
}
|
|
return this.scheduler.queue(packet);
|
|
}
|
|
};
|
|
|
|
WorkerTask.prototype.toString = function () {
|
|
return "WorkerTask";
|
|
};
|
|
|
|
/**
|
|
* A task that manipulates work packets and then suspends itself.
|
|
* @param {Scheduler} scheduler the scheduler that manages this task
|
|
* @constructor
|
|
*/
|
|
function HandlerTask(scheduler) {
|
|
this.scheduler = scheduler;
|
|
this.v1 = null;
|
|
this.v2 = null;
|
|
}
|
|
|
|
HandlerTask.prototype.run = function (packet) {
|
|
if (packet != null) {
|
|
if (packet.kind == KIND_WORK) {
|
|
this.v1 = packet.addTo(this.v1);
|
|
} else {
|
|
this.v2 = packet.addTo(this.v2);
|
|
}
|
|
}
|
|
if (this.v1 != null) {
|
|
var count = this.v1.a1;
|
|
var v;
|
|
if (count < DATA_SIZE) {
|
|
if (this.v2 != null) {
|
|
v = this.v2;
|
|
this.v2 = this.v2.link;
|
|
v.a1 = this.v1.a2[count];
|
|
this.v1.a1 = count + 1;
|
|
return this.scheduler.queue(v);
|
|
}
|
|
} else {
|
|
v = this.v1;
|
|
this.v1 = this.v1.link;
|
|
return this.scheduler.queue(v);
|
|
}
|
|
}
|
|
return this.scheduler.suspendCurrent();
|
|
};
|
|
|
|
HandlerTask.prototype.toString = function () {
|
|
return "HandlerTask";
|
|
};
|
|
|
|
/* --- *
|
|
* P a c k e t
|
|
* --- */
|
|
|
|
var DATA_SIZE = 4;
|
|
|
|
/**
|
|
* A simple package of data that is manipulated by the tasks. The exact layout
|
|
* of the payload data carried by a packet is not importaint, and neither is the
|
|
* nature of the work performed on packets by the tasks.
|
|
*
|
|
* Besides carrying data, packets form linked lists and are hence used both as
|
|
* data and worklists.
|
|
* @param {Packet} link the tail of the linked list of packets
|
|
* @param {int} id an ID for this packet
|
|
* @param {int} kind the type of this packet
|
|
* @constructor
|
|
*/
|
|
function Packet(link, id, kind) {
|
|
this.link = link;
|
|
this.id = id;
|
|
this.kind = kind;
|
|
this.a1 = 0;
|
|
this.a2 = new Array(DATA_SIZE);
|
|
}
|
|
|
|
/**
|
|
* Add this packet to the end of a worklist, and return the worklist.
|
|
* @param {Packet} queue the worklist to add this packet to
|
|
*/
|
|
Packet.prototype.addTo = function (queue) {
|
|
this.link = null;
|
|
if (queue == null) return this;
|
|
var peek, next = queue;
|
|
while ((peek = next.link) != null)
|
|
next = peek;
|
|
next.link = this;
|
|
return queue;
|
|
};
|
|
|
|
Packet.prototype.toString = function () {
|
|
return "Packet";
|
|
};
|
|
// Copyright 2008 the V8 project authors. All rights reserved.
|
|
// Copyright 1996 John Maloney and Mario Wolczko.
|
|
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
|
|
// This implementation of the DeltaBlue benchmark is derived
|
|
// from the Smalltalk implementation by John Maloney and Mario
|
|
// Wolczko. Some parts have been translated directly, whereas
|
|
// others have been modified more aggresively to make it feel
|
|
// more like a JavaScript program.
|
|
|
|
|
|
var DeltaBlue = new BenchmarkSuite('DeltaBlue', 66118, [
|
|
new Benchmark('DeltaBlue', deltaBlue)
|
|
]);
|
|
|
|
|
|
/**
|
|
* A JavaScript implementation of the DeltaBlue constraint-solving
|
|
* algorithm, as described in:
|
|
*
|
|
* "The DeltaBlue Algorithm: An Incremental Constraint Hierarchy Solver"
|
|
* Bjorn N. Freeman-Benson and John Maloney
|
|
* January 1990 Communications of the ACM,
|
|
* also available as University of Washington TR 89-08-06.
|
|
*
|
|
* Beware: this benchmark is written in a grotesque style where
|
|
* the constraint model is built by side-effects from constructors.
|
|
* I've kept it this way to avoid deviating too much from the original
|
|
* implementation.
|
|
*/
|
|
|
|
|
|
/* --- O b j e c t M o d e l --- */
|
|
|
|
Object.prototype.inheritsFrom = function (shuper) {
|
|
function Inheriter() { }
|
|
Inheriter.prototype = shuper.prototype;
|
|
this.prototype = new Inheriter();
|
|
this.superConstructor = shuper;
|
|
}
|
|
|
|
function OrderedCollection() {
|
|
this.elms = new Array();
|
|
}
|
|
|
|
OrderedCollection.prototype.add = function (elm) {
|
|
this.elms.push(elm);
|
|
}
|
|
|
|
OrderedCollection.prototype.at = function (index) {
|
|
return this.elms[index];
|
|
}
|
|
|
|
OrderedCollection.prototype.size = function () {
|
|
return this.elms.length;
|
|
}
|
|
|
|
OrderedCollection.prototype.removeFirst = function () {
|
|
return this.elms.pop();
|
|
}
|
|
|
|
OrderedCollection.prototype.remove = function (elm) {
|
|
var index = 0, skipped = 0;
|
|
for (var i = 0; i < this.elms.length; i++) {
|
|
var value = this.elms[i];
|
|
if (value != elm) {
|
|
this.elms[index] = value;
|
|
index++;
|
|
} else {
|
|
skipped++;
|
|
}
|
|
}
|
|
for (var i = 0; i < skipped; i++)
|
|
this.elms.pop();
|
|
}
|
|
|
|
/* --- *
|
|
* S t r e n g t h
|
|
* --- */
|
|
|
|
/**
|
|
* Strengths are used to measure the relative importance of constraints.
|
|
* New strengths may be inserted in the strength hierarchy without
|
|
* disrupting current constraints. Strengths cannot be created outside
|
|
* this class, so pointer comparison can be used for value comparison.
|
|
*/
|
|
function Strength(strengthValue, name) {
|
|
this.strengthValue = strengthValue;
|
|
this.name = name;
|
|
}
|
|
|
|
Strength.stronger = function (s1, s2) {
|
|
return s1.strengthValue < s2.strengthValue;
|
|
}
|
|
|
|
Strength.weaker = function (s1, s2) {
|
|
return s1.strengthValue > s2.strengthValue;
|
|
}
|
|
|
|
Strength.weakestOf = function (s1, s2) {
|
|
return this.weaker(s1, s2) ? s1 : s2;
|
|
}
|
|
|
|
Strength.strongest = function (s1, s2) {
|
|
return this.stronger(s1, s2) ? s1 : s2;
|
|
}
|
|
|
|
Strength.prototype.nextWeaker = function () {
|
|
switch (this.strengthValue) {
|
|
case 0: return Strength.WEAKEST;
|
|
case 1: return Strength.WEAK_DEFAULT;
|
|
case 2: return Strength.NORMAL;
|
|
case 3: return Strength.STRONG_DEFAULT;
|
|
case 4: return Strength.PREFERRED;
|
|
case 5: return Strength.REQUIRED;
|
|
}
|
|
}
|
|
|
|
// Strength constants.
|
|
Strength.REQUIRED = new Strength(0, "required");
|
|
Strength.STONG_PREFERRED = new Strength(1, "strongPreferred");
|
|
Strength.PREFERRED = new Strength(2, "preferred");
|
|
Strength.STRONG_DEFAULT = new Strength(3, "strongDefault");
|
|
Strength.NORMAL = new Strength(4, "normal");
|
|
Strength.WEAK_DEFAULT = new Strength(5, "weakDefault");
|
|
Strength.WEAKEST = new Strength(6, "weakest");
|
|
|
|
/* --- *
|
|
* C o n s t r a i n t
|
|
* --- */
|
|
|
|
/**
|
|
* An abstract class representing a system-maintainable relationship
|
|
* (or "constraint") between a set of variables. A constraint supplies
|
|
* a strength instance variable; concrete subclasses provide a means
|
|
* of storing the constrained variables and other information required
|
|
* to represent a constraint.
|
|
*/
|
|
function Constraint(strength) {
|
|
this.strength = strength;
|
|
}
|
|
|
|
/**
|
|
* Activate this constraint and attempt to satisfy it.
|
|
*/
|
|
Constraint.prototype.addConstraint = function () {
|
|
this.addToGraph();
|
|
planner.incrementalAdd(this);
|
|
}
|
|
|
|
/**
|
|
* Attempt to find a way to enforce this constraint. If successful,
|
|
* record the solution, perhaps modifying the current dataflow
|
|
* graph. Answer the constraint that this constraint overrides, if
|
|
* there is one, or nil, if there isn't.
|
|
* Assume: I am not already satisfied.
|
|
*/
|
|
Constraint.prototype.satisfy = function (mark) {
|
|
this.chooseMethod(mark);
|
|
if (!this.isSatisfied()) {
|
|
if (this.strength == Strength.REQUIRED)
|
|
alert("Could not satisfy a required constraint!");
|
|
return null;
|
|
}
|
|
this.markInputs(mark);
|
|
var out = this.output();
|
|
var overridden = out.determinedBy;
|
|
if (overridden != null) overridden.markUnsatisfied();
|
|
out.determinedBy = this;
|
|
if (!planner.addPropagate(this, mark))
|
|
alert("Cycle encountered");
|
|
out.mark = mark;
|
|
return overridden;
|
|
}
|
|
|
|
Constraint.prototype.destroyConstraint = function () {
|
|
if (this.isSatisfied()) planner.incrementalRemove(this);
|
|
else this.removeFromGraph();
|
|
}
|
|
|
|
/**
|
|
* Normal constraints are not input constraints. An input constraint
|
|
* is one that depends on external state, such as the mouse, the
|
|
* keybord, a clock, or some arbitraty piece of imperative code.
|
|
*/
|
|
Constraint.prototype.isInput = function () {
|
|
return false;
|
|
}
|
|
|
|
/* --- *
|
|
* U n a r y C o n s t r a i n t
|
|
* --- */
|
|
|
|
/**
|
|
* Abstract superclass for constraints having a single possible output
|
|
* variable.
|
|
*/
|
|
function UnaryConstraint(v, strength) {
|
|
UnaryConstraint.superConstructor.call(this, strength);
|
|
this.myOutput = v;
|
|
this.satisfied = false;
|
|
this.addConstraint();
|
|
}
|
|
|
|
UnaryConstraint.inheritsFrom(Constraint);
|
|
|
|
/**
|
|
* Adds this constraint to the constraint graph
|
|
*/
|
|
UnaryConstraint.prototype.addToGraph = function () {
|
|
this.myOutput.addConstraint(this);
|
|
this.satisfied = false;
|
|
}
|
|
|
|
/**
|
|
* Decides if this constraint can be satisfied and records that
|
|
* decision.
|
|
*/
|
|
UnaryConstraint.prototype.chooseMethod = function (mark) {
|
|
this.satisfied = (this.myOutput.mark != mark)
|
|
&& Strength.stronger(this.strength, this.myOutput.walkStrength);
|
|
}
|
|
|
|
/**
|
|
* Returns true if this constraint is satisfied in the current solution.
|
|
*/
|
|
UnaryConstraint.prototype.isSatisfied = function () {
|
|
return this.satisfied;
|
|
}
|
|
|
|
UnaryConstraint.prototype.markInputs = function (mark) {
|
|
// has no inputs
|
|
}
|
|
|
|
/**
|
|
* Returns the current output variable.
|
|
*/
|
|
UnaryConstraint.prototype.output = function () {
|
|
return this.myOutput;
|
|
}
|
|
|
|
/**
|
|
* Calculate the walkabout strength, the stay flag, and, if it is
|
|
* 'stay', the value for the current output of this constraint. Assume
|
|
* this constraint is satisfied.
|
|
*/
|
|
UnaryConstraint.prototype.recalculate = function () {
|
|
this.myOutput.walkStrength = this.strength;
|
|
this.myOutput.stay = !this.isInput();
|
|
if (this.myOutput.stay) this.execute(); // Stay optimization
|
|
}
|
|
|
|
/**
|
|
* Records that this constraint is unsatisfied
|
|
*/
|
|
UnaryConstraint.prototype.markUnsatisfied = function () {
|
|
this.satisfied = false;
|
|
}
|
|
|
|
UnaryConstraint.prototype.inputsKnown = function () {
|
|
return true;
|
|
}
|
|
|
|
UnaryConstraint.prototype.removeFromGraph = function () {
|
|
if (this.myOutput != null) this.myOutput.removeConstraint(this);
|
|
this.satisfied = false;
|
|
}
|
|
|
|
/* --- *
|
|
* S t a y C o n s t r a i n t
|
|
* --- */
|
|
|
|
/**
|
|
* Variables that should, with some level of preference, stay the same.
|
|
* Planners may exploit the fact that instances, if satisfied, will not
|
|
* change their output during plan execution. This is called "stay
|
|
* optimization".
|
|
*/
|
|
function StayConstraint(v, str) {
|
|
StayConstraint.superConstructor.call(this, v, str);
|
|
}
|
|
|
|
StayConstraint.inheritsFrom(UnaryConstraint);
|
|
|
|
StayConstraint.prototype.execute = function () {
|
|
// Stay constraints do nothing
|
|
}
|
|
|
|
/* --- *
|
|
* E d i t C o n s t r a i n t
|
|
* --- */
|
|
|
|
/**
|
|
* A unary input constraint used to mark a variable that the client
|
|
* wishes to change.
|
|
*/
|
|
function EditConstraint(v, str) {
|
|
EditConstraint.superConstructor.call(this, v, str);
|
|
}
|
|
|
|
EditConstraint.inheritsFrom(UnaryConstraint);
|
|
|
|
/**
|
|
* Edits indicate that a variable is to be changed by imperative code.
|
|
*/
|
|
EditConstraint.prototype.isInput = function () {
|
|
return true;
|
|
}
|
|
|
|
EditConstraint.prototype.execute = function () {
|
|
// Edit constraints do nothing
|
|
}
|
|
|
|
/* --- *
|
|
* B i n a r y C o n s t r a i n t
|
|
* --- */
|
|
|
|
var Direction = new Object();
|
|
Direction.NONE = 0;
|
|
Direction.FORWARD = 1;
|
|
Direction.BACKWARD = -1;
|
|
|
|
/**
|
|
* Abstract superclass for constraints having two possible output
|
|
* variables.
|
|
*/
|
|
function BinaryConstraint(var1, var2, strength) {
|
|
BinaryConstraint.superConstructor.call(this, strength);
|
|
this.v1 = var1;
|
|
this.v2 = var2;
|
|
this.direction = Direction.NONE;
|
|
this.addConstraint();
|
|
}
|
|
|
|
BinaryConstraint.inheritsFrom(Constraint);
|
|
|
|
/**
|
|
* Decides if this constraint can be satisfied and which way it
|
|
* should flow based on the relative strength of the variables related,
|
|
* and record that decision.
|
|
*/
|
|
BinaryConstraint.prototype.chooseMethod = function (mark) {
|
|
if (this.v1.mark == mark) {
|
|
this.direction = (this.v2.mark != mark && Strength.stronger(this.strength, this.v2.walkStrength))
|
|
? Direction.FORWARD
|
|
: Direction.NONE;
|
|
}
|
|
if (this.v2.mark == mark) {
|
|
this.direction = (this.v1.mark != mark && Strength.stronger(this.strength, this.v1.walkStrength))
|
|
? Direction.BACKWARD
|
|
: Direction.NONE;
|
|
}
|
|
if (Strength.weaker(this.v1.walkStrength, this.v2.walkStrength)) {
|
|
this.direction = Strength.stronger(this.strength, this.v1.walkStrength)
|
|
? Direction.BACKWARD
|
|
: Direction.NONE;
|
|
} else {
|
|
this.direction = Strength.stronger(this.strength, this.v2.walkStrength)
|
|
? Direction.FORWARD
|
|
: Direction.BACKWARD
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add this constraint to the constraint graph
|
|
*/
|
|
BinaryConstraint.prototype.addToGraph = function () {
|
|
this.v1.addConstraint(this);
|
|
this.v2.addConstraint(this);
|
|
this.direction = Direction.NONE;
|
|
}
|
|
|
|
/**
|
|
* Answer true if this constraint is satisfied in the current solution.
|
|
*/
|
|
BinaryConstraint.prototype.isSatisfied = function () {
|
|
return this.direction != Direction.NONE;
|
|
}
|
|
|
|
/**
|
|
* Mark the input variable with the given mark.
|
|
*/
|
|
BinaryConstraint.prototype.markInputs = function (mark) {
|
|
this.input().mark = mark;
|
|
}
|
|
|
|
/**
|
|
* Returns the current input variable
|
|
*/
|
|
BinaryConstraint.prototype.input = function () {
|
|
return (this.direction == Direction.FORWARD) ? this.v1 : this.v2;
|
|
}
|
|
|
|
/**
|
|
* Returns the current output variable
|
|
*/
|
|
BinaryConstraint.prototype.output = function () {
|
|
return (this.direction == Direction.FORWARD) ? this.v2 : this.v1;
|
|
}
|
|
|
|
/**
|
|
* Calculate the walkabout strength, the stay flag, and, if it is
|
|
* 'stay', the value for the current output of this
|
|
* constraint. Assume this constraint is satisfied.
|
|
*/
|
|
BinaryConstraint.prototype.recalculate = function () {
|
|
var ihn = this.input(), out = this.output();
|
|
out.walkStrength = Strength.weakestOf(this.strength, ihn.walkStrength);
|
|
out.stay = ihn.stay;
|
|
if (out.stay) this.execute();
|
|
}
|
|
|
|
/**
|
|
* Record the fact that this constraint is unsatisfied.
|
|
*/
|
|
BinaryConstraint.prototype.markUnsatisfied = function () {
|
|
this.direction = Direction.NONE;
|
|
}
|
|
|
|
BinaryConstraint.prototype.inputsKnown = function (mark) {
|
|
var i = this.input();
|
|
return i.mark == mark || i.stay || i.determinedBy == null;
|
|
}
|
|
|
|
BinaryConstraint.prototype.removeFromGraph = function () {
|
|
if (this.v1 != null) this.v1.removeConstraint(this);
|
|
if (this.v2 != null) this.v2.removeConstraint(this);
|
|
this.direction = Direction.NONE;
|
|
}
|
|
|
|
/* --- *
|
|
* S c a l e C o n s t r a i n t
|
|
* --- */
|
|
|
|
/**
|
|
* Relates two variables by the linear scaling relationship: "v2 =
|
|
* (v1 * scale) + offset". Either v1 or v2 may be changed to maintain
|
|
* this relationship but the scale factor and offset are considered
|
|
* read-only.
|
|
*/
|
|
function ScaleConstraint(src, scale, offset, dest, strength) {
|
|
this.direction = Direction.NONE;
|
|
this.scale = scale;
|
|
this.offset = offset;
|
|
ScaleConstraint.superConstructor.call(this, src, dest, strength);
|
|
}
|
|
|
|
ScaleConstraint.inheritsFrom(BinaryConstraint);
|
|
|
|
/**
|
|
* Adds this constraint to the constraint graph.
|
|
*/
|
|
ScaleConstraint.prototype.addToGraph = function () {
|
|
ScaleConstraint.superConstructor.prototype.addToGraph.call(this);
|
|
this.scale.addConstraint(this);
|
|
this.offset.addConstraint(this);
|
|
}
|
|
|
|
ScaleConstraint.prototype.removeFromGraph = function () {
|
|
ScaleConstraint.superConstructor.prototype.removeFromGraph.call(this);
|
|
if (this.scale != null) this.scale.removeConstraint(this);
|
|
if (this.offset != null) this.offset.removeConstraint(this);
|
|
}
|
|
|
|
ScaleConstraint.prototype.markInputs = function (mark) {
|
|
ScaleConstraint.superConstructor.prototype.markInputs.call(this, mark);
|
|
this.scale.mark = this.offset.mark = mark;
|
|
}
|
|
|
|
/**
|
|
* Enforce this constraint. Assume that it is satisfied.
|
|
*/
|
|
ScaleConstraint.prototype.execute = function () {
|
|
if (this.direction == Direction.FORWARD) {
|
|
this.v2.value = this.v1.value * this.scale.value + this.offset.value;
|
|
} else {
|
|
this.v1.value = (this.v2.value - this.offset.value) / this.scale.value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate the walkabout strength, the stay flag, and, if it is
|
|
* 'stay', the value for the current output of this constraint. Assume
|
|
* this constraint is satisfied.
|
|
*/
|
|
ScaleConstraint.prototype.recalculate = function () {
|
|
var ihn = this.input(), out = this.output();
|
|
out.walkStrength = Strength.weakestOf(this.strength, ihn.walkStrength);
|
|
out.stay = ihn.stay && this.scale.stay && this.offset.stay;
|
|
if (out.stay) this.execute();
|
|
}
|
|
|
|
/* --- *
|
|
* E q u a l i t y C o n s t r a i n t
|
|
* --- */
|
|
|
|
/**
|
|
* Constrains two variables to have the same value.
|
|
*/
|
|
function EqualityConstraint(var1, var2, strength) {
|
|
EqualityConstraint.superConstructor.call(this, var1, var2, strength);
|
|
}
|
|
|
|
EqualityConstraint.inheritsFrom(BinaryConstraint);
|
|
|
|
/**
|
|
* Enforce this constraint. Assume that it is satisfied.
|
|
*/
|
|
EqualityConstraint.prototype.execute = function () {
|
|
this.output().value = this.input().value;
|
|
}
|
|
|
|
/* --- *
|
|
* V a r i a b l e
|
|
* --- */
|
|
|
|
/**
|
|
* A constrained variable. In addition to its value, it maintain the
|
|
* structure of the constraint graph, the current dataflow graph, and
|
|
* various parameters of interest to the DeltaBlue incremental
|
|
* constraint solver.
|
|
**/
|
|
function Variable(name, initialValue) {
|
|
this.value = initialValue || 0;
|
|
this.constraints = new OrderedCollection();
|
|
this.determinedBy = null;
|
|
this.mark = 0;
|
|
this.walkStrength = Strength.WEAKEST;
|
|
this.stay = true;
|
|
this.name = name;
|
|
}
|
|
|
|
/**
|
|
* Add the given constraint to the set of all constraints that refer
|
|
* this variable.
|
|
*/
|
|
Variable.prototype.addConstraint = function (c) {
|
|
this.constraints.add(c);
|
|
}
|
|
|
|
/**
|
|
* Removes all traces of c from this variable.
|
|
*/
|
|
Variable.prototype.removeConstraint = function (c) {
|
|
this.constraints.remove(c);
|
|
if (this.determinedBy == c) this.determinedBy = null;
|
|
}
|
|
|
|
/* --- *
|
|
* P l a n n e r
|
|
* --- */
|
|
|
|
/**
|
|
* The DeltaBlue planner
|
|
*/
|
|
function Planner() {
|
|
this.currentMark = 0;
|
|
}
|
|
|
|
/**
|
|
* Attempt to satisfy the given constraint and, if successful,
|
|
* incrementally update the dataflow graph. Details: If satifying
|
|
* the constraint is successful, it may override a weaker constraint
|
|
* on its output. The algorithm attempts to resatisfy that
|
|
* constraint using some other method. This process is repeated
|
|
* until either a) it reaches a variable that was not previously
|
|
* determined by any constraint or b) it reaches a constraint that
|
|
* is too weak to be satisfied using any of its methods. The
|
|
* variables of constraints that have been processed are marked with
|
|
* a unique mark value so that we know where we've been. This allows
|
|
* the algorithm to avoid getting into an infinite loop even if the
|
|
* constraint graph has an inadvertent cycle.
|
|
*/
|
|
Planner.prototype.incrementalAdd = function (c) {
|
|
var mark = this.newMark();
|
|
var overridden = c.satisfy(mark);
|
|
while (overridden != null)
|
|
overridden = overridden.satisfy(mark);
|
|
}
|
|
|
|
/**
|
|
* Entry point for retracting a constraint. Remove the given
|
|
* constraint and incrementally update the dataflow graph.
|
|
* Details: Retracting the given constraint may allow some currently
|
|
* unsatisfiable downstream constraint to be satisfied. We therefore collect
|
|
* a list of unsatisfied downstream constraints and attempt to
|
|
* satisfy each one in turn. This list is traversed by constraint
|
|
* strength, strongest first, as a heuristic for avoiding
|
|
* unnecessarily adding and then overriding weak constraints.
|
|
* Assume: c is satisfied.
|
|
*/
|
|
Planner.prototype.incrementalRemove = function (c) {
|
|
var out = c.output();
|
|
c.markUnsatisfied();
|
|
c.removeFromGraph();
|
|
var unsatisfied = this.removePropagateFrom(out);
|
|
var strength = Strength.REQUIRED;
|
|
do {
|
|
for (var i = 0; i < unsatisfied.size(); i++) {
|
|
var u = unsatisfied.at(i);
|
|
if (u.strength == strength)
|
|
this.incrementalAdd(u);
|
|
}
|
|
strength = strength.nextWeaker();
|
|
} while (strength != Strength.WEAKEST);
|
|
}
|
|
|
|
/**
|
|
* Select a previously unused mark value.
|
|
*/
|
|
Planner.prototype.newMark = function () {
|
|
return ++this.currentMark;
|
|
}
|
|
|
|
/**
|
|
* Extract a plan for resatisfaction starting from the given source
|
|
* constraints, usually a set of input constraints. This method
|
|
* assumes that stay optimization is desired; the plan will contain
|
|
* only constraints whose output variables are not stay. Constraints
|
|
* that do no computation, such as stay and edit constraints, are
|
|
* not included in the plan.
|
|
* Details: The outputs of a constraint are marked when it is added
|
|
* to the plan under construction. A constraint may be appended to
|
|
* the plan when all its input variables are known. A variable is
|
|
* known if either a) the variable is marked (indicating that has
|
|
* been computed by a constraint appearing earlier in the plan), b)
|
|
* the variable is 'stay' (i.e. it is a constant at plan execution
|
|
* time), or c) the variable is not determined by any
|
|
* constraint. The last provision is for past states of history
|
|
* variables, which are not stay but which are also not computed by
|
|
* any constraint.
|
|
* Assume: sources are all satisfied.
|
|
*/
|
|
Planner.prototype.makePlan = function (sources) {
|
|
var mark = this.newMark();
|
|
var plan = new Plan();
|
|
var todo = sources;
|
|
while (todo.size() > 0) {
|
|
var c = todo.removeFirst();
|
|
if (c.output().mark != mark && c.inputsKnown(mark)) {
|
|
plan.addConstraint(c);
|
|
c.output().mark = mark;
|
|
this.addConstraintsConsumingTo(c.output(), todo);
|
|
}
|
|
}
|
|
return plan;
|
|
}
|
|
|
|
/**
|
|
* Extract a plan for resatisfying starting from the output of the
|
|
* given constraints, usually a set of input constraints.
|
|
*/
|
|
Planner.prototype.extractPlanFromConstraints = function (constraints) {
|
|
var sources = new OrderedCollection();
|
|
for (var i = 0; i < constraints.size(); i++) {
|
|
var c = constraints.at(i);
|
|
if (c.isInput() && c.isSatisfied())
|
|
// not in plan already and eligible for inclusion
|
|
sources.add(c);
|
|
}
|
|
return this.makePlan(sources);
|
|
}
|
|
|
|
/**
|
|
* Recompute the walkabout strengths and stay flags of all variables
|
|
* downstream of the given constraint and recompute the actual
|
|
* values of all variables whose stay flag is true. If a cycle is
|
|
* detected, remove the given constraint and answer
|
|
* false. Otherwise, answer true.
|
|
* Details: Cycles are detected when a marked variable is
|
|
* encountered downstream of the given constraint. The sender is
|
|
* assumed to have marked the inputs of the given constraint with
|
|
* the given mark. Thus, encountering a marked node downstream of
|
|
* the output constraint means that there is a path from the
|
|
* constraint's output to one of its inputs.
|
|
*/
|
|
Planner.prototype.addPropagate = function (c, mark) {
|
|
var todo = new OrderedCollection();
|
|
todo.add(c);
|
|
while (todo.size() > 0) {
|
|
var d = todo.removeFirst();
|
|
if (d.output().mark == mark) {
|
|
this.incrementalRemove(c);
|
|
return false;
|
|
}
|
|
d.recalculate();
|
|
this.addConstraintsConsumingTo(d.output(), todo);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Update the walkabout strengths and stay flags of all variables
|
|
* downstream of the given constraint. Answer a collection of
|
|
* unsatisfied constraints sorted in order of decreasing strength.
|
|
*/
|
|
Planner.prototype.removePropagateFrom = function (out) {
|
|
out.determinedBy = null;
|
|
out.walkStrength = Strength.WEAKEST;
|
|
out.stay = true;
|
|
var unsatisfied = new OrderedCollection();
|
|
var todo = new OrderedCollection();
|
|
todo.add(out);
|
|
while (todo.size() > 0) {
|
|
var v = todo.removeFirst();
|
|
for (var i = 0; i < v.constraints.size(); i++) {
|
|
var c = v.constraints.at(i);
|
|
if (!c.isSatisfied())
|
|
unsatisfied.add(c);
|
|
}
|
|
var determining = v.determinedBy;
|
|
for (var i = 0; i < v.constraints.size(); i++) {
|
|
var next = v.constraints.at(i);
|
|
if (next != determining && next.isSatisfied()) {
|
|
next.recalculate();
|
|
todo.add(next.output());
|
|
}
|
|
}
|
|
}
|
|
return unsatisfied;
|
|
}
|
|
|
|
Planner.prototype.addConstraintsConsumingTo = function (v, coll) {
|
|
var determining = v.determinedBy;
|
|
var cc = v.constraints;
|
|
for (var i = 0; i < cc.size(); i++) {
|
|
var c = cc.at(i);
|
|
if (c != determining && c.isSatisfied())
|
|
coll.add(c);
|
|
}
|
|
}
|
|
|
|
/* --- *
|
|
* P l a n
|
|
* --- */
|
|
|
|
/**
|
|
* A Plan is an ordered list of constraints to be executed in sequence
|
|
* to resatisfy all currently satisfiable constraints in the face of
|
|
* one or more changing inputs.
|
|
*/
|
|
function Plan() {
|
|
this.v = new OrderedCollection();
|
|
}
|
|
|
|
Plan.prototype.addConstraint = function (c) {
|
|
this.v.add(c);
|
|
}
|
|
|
|
Plan.prototype.size = function () {
|
|
return this.v.size();
|
|
}
|
|
|
|
Plan.prototype.constraintAt = function (index) {
|
|
return this.v.at(index);
|
|
}
|
|
|
|
Plan.prototype.execute = function () {
|
|
for (var i = 0; i < this.size(); i++) {
|
|
var c = this.constraintAt(i);
|
|
c.execute();
|
|
}
|
|
}
|
|
|
|
/* --- *
|
|
* M a i n
|
|
* --- */
|
|
|
|
/**
|
|
* This is the standard DeltaBlue benchmark. A long chain of equality
|
|
* constraints is constructed with a stay constraint on one end. An
|
|
* edit constraint is then added to the opposite end and the time is
|
|
* measured for adding and removing this constraint, and extracting
|
|
* and executing a constraint satisfaction plan. There are two cases.
|
|
* In case 1, the added constraint is stronger than the stay
|
|
* constraint and values must propagate down the entire length of the
|
|
* chain. In case 2, the added constraint is weaker than the stay
|
|
* constraint so it cannot be accomodated. The cost in this case is,
|
|
* of course, very low. Typical situations lie somewhere between these
|
|
* two extremes.
|
|
*/
|
|
function chainTest(n) {
|
|
planner = new Planner();
|
|
var prev = null, first = null, last = null;
|
|
|
|
// Build chain of n equality constraints
|
|
for (var i = 0; i <= n; i++) {
|
|
var name = "v" + i;
|
|
var v = new Variable(name);
|
|
if (prev != null)
|
|
new EqualityConstraint(prev, v, Strength.REQUIRED);
|
|
if (i == 0) first = v;
|
|
if (i == n) last = v;
|
|
prev = v;
|
|
}
|
|
|
|
new StayConstraint(last, Strength.STRONG_DEFAULT);
|
|
var edit = new EditConstraint(first, Strength.PREFERRED);
|
|
var edits = new OrderedCollection();
|
|
edits.add(edit);
|
|
var plan = planner.extractPlanFromConstraints(edits);
|
|
for (var i = 0; i < 100; i++) {
|
|
first.value = i;
|
|
plan.execute();
|
|
if (last.value != i)
|
|
alert("Chain test failed.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This test constructs a two sets of variables related to each
|
|
* other by a simple linear transformation (scale and offset). The
|
|
* time is measured to change a variable on either side of the
|
|
* mapping and to change the scale and offset factors.
|
|
*/
|
|
function projectionTest(n) {
|
|
planner = new Planner();
|
|
var scale = new Variable("scale", 10);
|
|
var offset = new Variable("offset", 1000);
|
|
var src = null, dst = null;
|
|
|
|
var dests = new OrderedCollection();
|
|
for (var i = 0; i < n; i++) {
|
|
src = new Variable("src" + i, i);
|
|
dst = new Variable("dst" + i, i);
|
|
dests.add(dst);
|
|
new StayConstraint(src, Strength.NORMAL);
|
|
new ScaleConstraint(src, scale, offset, dst, Strength.REQUIRED);
|
|
}
|
|
|
|
change(src, 17);
|
|
if (dst.value != 1170) alert("Projection 1 failed");
|
|
change(dst, 1050);
|
|
if (src.value != 5) alert("Projection 2 failed");
|
|
change(scale, 5);
|
|
for (var i = 0; i < n - 1; i++) {
|
|
if (dests.at(i).value != i * 5 + 1000)
|
|
alert("Projection 3 failed");
|
|
}
|
|
change(offset, 2000);
|
|
for (var i = 0; i < n - 1; i++) {
|
|
if (dests.at(i).value != i * 5 + 2000)
|
|
alert("Projection 4 failed");
|
|
}
|
|
}
|
|
|
|
function change(v, newValue) {
|
|
var edit = new EditConstraint(v, Strength.PREFERRED);
|
|
var edits = new OrderedCollection();
|
|
edits.add(edit);
|
|
var plan = planner.extractPlanFromConstraints(edits);
|
|
for (var i = 0; i < 10; i++) {
|
|
v.value = newValue;
|
|
plan.execute();
|
|
}
|
|
edit.destroyConstraint();
|
|
}
|
|
|
|
// Global variable holding the current planner.
|
|
var planner = null;
|
|
|
|
function deltaBlue() {
|
|
chainTest(100);
|
|
projectionTest(100);
|
|
}
|
|
/*
|
|
* Copyright (c) 2003-2005 Tom Wu
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
|
|
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
|
|
* INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
|
|
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
|
|
* THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
|
|
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* In addition, the following condition applies:
|
|
*
|
|
* All redistributions must retain an intact copy of this copyright notice
|
|
* and disclaimer.
|
|
*/
|
|
|
|
|
|
// The code has been adapted for use as a benchmark by Google.
|
|
var Crypto = new BenchmarkSuite('Crypto', 266181, [
|
|
new Benchmark("Encrypt", encrypt),
|
|
new Benchmark("Decrypt", decrypt)
|
|
]);
|
|
|
|
|
|
// Basic JavaScript BN library - subset useful for RSA encryption.
|
|
|
|
// Bits per digit
|
|
var dbits;
|
|
var BI_DB;
|
|
var BI_DM;
|
|
var BI_DV;
|
|
|
|
var BI_FP;
|
|
var BI_FV;
|
|
var BI_F1;
|
|
var BI_F2;
|
|
|
|
// JavaScript engine analysis
|
|
var canary = 0xdeadbeefcafe;
|
|
var j_lm = ((canary&0xffffff)==0xefcafe);
|
|
|
|
// (public) Constructor
|
|
function BigInteger(a,b,c) {
|
|
this.array = new Array();
|
|
if(a != null)
|
|
if("number" == typeof a) this.fromNumber(a,b,c);
|
|
else if(b == null && "string" != typeof a) this.fromString(a,256);
|
|
else this.fromString(a,b);
|
|
}
|
|
|
|
// return new, unset BigInteger
|
|
function nbi() { return new BigInteger(null); }
|
|
|
|
// am: Compute w_j += (x*this_i), propagate carries,
|
|
// c is initial carry, returns final carry.
|
|
// c < 3*dvalue, x < 2*dvalue, this_i < dvalue
|
|
// We need to select the fastest one that works in this environment.
|
|
|
|
// am1: use a single mult and divide to get the high bits,
|
|
// max digit bits should be 26 because
|
|
// max internal value = 2*dvalue^2-2*dvalue (< 2^53)
|
|
function am1(i,x,w,j,c,n) {
|
|
var this_array = this.array;
|
|
var w_array = w.array;
|
|
while(--n >= 0) {
|
|
var v = x*this_array[i++]+w_array[j]+c;
|
|
c = Math.floor(v/0x4000000);
|
|
w_array[j++] = v&0x3ffffff;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// am2 avoids a big mult-and-extract completely.
|
|
// Max digit bits should be <= 30 because we do bitwise ops
|
|
// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
|
|
function am2(i,x,w,j,c,n) {
|
|
var this_array = this.array;
|
|
var w_array = w.array;
|
|
var xl = x&0x7fff, xh = x>>15;
|
|
while(--n >= 0) {
|
|
var l = this_array[i]&0x7fff;
|
|
var h = this_array[i++]>>15;
|
|
var m = xh*l+h*xl;
|
|
l = xl*l+((m&0x7fff)<<15)+w_array[j]+(c&0x3fffffff);
|
|
c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);
|
|
w_array[j++] = l&0x3fffffff;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// Alternately, set max digit bits to 28 since some
|
|
// browsers slow down when dealing with 32-bit numbers.
|
|
function am3(i,x,w,j,c,n) {
|
|
var this_array = this.array;
|
|
var w_array = w.array;
|
|
|
|
var xl = x&0x3fff, xh = x>>14;
|
|
while(--n >= 0) {
|
|
var l = this_array[i]&0x3fff;
|
|
var h = this_array[i++]>>14;
|
|
var m = xh*l+h*xl;
|
|
l = xl*l+((m&0x3fff)<<14)+w_array[j]+c;
|
|
c = (l>>28)+(m>>14)+xh*h;
|
|
w_array[j++] = l&0xfffffff;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// This is tailored to VMs with 2-bit tagging. It makes sure
|
|
// that all the computations stay within the 29 bits available.
|
|
function am4(i,x,w,j,c,n) {
|
|
var this_array = this.array;
|
|
var w_array = w.array;
|
|
|
|
var xl = x&0x1fff, xh = x>>13;
|
|
while(--n >= 0) {
|
|
var l = this_array[i]&0x1fff;
|
|
var h = this_array[i++]>>13;
|
|
var m = xh*l+h*xl;
|
|
l = xl*l+((m&0x1fff)<<13)+w_array[j]+c;
|
|
c = (l>>26)+(m>>13)+xh*h;
|
|
w_array[j++] = l&0x3ffffff;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// am3/28 is best for SM, Rhino, but am4/26 is best for v8.
|
|
// Kestrel (Opera 9.5) gets its best result with am4/26.
|
|
// IE7 does 9% better with am3/28 than with am4/26.
|
|
// Firefox (SM) gets 10% faster with am3/28 than with am4/26.
|
|
|
|
setupEngine = function(fn, bits) {
|
|
BigInteger.prototype.am = fn;
|
|
dbits = bits;
|
|
|
|
BI_DB = dbits;
|
|
BI_DM = ((1<<dbits)-1);
|
|
BI_DV = (1<<dbits);
|
|
|
|
BI_FP = 52;
|
|
BI_FV = Math.pow(2,BI_FP);
|
|
BI_F1 = BI_FP-dbits;
|
|
BI_F2 = 2*dbits-BI_FP;
|
|
}
|
|
|
|
|
|
// Digit conversions
|
|
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
var BI_RC = new Array();
|
|
var rr,vv;
|
|
rr = "0".charCodeAt(0);
|
|
for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;
|
|
rr = "a".charCodeAt(0);
|
|
for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
|
|
rr = "A".charCodeAt(0);
|
|
for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;
|
|
|
|
function int2char(n) { return BI_RM.charAt(n); }
|
|
function intAt(s,i) {
|
|
var c = BI_RC[s.charCodeAt(i)];
|
|
return (c==null)?-1:c;
|
|
}
|
|
|
|
// (protected) copy this to r
|
|
function bnpCopyTo(r) {
|
|
var this_array = this.array;
|
|
var r_array = r.array;
|
|
|
|
for(var i = this.t-1; i >= 0; --i) r_array[i] = this_array[i];
|
|
r.t = this.t;
|
|
r.s = this.s;
|
|
}
|
|
|
|
// (protected) set from integer value x, -DV <= x < DV
|
|
function bnpFromInt(x) {
|
|
var this_array = this.array;
|
|
this.t = 1;
|
|
this.s = (x<0)?-1:0;
|
|
if(x > 0) this_array[0] = x;
|
|
else if(x < -1) this_array[0] = x+DV;
|
|
else this.t = 0;
|
|
}
|
|
|
|
// return bigint initialized to value
|
|
function nbv(i) { var r = nbi(); r.fromInt(i); return r; }
|
|
|
|
// (protected) set from string and radix
|
|
function bnpFromString(s,b) {
|
|
var this_array = this.array;
|
|
var k;
|
|
if(b == 16) k = 4;
|
|
else if(b == 8) k = 3;
|
|
else if(b == 256) k = 8; // byte array
|
|
else if(b == 2) k = 1;
|
|
else if(b == 32) k = 5;
|
|
else if(b == 4) k = 2;
|
|
else { this.fromRadix(s,b); return; }
|
|
this.t = 0;
|
|
this.s = 0;
|
|
var i = s.length, mi = false, sh = 0;
|
|
while(--i >= 0) {
|
|
var x = (k==8)?s[i]&0xff:intAt(s,i);
|
|
if(x < 0) {
|
|
if(s.charAt(i) == "-") mi = true;
|
|
continue;
|
|
}
|
|
mi = false;
|
|
if(sh == 0)
|
|
this_array[this.t++] = x;
|
|
else if(sh+k > BI_DB) {
|
|
this_array[this.t-1] |= (x&((1<<(BI_DB-sh))-1))<<sh;
|
|
this_array[this.t++] = (x>>(BI_DB-sh));
|
|
}
|
|
else
|
|
this_array[this.t-1] |= x<<sh;
|
|
sh += k;
|
|
if(sh >= BI_DB) sh -= BI_DB;
|
|
}
|
|
if(k == 8 && (s[0]&0x80) != 0) {
|
|
this.s = -1;
|
|
if(sh > 0) this_array[this.t-1] |= ((1<<(BI_DB-sh))-1)<<sh;
|
|
}
|
|
this.clamp();
|
|
if(mi) BigInteger.ZERO.subTo(this,this);
|
|
}
|
|
|
|
// (protected) clamp off excess high words
|
|
function bnpClamp() {
|
|
var this_array = this.array;
|
|
var c = this.s&BI_DM;
|
|
while(this.t > 0 && this_array[this.t-1] == c) --this.t;
|
|
}
|
|
|
|
// (public) return string representation in given radix
|
|
function bnToString(b) {
|
|
var this_array = this.array;
|
|
if(this.s < 0) return "-"+this.negate().toString(b);
|
|
var k;
|
|
if(b == 16) k = 4;
|
|
else if(b == 8) k = 3;
|
|
else if(b == 2) k = 1;
|
|
else if(b == 32) k = 5;
|
|
else if(b == 4) k = 2;
|
|
else return this.toRadix(b);
|
|
var km = (1<<k)-1, d, m = false, r = "", i = this.t;
|
|
var p = BI_DB-(i*BI_DB)%k;
|
|
if(i-- > 0) {
|
|
if(p < BI_DB && (d = this_array[i]>>p) > 0) { m = true; r = int2char(d); }
|
|
while(i >= 0) {
|
|
if(p < k) {
|
|
d = (this_array[i]&((1<<p)-1))<<(k-p);
|
|
d |= this_array[--i]>>(p+=BI_DB-k);
|
|
}
|
|
else {
|
|
d = (this_array[i]>>(p-=k))&km;
|
|
if(p <= 0) { p += BI_DB; --i; }
|
|
}
|
|
if(d > 0) m = true;
|
|
if(m) r += int2char(d);
|
|
}
|
|
}
|
|
return m?r:"0";
|
|
}
|
|
|
|
// (public) -this
|
|
function bnNegate() { var r = nbi(); BigInteger.ZERO.subTo(this,r); return r; }
|
|
|
|
// (public) |this|
|
|
function bnAbs() { return (this.s<0)?this.negate():this; }
|
|
|
|
// (public) return + if this > a, - if this < a, 0 if equal
|
|
function bnCompareTo(a) {
|
|
var this_array = this.array;
|
|
var a_array = a.array;
|
|
|
|
var r = this.s-a.s;
|
|
if(r != 0) return r;
|
|
var i = this.t;
|
|
r = i-a.t;
|
|
if(r != 0) return r;
|
|
while(--i >= 0) if((r=this_array[i]-a_array[i]) != 0) return r;
|
|
return 0;
|
|
}
|
|
|
|
// returns bit length of the integer x
|
|
function nbits(x) {
|
|
var r = 1, t;
|
|
if((t=x>>>16) != 0) { x = t; r += 16; }
|
|
if((t=x>>8) != 0) { x = t; r += 8; }
|
|
if((t=x>>4) != 0) { x = t; r += 4; }
|
|
if((t=x>>2) != 0) { x = t; r += 2; }
|
|
if((t=x>>1) != 0) { x = t; r += 1; }
|
|
return r;
|
|
}
|
|
|
|
// (public) return the number of bits in "this"
|
|
function bnBitLength() {
|
|
var this_array = this.array;
|
|
if(this.t <= 0) return 0;
|
|
return BI_DB*(this.t-1)+nbits(this_array[this.t-1]^(this.s&BI_DM));
|
|
}
|
|
|
|
// (protected) r = this << n*DB
|
|
function bnpDLShiftTo(n,r) {
|
|
var this_array = this.array;
|
|
var r_array = r.array;
|
|
var i;
|
|
for(i = this.t-1; i >= 0; --i) r_array[i+n] = this_array[i];
|
|
for(i = n-1; i >= 0; --i) r_array[i] = 0;
|
|
r.t = this.t+n;
|
|
r.s = this.s;
|
|
}
|
|
|
|
// (protected) r = this >> n*DB
|
|
function bnpDRShiftTo(n,r) {
|
|
var this_array = this.array;
|
|
var r_array = r.array;
|
|
for(var i = n; i < this.t; ++i) r_array[i-n] = this_array[i];
|
|
r.t = Math.max(this.t-n,0);
|
|
r.s = this.s;
|
|
}
|
|
|
|
// (protected) r = this << n
|
|
function bnpLShiftTo(n,r) {
|
|
var this_array = this.array;
|
|
var r_array = r.array;
|
|
var bs = n%BI_DB;
|
|
var cbs = BI_DB-bs;
|
|
var bm = (1<<cbs)-1;
|
|
var ds = Math.floor(n/BI_DB), c = (this.s<<bs)&BI_DM, i;
|
|
for(i = this.t-1; i >= 0; --i) {
|
|
r_array[i+ds+1] = (this_array[i]>>cbs)|c;
|
|
c = (this_array[i]&bm)<<bs;
|
|
}
|
|
for(i = ds-1; i >= 0; --i) r_array[i] = 0;
|
|
r_array[ds] = c;
|
|
r.t = this.t+ds+1;
|
|
r.s = this.s;
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = this >> n
|
|
function bnpRShiftTo(n,r) {
|
|
var this_array = this.array;
|
|
var r_array = r.array;
|
|
r.s = this.s;
|
|
var ds = Math.floor(n/BI_DB);
|
|
if(ds >= this.t) { r.t = 0; return; }
|
|
var bs = n%BI_DB;
|
|
var cbs = BI_DB-bs;
|
|
var bm = (1<<bs)-1;
|
|
r_array[0] = this_array[ds]>>bs;
|
|
for(var i = ds+1; i < this.t; ++i) {
|
|
r_array[i-ds-1] |= (this_array[i]&bm)<<cbs;
|
|
r_array[i-ds] = this_array[i]>>bs;
|
|
}
|
|
if(bs > 0) r_array[this.t-ds-1] |= (this.s&bm)<<cbs;
|
|
r.t = this.t-ds;
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = this - a
|
|
function bnpSubTo(a,r) {
|
|
var this_array = this.array;
|
|
var r_array = r.array;
|
|
var a_array = a.array;
|
|
var i = 0, c = 0, m = Math.min(a.t,this.t);
|
|
while(i < m) {
|
|
c += this_array[i]-a_array[i];
|
|
r_array[i++] = c&BI_DM;
|
|
c >>= BI_DB;
|
|
}
|
|
if(a.t < this.t) {
|
|
c -= a.s;
|
|
while(i < this.t) {
|
|
c += this_array[i];
|
|
r_array[i++] = c&BI_DM;
|
|
c >>= BI_DB;
|
|
}
|
|
c += this.s;
|
|
}
|
|
else {
|
|
c += this.s;
|
|
while(i < a.t) {
|
|
c -= a_array[i];
|
|
r_array[i++] = c&BI_DM;
|
|
c >>= BI_DB;
|
|
}
|
|
c -= a.s;
|
|
}
|
|
r.s = (c<0)?-1:0;
|
|
if(c < -1) r_array[i++] = BI_DV+c;
|
|
else if(c > 0) r_array[i++] = c;
|
|
r.t = i;
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = this * a, r != this,a (HAC 14.12)
|
|
// "this" should be the larger one if appropriate.
|
|
function bnpMultiplyTo(a,r) {
|
|
var this_array = this.array;
|
|
var r_array = r.array;
|
|
var x = this.abs(), y = a.abs();
|
|
var y_array = y.array;
|
|
|
|
var i = x.t;
|
|
r.t = i+y.t;
|
|
while(--i >= 0) r_array[i] = 0;
|
|
for(i = 0; i < y.t; ++i) r_array[i+x.t] = x.am(0,y_array[i],r,i,0,x.t);
|
|
r.s = 0;
|
|
r.clamp();
|
|
if(this.s != a.s) BigInteger.ZERO.subTo(r,r);
|
|
}
|
|
|
|
// (protected) r = this^2, r != this (HAC 14.16)
|
|
function bnpSquareTo(r) {
|
|
var x = this.abs();
|
|
var x_array = x.array;
|
|
var r_array = r.array;
|
|
|
|
var i = r.t = 2*x.t;
|
|
while(--i >= 0) r_array[i] = 0;
|
|
for(i = 0; i < x.t-1; ++i) {
|
|
var c = x.am(i,x_array[i],r,2*i,0,1);
|
|
if((r_array[i+x.t]+=x.am(i+1,2*x_array[i],r,2*i+1,c,x.t-i-1)) >= BI_DV) {
|
|
r_array[i+x.t] -= BI_DV;
|
|
r_array[i+x.t+1] = 1;
|
|
}
|
|
}
|
|
if(r.t > 0) r_array[r.t-1] += x.am(i,x_array[i],r,2*i,0,1);
|
|
r.s = 0;
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
|
|
// r != q, this != m. q or r may be null.
|
|
function bnpDivRemTo(m,q,r) {
|
|
var pm = m.abs();
|
|
if(pm.t <= 0) return;
|
|
var pt = this.abs();
|
|
if(pt.t < pm.t) {
|
|
if(q != null) q.fromInt(0);
|
|
if(r != null) this.copyTo(r);
|
|
return;
|
|
}
|
|
if(r == null) r = nbi();
|
|
var y = nbi(), ts = this.s, ms = m.s;
|
|
var pm_array = pm.array;
|
|
var nsh = BI_DB-nbits(pm_array[pm.t-1]); // normalize modulus
|
|
if(nsh > 0) { pm.lShiftTo(nsh,y); pt.lShiftTo(nsh,r); }
|
|
else { pm.copyTo(y); pt.copyTo(r); }
|
|
var ys = y.t;
|
|
|
|
var y_array = y.array;
|
|
var y0 = y_array[ys-1];
|
|
if(y0 == 0) return;
|
|
var yt = y0*(1<<BI_F1)+((ys>1)?y_array[ys-2]>>BI_F2:0);
|
|
var d1 = BI_FV/yt, d2 = (1<<BI_F1)/yt, e = 1<<BI_F2;
|
|
var i = r.t, j = i-ys, t = (q==null)?nbi():q;
|
|
y.dlShiftTo(j,t);
|
|
|
|
var r_array = r.array;
|
|
if(r.compareTo(t) >= 0) {
|
|
r_array[r.t++] = 1;
|
|
r.subTo(t,r);
|
|
}
|
|
BigInteger.ONE.dlShiftTo(ys,t);
|
|
t.subTo(y,y); // "negative" y so we can replace sub with am later
|
|
while(y.t < ys) y_array[y.t++] = 0;
|
|
while(--j >= 0) {
|
|
// Estimate quotient digit
|
|
var qd = (r_array[--i]==y0)?BI_DM:Math.floor(r_array[i]*d1+(r_array[i-1]+e)*d2);
|
|
if((r_array[i]+=y.am(0,qd,r,j,0,ys)) < qd) { // Try it out
|
|
y.dlShiftTo(j,t);
|
|
r.subTo(t,r);
|
|
while(r_array[i] < --qd) r.subTo(t,r);
|
|
}
|
|
}
|
|
if(q != null) {
|
|
r.drShiftTo(ys,q);
|
|
if(ts != ms) BigInteger.ZERO.subTo(q,q);
|
|
}
|
|
r.t = ys;
|
|
r.clamp();
|
|
if(nsh > 0) r.rShiftTo(nsh,r); // Denormalize remainder
|
|
if(ts < 0) BigInteger.ZERO.subTo(r,r);
|
|
}
|
|
|
|
// (public) this mod a
|
|
function bnMod(a) {
|
|
var r = nbi();
|
|
this.abs().divRemTo(a,null,r);
|
|
if(this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r,r);
|
|
return r;
|
|
}
|
|
|
|
// Modular reduction using "classic" algorithm
|
|
function Classic(m) { this.m = m; }
|
|
function cConvert(x) {
|
|
if(x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m);
|
|
else return x;
|
|
}
|
|
function cRevert(x) { return x; }
|
|
function cReduce(x) { x.divRemTo(this.m,null,x); }
|
|
function cMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
|
|
function cSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
|
|
|
|
Classic.prototype.convert = cConvert;
|
|
Classic.prototype.revert = cRevert;
|
|
Classic.prototype.reduce = cReduce;
|
|
Classic.prototype.mulTo = cMulTo;
|
|
Classic.prototype.sqrTo = cSqrTo;
|
|
|
|
// (protected) return "-1/this % 2^DB"; useful for Mont. reduction
|
|
// justification:
|
|
// xy == 1 (mod m)
|
|
// xy = 1+km
|
|
// xy(2-xy) = (1+km)(1-km)
|
|
// x[y(2-xy)] = 1-k^2m^2
|
|
// x[y(2-xy)] == 1 (mod m^2)
|
|
// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
|
|
// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
|
|
// JS multiply "overflows" differently from C/C++, so care is needed here.
|
|
function bnpInvDigit() {
|
|
var this_array = this.array;
|
|
if(this.t < 1) return 0;
|
|
var x = this_array[0];
|
|
if((x&1) == 0) return 0;
|
|
var y = x&3; // y == 1/x mod 2^2
|
|
y = (y*(2-(x&0xf)*y))&0xf; // y == 1/x mod 2^4
|
|
y = (y*(2-(x&0xff)*y))&0xff; // y == 1/x mod 2^8
|
|
y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff; // y == 1/x mod 2^16
|
|
// last step - calculate inverse mod DV directly;
|
|
// assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
|
|
y = (y*(2-x*y%BI_DV))%BI_DV; // y == 1/x mod 2^dbits
|
|
// we really want the negative inverse, and -DV < y < DV
|
|
return (y>0)?BI_DV-y:-y;
|
|
}
|
|
|
|
// Montgomery reduction
|
|
function Montgomery(m) {
|
|
this.m = m;
|
|
this.mp = m.invDigit();
|
|
this.mpl = this.mp&0x7fff;
|
|
this.mph = this.mp>>15;
|
|
this.um = (1<<(BI_DB-15))-1;
|
|
this.mt2 = 2*m.t;
|
|
}
|
|
|
|
// xR mod m
|
|
function montConvert(x) {
|
|
var r = nbi();
|
|
x.abs().dlShiftTo(this.m.t,r);
|
|
r.divRemTo(this.m,null,r);
|
|
if(x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r,r);
|
|
return r;
|
|
}
|
|
|
|
// x/R mod m
|
|
function montRevert(x) {
|
|
var r = nbi();
|
|
x.copyTo(r);
|
|
this.reduce(r);
|
|
return r;
|
|
}
|
|
|
|
// x = x/R mod m (HAC 14.32)
|
|
function montReduce(x) {
|
|
var x_array = x.array;
|
|
while(x.t <= this.mt2) // pad x so am has enough room later
|
|
x_array[x.t++] = 0;
|
|
for(var i = 0; i < this.m.t; ++i) {
|
|
// faster way of calculating u0 = x[i]*mp mod DV
|
|
var j = x_array[i]&0x7fff;
|
|
var u0 = (j*this.mpl+(((j*this.mph+(x_array[i]>>15)*this.mpl)&this.um)<<15))&BI_DM;
|
|
// use am to combine the multiply-shift-add into one call
|
|
j = i+this.m.t;
|
|
x_array[j] += this.m.am(0,u0,x,i,0,this.m.t);
|
|
// propagate carry
|
|
while(x_array[j] >= BI_DV) { x_array[j] -= BI_DV; x_array[++j]++; }
|
|
}
|
|
x.clamp();
|
|
x.drShiftTo(this.m.t,x);
|
|
if(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
|
|
}
|
|
|
|
// r = "x^2/R mod m"; x != r
|
|
function montSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
|
|
|
|
// r = "xy/R mod m"; x,y != r
|
|
function montMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
|
|
|
|
Montgomery.prototype.convert = montConvert;
|
|
Montgomery.prototype.revert = montRevert;
|
|
Montgomery.prototype.reduce = montReduce;
|
|
Montgomery.prototype.mulTo = montMulTo;
|
|
Montgomery.prototype.sqrTo = montSqrTo;
|
|
|
|
// (protected) true iff this is even
|
|
function bnpIsEven() {
|
|
var this_array = this.array;
|
|
return ((this.t>0)?(this_array[0]&1):this.s) == 0;
|
|
}
|
|
|
|
// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
|
|
function bnpExp(e,z) {
|
|
if(e > 0xffffffff || e < 1) return BigInteger.ONE;
|
|
var r = nbi(), r2 = nbi(), g = z.convert(this), i = nbits(e)-1;
|
|
g.copyTo(r);
|
|
while(--i >= 0) {
|
|
z.sqrTo(r,r2);
|
|
if((e&(1<<i)) > 0) z.mulTo(r2,g,r);
|
|
else { var t = r; r = r2; r2 = t; }
|
|
}
|
|
return z.revert(r);
|
|
}
|
|
|
|
// (public) this^e % m, 0 <= e < 2^32
|
|
function bnModPowInt(e,m) {
|
|
var z;
|
|
if(e < 256 || m.isEven()) z = new Classic(m); else z = new Montgomery(m);
|
|
return this.exp(e,z);
|
|
}
|
|
|
|
// protected
|
|
BigInteger.prototype.copyTo = bnpCopyTo;
|
|
BigInteger.prototype.fromInt = bnpFromInt;
|
|
BigInteger.prototype.fromString = bnpFromString;
|
|
BigInteger.prototype.clamp = bnpClamp;
|
|
BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
|
|
BigInteger.prototype.drShiftTo = bnpDRShiftTo;
|
|
BigInteger.prototype.lShiftTo = bnpLShiftTo;
|
|
BigInteger.prototype.rShiftTo = bnpRShiftTo;
|
|
BigInteger.prototype.subTo = bnpSubTo;
|
|
BigInteger.prototype.multiplyTo = bnpMultiplyTo;
|
|
BigInteger.prototype.squareTo = bnpSquareTo;
|
|
BigInteger.prototype.divRemTo = bnpDivRemTo;
|
|
BigInteger.prototype.invDigit = bnpInvDigit;
|
|
BigInteger.prototype.isEven = bnpIsEven;
|
|
BigInteger.prototype.exp = bnpExp;
|
|
|
|
// public
|
|
BigInteger.prototype.toString = bnToString;
|
|
BigInteger.prototype.negate = bnNegate;
|
|
BigInteger.prototype.abs = bnAbs;
|
|
BigInteger.prototype.compareTo = bnCompareTo;
|
|
BigInteger.prototype.bitLength = bnBitLength;
|
|
BigInteger.prototype.mod = bnMod;
|
|
BigInteger.prototype.modPowInt = bnModPowInt;
|
|
|
|
// "constants"
|
|
BigInteger.ZERO = nbv(0);
|
|
BigInteger.ONE = nbv(1);
|
|
// Copyright (c) 2005 Tom Wu
|
|
// All Rights Reserved.
|
|
// See "LICENSE" for details.
|
|
|
|
// Extended JavaScript BN functions, required for RSA private ops.
|
|
|
|
// (public)
|
|
function bnClone() { var r = nbi(); this.copyTo(r); return r; }
|
|
|
|
// (public) return value as integer
|
|
function bnIntValue() {
|
|
var this_array = this.array;
|
|
if(this.s < 0) {
|
|
if(this.t == 1) return this_array[0]-BI_DV;
|
|
else if(this.t == 0) return -1;
|
|
}
|
|
else if(this.t == 1) return this_array[0];
|
|
else if(this.t == 0) return 0;
|
|
// assumes 16 < DB < 32
|
|
return ((this_array[1]&((1<<(32-BI_DB))-1))<<BI_DB)|this_array[0];
|
|
}
|
|
|
|
// (public) return value as byte
|
|
function bnByteValue() {
|
|
var this_array = this.array;
|
|
return (this.t==0)?this.s:(this_array[0]<<24)>>24;
|
|
}
|
|
|
|
// (public) return value as short (assumes DB>=16)
|
|
function bnShortValue() {
|
|
var this_array = this.array;
|
|
return (this.t==0)?this.s:(this_array[0]<<16)>>16;
|
|
}
|
|
|
|
// (protected) return x s.t. r^x < DV
|
|
function bnpChunkSize(r) { return Math.floor(Math.LN2*BI_DB/Math.log(r)); }
|
|
|
|
// (public) 0 if this == 0, 1 if this > 0
|
|
function bnSigNum() {
|
|
var this_array = this.array;
|
|
if(this.s < 0) return -1;
|
|
else if(this.t <= 0 || (this.t == 1 && this_array[0] <= 0)) return 0;
|
|
else return 1;
|
|
}
|
|
|
|
// (protected) convert to radix string
|
|
function bnpToRadix(b) {
|
|
if(b == null) b = 10;
|
|
if(this.signum() == 0 || b < 2 || b > 36) return "0";
|
|
var cs = this.chunkSize(b);
|
|
var a = Math.pow(b,cs);
|
|
var d = nbv(a), y = nbi(), z = nbi(), r = "";
|
|
this.divRemTo(d,y,z);
|
|
while(y.signum() > 0) {
|
|
r = (a+z.intValue()).toString(b).substr(1) + r;
|
|
y.divRemTo(d,y,z);
|
|
}
|
|
return z.intValue().toString(b) + r;
|
|
}
|
|
|
|
// (protected) convert from radix string
|
|
function bnpFromRadix(s,b) {
|
|
this.fromInt(0);
|
|
if(b == null) b = 10;
|
|
var cs = this.chunkSize(b);
|
|
var d = Math.pow(b,cs), mi = false, j = 0, w = 0;
|
|
for(var i = 0; i < s.length; ++i) {
|
|
var x = intAt(s,i);
|
|
if(x < 0) {
|
|
if(s.charAt(i) == "-" && this.signum() == 0) mi = true;
|
|
continue;
|
|
}
|
|
w = b*w+x;
|
|
if(++j >= cs) {
|
|
this.dMultiply(d);
|
|
this.dAddOffset(w,0);
|
|
j = 0;
|
|
w = 0;
|
|
}
|
|
}
|
|
if(j > 0) {
|
|
this.dMultiply(Math.pow(b,j));
|
|
this.dAddOffset(w,0);
|
|
}
|
|
if(mi) BigInteger.ZERO.subTo(this,this);
|
|
}
|
|
|
|
// (protected) alternate constructor
|
|
function bnpFromNumber(a,b,c) {
|
|
if("number" == typeof b) {
|
|
// new BigInteger(int,int,RNG)
|
|
if(a < 2) this.fromInt(1);
|
|
else {
|
|
this.fromNumber(a,c);
|
|
if(!this.testBit(a-1)) // force MSB set
|
|
this.bitwiseTo(BigInteger.ONE.shiftLeft(a-1),op_or,this);
|
|
if(this.isEven()) this.dAddOffset(1,0); // force odd
|
|
while(!this.isProbablePrime(b)) {
|
|
this.dAddOffset(2,0);
|
|
if(this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a-1),this);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// new BigInteger(int,RNG)
|
|
var x = new Array(), t = a&7;
|
|
x.length = (a>>3)+1;
|
|
b.nextBytes(x);
|
|
if(t > 0) x[0] &= ((1<<t)-1); else x[0] = 0;
|
|
this.fromString(x,256);
|
|
}
|
|
}
|
|
|
|
// (public) convert to bigendian byte array
|
|
function bnToByteArray() {
|
|
var this_array = this.array;
|
|
var i = this.t, r = new Array();
|
|
r[0] = this.s;
|
|
var p = BI_DB-(i*BI_DB)%8, d, k = 0;
|
|
if(i-- > 0) {
|
|
if(p < BI_DB && (d = this_array[i]>>p) != (this.s&BI_DM)>>p)
|
|
r[k++] = d|(this.s<<(BI_DB-p));
|
|
while(i >= 0) {
|
|
if(p < 8) {
|
|
d = (this_array[i]&((1<<p)-1))<<(8-p);
|
|
d |= this_array[--i]>>(p+=BI_DB-8);
|
|
}
|
|
else {
|
|
d = (this_array[i]>>(p-=8))&0xff;
|
|
if(p <= 0) { p += BI_DB; --i; }
|
|
}
|
|
if((d&0x80) != 0) d |= -256;
|
|
if(k == 0 && (this.s&0x80) != (d&0x80)) ++k;
|
|
if(k > 0 || d != this.s) r[k++] = d;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
function bnEquals(a) { return(this.compareTo(a)==0); }
|
|
function bnMin(a) { return(this.compareTo(a)<0)?this:a; }
|
|
function bnMax(a) { return(this.compareTo(a)>0)?this:a; }
|
|
|
|
// (protected) r = this op a (bitwise)
|
|
function bnpBitwiseTo(a,op,r) {
|
|
var this_array = this.array;
|
|
var a_array = a.array;
|
|
var r_array = r.array;
|
|
var i, f, m = Math.min(a.t,this.t);
|
|
for(i = 0; i < m; ++i) r_array[i] = op(this_array[i],a_array[i]);
|
|
if(a.t < this.t) {
|
|
f = a.s&BI_DM;
|
|
for(i = m; i < this.t; ++i) r_array[i] = op(this_array[i],f);
|
|
r.t = this.t;
|
|
}
|
|
else {
|
|
f = this.s&BI_DM;
|
|
for(i = m; i < a.t; ++i) r_array[i] = op(f,a_array[i]);
|
|
r.t = a.t;
|
|
}
|
|
r.s = op(this.s,a.s);
|
|
r.clamp();
|
|
}
|
|
|
|
// (public) this & a
|
|
function op_and(x,y) { return x&y; }
|
|
function bnAnd(a) { var r = nbi(); this.bitwiseTo(a,op_and,r); return r; }
|
|
|
|
// (public) this | a
|
|
function op_or(x,y) { return x|y; }
|
|
function bnOr(a) { var r = nbi(); this.bitwiseTo(a,op_or,r); return r; }
|
|
|
|
// (public) this ^ a
|
|
function op_xor(x,y) { return x^y; }
|
|
function bnXor(a) { var r = nbi(); this.bitwiseTo(a,op_xor,r); return r; }
|
|
|
|
// (public) this & ~a
|
|
function op_andnot(x,y) { return x&~y; }
|
|
function bnAndNot(a) { var r = nbi(); this.bitwiseTo(a,op_andnot,r); return r; }
|
|
|
|
// (public) ~this
|
|
function bnNot() {
|
|
var this_array = this.array;
|
|
var r = nbi();
|
|
var r_array = r.array;
|
|
|
|
for(var i = 0; i < this.t; ++i) r_array[i] = BI_DM&~this_array[i];
|
|
r.t = this.t;
|
|
r.s = ~this.s;
|
|
return r;
|
|
}
|
|
|
|
// (public) this << n
|
|
function bnShiftLeft(n) {
|
|
var r = nbi();
|
|
if(n < 0) this.rShiftTo(-n,r); else this.lShiftTo(n,r);
|
|
return r;
|
|
}
|
|
|
|
// (public) this >> n
|
|
function bnShiftRight(n) {
|
|
var r = nbi();
|
|
if(n < 0) this.lShiftTo(-n,r); else this.rShiftTo(n,r);
|
|
return r;
|
|
}
|
|
|
|
// return index of lowest 1-bit in x, x < 2^31
|
|
function lbit(x) {
|
|
if(x == 0) return -1;
|
|
var r = 0;
|
|
if((x&0xffff) == 0) { x >>= 16; r += 16; }
|
|
if((x&0xff) == 0) { x >>= 8; r += 8; }
|
|
if((x&0xf) == 0) { x >>= 4; r += 4; }
|
|
if((x&3) == 0) { x >>= 2; r += 2; }
|
|
if((x&1) == 0) ++r;
|
|
return r;
|
|
}
|
|
|
|
// (public) returns index of lowest 1-bit (or -1 if none)
|
|
function bnGetLowestSetBit() {
|
|
var this_array = this.array;
|
|
for(var i = 0; i < this.t; ++i)
|
|
if(this_array[i] != 0) return i*BI_DB+lbit(this_array[i]);
|
|
if(this.s < 0) return this.t*BI_DB;
|
|
return -1;
|
|
}
|
|
|
|
// return number of 1 bits in x
|
|
function cbit(x) {
|
|
var r = 0;
|
|
while(x != 0) { x &= x-1; ++r; }
|
|
return r;
|
|
}
|
|
|
|
// (public) return number of set bits
|
|
function bnBitCount() {
|
|
var r = 0, x = this.s&BI_DM;
|
|
for(var i = 0; i < this.t; ++i) r += cbit(this_array[i]^x);
|
|
return r;
|
|
}
|
|
|
|
// (public) true iff nth bit is set
|
|
function bnTestBit(n) {
|
|
var this_array = this.array;
|
|
var j = Math.floor(n/BI_DB);
|
|
if(j >= this.t) return(this.s!=0);
|
|
return((this_array[j]&(1<<(n%BI_DB)))!=0);
|
|
}
|
|
|
|
// (protected) this op (1<<n)
|
|
function bnpChangeBit(n,op) {
|
|
var r = BigInteger.ONE.shiftLeft(n);
|
|
this.bitwiseTo(r,op,r);
|
|
return r;
|
|
}
|
|
|
|
// (public) this | (1<<n)
|
|
function bnSetBit(n) { return this.changeBit(n,op_or); }
|
|
|
|
// (public) this & ~(1<<n)
|
|
function bnClearBit(n) { return this.changeBit(n,op_andnot); }
|
|
|
|
// (public) this ^ (1<<n)
|
|
function bnFlipBit(n) { return this.changeBit(n,op_xor); }
|
|
|
|
// (protected) r = this + a
|
|
function bnpAddTo(a,r) {
|
|
var this_array = this.array;
|
|
var a_array = a.array;
|
|
var r_array = r.array;
|
|
var i = 0, c = 0, m = Math.min(a.t,this.t);
|
|
while(i < m) {
|
|
c += this_array[i]+a_array[i];
|
|
r_array[i++] = c&BI_DM;
|
|
c >>= BI_DB;
|
|
}
|
|
if(a.t < this.t) {
|
|
c += a.s;
|
|
while(i < this.t) {
|
|
c += this_array[i];
|
|
r_array[i++] = c&BI_DM;
|
|
c >>= BI_DB;
|
|
}
|
|
c += this.s;
|
|
}
|
|
else {
|
|
c += this.s;
|
|
while(i < a.t) {
|
|
c += a_array[i];
|
|
r_array[i++] = c&BI_DM;
|
|
c >>= BI_DB;
|
|
}
|
|
c += a.s;
|
|
}
|
|
r.s = (c<0)?-1:0;
|
|
if(c > 0) r_array[i++] = c;
|
|
else if(c < -1) r_array[i++] = BI_DV+c;
|
|
r.t = i;
|
|
r.clamp();
|
|
}
|
|
|
|
// (public) this + a
|
|
function bnAdd(a) { var r = nbi(); this.addTo(a,r); return r; }
|
|
|
|
// (public) this - a
|
|
function bnSubtract(a) { var r = nbi(); this.subTo(a,r); return r; }
|
|
|
|
// (public) this * a
|
|
function bnMultiply(a) { var r = nbi(); this.multiplyTo(a,r); return r; }
|
|
|
|
// (public) this / a
|
|
function bnDivide(a) { var r = nbi(); this.divRemTo(a,r,null); return r; }
|
|
|
|
// (public) this % a
|
|
function bnRemainder(a) { var r = nbi(); this.divRemTo(a,null,r); return r; }
|
|
|
|
// (public) [this/a,this%a]
|
|
function bnDivideAndRemainder(a) {
|
|
var q = nbi(), r = nbi();
|
|
this.divRemTo(a,q,r);
|
|
return new Array(q,r);
|
|
}
|
|
|
|
// (protected) this *= n, this >= 0, 1 < n < DV
|
|
function bnpDMultiply(n) {
|
|
var this_array = this.array;
|
|
this_array[this.t] = this.am(0,n-1,this,0,0,this.t);
|
|
++this.t;
|
|
this.clamp();
|
|
}
|
|
|
|
// (protected) this += n << w words, this >= 0
|
|
function bnpDAddOffset(n,w) {
|
|
var this_array = this.array;
|
|
while(this.t <= w) this_array[this.t++] = 0;
|
|
this_array[w] += n;
|
|
while(this_array[w] >= BI_DV) {
|
|
this_array[w] -= BI_DV;
|
|
if(++w >= this.t) this_array[this.t++] = 0;
|
|
++this_array[w];
|
|
}
|
|
}
|
|
|
|
// A "null" reducer
|
|
function NullExp() {}
|
|
function nNop(x) { return x; }
|
|
function nMulTo(x,y,r) { x.multiplyTo(y,r); }
|
|
function nSqrTo(x,r) { x.squareTo(r); }
|
|
|
|
NullExp.prototype.convert = nNop;
|
|
NullExp.prototype.revert = nNop;
|
|
NullExp.prototype.mulTo = nMulTo;
|
|
NullExp.prototype.sqrTo = nSqrTo;
|
|
|
|
// (public) this^e
|
|
function bnPow(e) { return this.exp(e,new NullExp()); }
|
|
|
|
// (protected) r = lower n words of "this * a", a.t <= n
|
|
// "this" should be the larger one if appropriate.
|
|
function bnpMultiplyLowerTo(a,n,r) {
|
|
var r_array = r.array;
|
|
var a_array = a.array;
|
|
var i = Math.min(this.t+a.t,n);
|
|
r.s = 0; // assumes a,this >= 0
|
|
r.t = i;
|
|
while(i > 0) r_array[--i] = 0;
|
|
var j;
|
|
for(j = r.t-this.t; i < j; ++i) r_array[i+this.t] = this.am(0,a_array[i],r,i,0,this.t);
|
|
for(j = Math.min(a.t,n); i < j; ++i) this.am(0,a_array[i],r,i,0,n-i);
|
|
r.clamp();
|
|
}
|
|
|
|
// (protected) r = "this * a" without lower n words, n > 0
|
|
// "this" should be the larger one if appropriate.
|
|
function bnpMultiplyUpperTo(a,n,r) {
|
|
var r_array = r.array;
|
|
var a_array = a.array;
|
|
--n;
|
|
var i = r.t = this.t+a.t-n;
|
|
r.s = 0; // assumes a,this >= 0
|
|
while(--i >= 0) r_array[i] = 0;
|
|
for(i = Math.max(n-this.t,0); i < a.t; ++i)
|
|
r_array[this.t+i-n] = this.am(n-i,a_array[i],r,0,0,this.t+i-n);
|
|
r.clamp();
|
|
r.drShiftTo(1,r);
|
|
}
|
|
|
|
// Barrett modular reduction
|
|
function Barrett(m) {
|
|
// setup Barrett
|
|
this.r2 = nbi();
|
|
this.q3 = nbi();
|
|
BigInteger.ONE.dlShiftTo(2*m.t,this.r2);
|
|
this.mu = this.r2.divide(m);
|
|
this.m = m;
|
|
}
|
|
|
|
function barrettConvert(x) {
|
|
if(x.s < 0 || x.t > 2*this.m.t) return x.mod(this.m);
|
|
else if(x.compareTo(this.m) < 0) return x;
|
|
else { var r = nbi(); x.copyTo(r); this.reduce(r); return r; }
|
|
}
|
|
|
|
function barrettRevert(x) { return x; }
|
|
|
|
// x = x mod m (HAC 14.42)
|
|
function barrettReduce(x) {
|
|
x.drShiftTo(this.m.t-1,this.r2);
|
|
if(x.t > this.m.t+1) { x.t = this.m.t+1; x.clamp(); }
|
|
this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);
|
|
this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);
|
|
while(x.compareTo(this.r2) < 0) x.dAddOffset(1,this.m.t+1);
|
|
x.subTo(this.r2,x);
|
|
while(x.compareTo(this.m) >= 0) x.subTo(this.m,x);
|
|
}
|
|
|
|
// r = x^2 mod m; x != r
|
|
function barrettSqrTo(x,r) { x.squareTo(r); this.reduce(r); }
|
|
|
|
// r = x*y mod m; x,y != r
|
|
function barrettMulTo(x,y,r) { x.multiplyTo(y,r); this.reduce(r); }
|
|
|
|
Barrett.prototype.convert = barrettConvert;
|
|
Barrett.prototype.revert = barrettRevert;
|
|
Barrett.prototype.reduce = barrettReduce;
|
|
Barrett.prototype.mulTo = barrettMulTo;
|
|
Barrett.prototype.sqrTo = barrettSqrTo;
|
|
|
|
// (public) this^e % m (HAC 14.85)
|
|
function bnModPow(e,m) {
|
|
var e_array = e.array;
|
|
var i = e.bitLength(), k, r = nbv(1), z;
|
|
if(i <= 0) return r;
|
|
else if(i < 18) k = 1;
|
|
else if(i < 48) k = 3;
|
|
else if(i < 144) k = 4;
|
|
else if(i < 768) k = 5;
|
|
else k = 6;
|
|
if(i < 8)
|
|
z = new Classic(m);
|
|
else if(m.isEven())
|
|
z = new Barrett(m);
|
|
else
|
|
z = new Montgomery(m);
|
|
|
|
// precomputation
|
|
var g = new Array(), n = 3, k1 = k-1, km = (1<<k)-1;
|
|
g[1] = z.convert(this);
|
|
if(k > 1) {
|
|
var g2 = nbi();
|
|
z.sqrTo(g[1],g2);
|
|
while(n <= km) {
|
|
g[n] = nbi();
|
|
z.mulTo(g2,g[n-2],g[n]);
|
|
n += 2;
|
|
}
|
|
}
|
|
|
|
var j = e.t-1, w, is1 = true, r2 = nbi(), t;
|
|
i = nbits(e_array[j])-1;
|
|
while(j >= 0) {
|
|
if(i >= k1) w = (e_array[j]>>(i-k1))&km;
|
|
else {
|
|
w = (e_array[j]&((1<<(i+1))-1))<<(k1-i);
|
|
if(j > 0) w |= e_array[j-1]>>(BI_DB+i-k1);
|
|
}
|
|
|
|
n = k;
|
|
while((w&1) == 0) { w >>= 1; --n; }
|
|
if((i -= n) < 0) { i += BI_DB; --j; }
|
|
if(is1) { // ret == 1, don't bother squaring or multiplying it
|
|
g[w].copyTo(r);
|
|
is1 = false;
|
|
}
|
|
else {
|
|
while(n > 1) { z.sqrTo(r,r2); z.sqrTo(r2,r); n -= 2; }
|
|
if(n > 0) z.sqrTo(r,r2); else { t = r; r = r2; r2 = t; }
|
|
z.mulTo(r2,g[w],r);
|
|
}
|
|
|
|
while(j >= 0 && (e_array[j]&(1<<i)) == 0) {
|
|
z.sqrTo(r,r2); t = r; r = r2; r2 = t;
|
|
if(--i < 0) { i = BI_DB-1; --j; }
|
|
}
|
|
}
|
|
return z.revert(r);
|
|
}
|
|
|
|
// (public) gcd(this,a) (HAC 14.54)
|
|
function bnGCD(a) {
|
|
var x = (this.s<0)?this.negate():this.clone();
|
|
var y = (a.s<0)?a.negate():a.clone();
|
|
if(x.compareTo(y) < 0) { var t = x; x = y; y = t; }
|
|
var i = x.getLowestSetBit(), g = y.getLowestSetBit();
|
|
if(g < 0) return x;
|
|
if(i < g) g = i;
|
|
if(g > 0) {
|
|
x.rShiftTo(g,x);
|
|
y.rShiftTo(g,y);
|
|
}
|
|
while(x.signum() > 0) {
|
|
if((i = x.getLowestSetBit()) > 0) x.rShiftTo(i,x);
|
|
if((i = y.getLowestSetBit()) > 0) y.rShiftTo(i,y);
|
|
if(x.compareTo(y) >= 0) {
|
|
x.subTo(y,x);
|
|
x.rShiftTo(1,x);
|
|
}
|
|
else {
|
|
y.subTo(x,y);
|
|
y.rShiftTo(1,y);
|
|
}
|
|
}
|
|
if(g > 0) y.lShiftTo(g,y);
|
|
return y;
|
|
}
|
|
|
|
// (protected) this % n, n < 2^26
|
|
function bnpModInt(n) {
|
|
var this_array = this.array;
|
|
if(n <= 0) return 0;
|
|
var d = BI_DV%n, r = (this.s<0)?n-1:0;
|
|
if(this.t > 0)
|
|
if(d == 0) r = this_array[0]%n;
|
|
else for(var i = this.t-1; i >= 0; --i) r = (d*r+this_array[i])%n;
|
|
return r;
|
|
}
|
|
|
|
// (public) 1/this % m (HAC 14.61)
|
|
function bnModInverse(m) {
|
|
var ac = m.isEven();
|
|
if((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO;
|
|
var u = m.clone(), v = this.clone();
|
|
var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
|
|
while(u.signum() != 0) {
|
|
while(u.isEven()) {
|
|
u.rShiftTo(1,u);
|
|
if(ac) {
|
|
if(!a.isEven() || !b.isEven()) { a.addTo(this,a); b.subTo(m,b); }
|
|
a.rShiftTo(1,a);
|
|
}
|
|
else if(!b.isEven()) b.subTo(m,b);
|
|
b.rShiftTo(1,b);
|
|
}
|
|
while(v.isEven()) {
|
|
v.rShiftTo(1,v);
|
|
if(ac) {
|
|
if(!c.isEven() || !d.isEven()) { c.addTo(this,c); d.subTo(m,d); }
|
|
c.rShiftTo(1,c);
|
|
}
|
|
else if(!d.isEven()) d.subTo(m,d);
|
|
d.rShiftTo(1,d);
|
|
}
|
|
if(u.compareTo(v) >= 0) {
|
|
u.subTo(v,u);
|
|
if(ac) a.subTo(c,a);
|
|
b.subTo(d,b);
|
|
}
|
|
else {
|
|
v.subTo(u,v);
|
|
if(ac) c.subTo(a,c);
|
|
d.subTo(b,d);
|
|
}
|
|
}
|
|
if(v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
|
|
if(d.compareTo(m) >= 0) return d.subtract(m);
|
|
if(d.signum() < 0) d.addTo(m,d); else return d;
|
|
if(d.signum() < 0) return d.add(m); else return d;
|
|
}
|
|
|
|
var lowprimes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509];
|
|
var lplim = (1<<26)/lowprimes[lowprimes.length-1];
|
|
|
|
// (public) test primality with certainty >= 1-.5^t
|
|
function bnIsProbablePrime(t) {
|
|
var i, x = this.abs();
|
|
var x_array = x.array;
|
|
if(x.t == 1 && x_array[0] <= lowprimes[lowprimes.length-1]) {
|
|
for(i = 0; i < lowprimes.length; ++i)
|
|
if(x_array[0] == lowprimes[i]) return true;
|
|
return false;
|
|
}
|
|
if(x.isEven()) return false;
|
|
i = 1;
|
|
while(i < lowprimes.length) {
|
|
var m = lowprimes[i], j = i+1;
|
|
while(j < lowprimes.length && m < lplim) m *= lowprimes[j++];
|
|
m = x.modInt(m);
|
|
while(i < j) if(m%lowprimes[i++] == 0) return false;
|
|
}
|
|
return x.millerRabin(t);
|
|
}
|
|
|
|
// (protected) true if probably prime (HAC 4.24, Miller-Rabin)
|
|
function bnpMillerRabin(t) {
|
|
var n1 = this.subtract(BigInteger.ONE);
|
|
var k = n1.getLowestSetBit();
|
|
if(k <= 0) return false;
|
|
var r = n1.shiftRight(k);
|
|
t = (t+1)>>1;
|
|
if(t > lowprimes.length) t = lowprimes.length;
|
|
var a = nbi();
|
|
for(var i = 0; i < t; ++i) {
|
|
a.fromInt(lowprimes[i]);
|
|
var y = a.modPow(r,this);
|
|
if(y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
|
|
var j = 1;
|
|
while(j++ < k && y.compareTo(n1) != 0) {
|
|
y = y.modPowInt(2,this);
|
|
if(y.compareTo(BigInteger.ONE) == 0) return false;
|
|
}
|
|
if(y.compareTo(n1) != 0) return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// protected
|
|
BigInteger.prototype.chunkSize = bnpChunkSize;
|
|
BigInteger.prototype.toRadix = bnpToRadix;
|
|
BigInteger.prototype.fromRadix = bnpFromRadix;
|
|
BigInteger.prototype.fromNumber = bnpFromNumber;
|
|
BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
|
|
BigInteger.prototype.changeBit = bnpChangeBit;
|
|
BigInteger.prototype.addTo = bnpAddTo;
|
|
BigInteger.prototype.dMultiply = bnpDMultiply;
|
|
BigInteger.prototype.dAddOffset = bnpDAddOffset;
|
|
BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
|
|
BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
|
|
BigInteger.prototype.modInt = bnpModInt;
|
|
BigInteger.prototype.millerRabin = bnpMillerRabin;
|
|
|
|
// public
|
|
BigInteger.prototype.clone = bnClone;
|
|
BigInteger.prototype.intValue = bnIntValue;
|
|
BigInteger.prototype.byteValue = bnByteValue;
|
|
BigInteger.prototype.shortValue = bnShortValue;
|
|
BigInteger.prototype.signum = bnSigNum;
|
|
BigInteger.prototype.toByteArray = bnToByteArray;
|
|
BigInteger.prototype.equals = bnEquals;
|
|
BigInteger.prototype.min = bnMin;
|
|
BigInteger.prototype.max = bnMax;
|
|
BigInteger.prototype.and = bnAnd;
|
|
BigInteger.prototype.or = bnOr;
|
|
BigInteger.prototype.xor = bnXor;
|
|
BigInteger.prototype.andNot = bnAndNot;
|
|
BigInteger.prototype.not = bnNot;
|
|
BigInteger.prototype.shiftLeft = bnShiftLeft;
|
|
BigInteger.prototype.shiftRight = bnShiftRight;
|
|
BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
|
|
BigInteger.prototype.bitCount = bnBitCount;
|
|
BigInteger.prototype.testBit = bnTestBit;
|
|
BigInteger.prototype.setBit = bnSetBit;
|
|
BigInteger.prototype.clearBit = bnClearBit;
|
|
BigInteger.prototype.flipBit = bnFlipBit;
|
|
BigInteger.prototype.add = bnAdd;
|
|
BigInteger.prototype.subtract = bnSubtract;
|
|
BigInteger.prototype.multiply = bnMultiply;
|
|
BigInteger.prototype.divide = bnDivide;
|
|
BigInteger.prototype.remainder = bnRemainder;
|
|
BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
|
|
BigInteger.prototype.modPow = bnModPow;
|
|
BigInteger.prototype.modInverse = bnModInverse;
|
|
BigInteger.prototype.pow = bnPow;
|
|
BigInteger.prototype.gcd = bnGCD;
|
|
BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
|
|
|
|
// BigInteger interfaces not implemented in jsbn:
|
|
|
|
// BigInteger(int signum, byte[] magnitude)
|
|
// double doubleValue()
|
|
// float floatValue()
|
|
// int hashCode()
|
|
// long longValue()
|
|
// static BigInteger valueOf(long val)
|
|
// prng4.js - uses Arcfour as a PRNG
|
|
|
|
function Arcfour() {
|
|
this.i = 0;
|
|
this.j = 0;
|
|
this.S = new Array();
|
|
}
|
|
|
|
// Initialize arcfour context from key, an array of ints, each from [0..255]
|
|
function ARC4init(key) {
|
|
var i, j, t;
|
|
for(i = 0; i < 256; ++i)
|
|
this.S[i] = i;
|
|
j = 0;
|
|
for(i = 0; i < 256; ++i) {
|
|
j = (j + this.S[i] + key[i % key.length]) & 255;
|
|
t = this.S[i];
|
|
this.S[i] = this.S[j];
|
|
this.S[j] = t;
|
|
}
|
|
this.i = 0;
|
|
this.j = 0;
|
|
}
|
|
|
|
function ARC4next() {
|
|
var t;
|
|
this.i = (this.i + 1) & 255;
|
|
this.j = (this.j + this.S[this.i]) & 255;
|
|
t = this.S[this.i];
|
|
this.S[this.i] = this.S[this.j];
|
|
this.S[this.j] = t;
|
|
return this.S[(t + this.S[this.i]) & 255];
|
|
}
|
|
|
|
Arcfour.prototype.init = ARC4init;
|
|
Arcfour.prototype.next = ARC4next;
|
|
|
|
// Plug in your RNG constructor here
|
|
function prng_newstate() {
|
|
return new Arcfour();
|
|
}
|
|
|
|
// Pool size must be a multiple of 4 and greater than 32.
|
|
// An array of bytes the size of the pool will be passed to init()
|
|
var rng_psize = 256;
|
|
// Random number generator - requires a PRNG backend, e.g. prng4.js
|
|
|
|
// For best results, put code like
|
|
// <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>
|
|
// in your main HTML document.
|
|
|
|
var rng_state;
|
|
var rng_pool;
|
|
var rng_pptr;
|
|
|
|
// Mix in a 32-bit integer into the pool
|
|
function rng_seed_int(x) {
|
|
rng_pool[rng_pptr++] ^= x & 255;
|
|
rng_pool[rng_pptr++] ^= (x >> 8) & 255;
|
|
rng_pool[rng_pptr++] ^= (x >> 16) & 255;
|
|
rng_pool[rng_pptr++] ^= (x >> 24) & 255;
|
|
if(rng_pptr >= rng_psize) rng_pptr -= rng_psize;
|
|
}
|
|
|
|
// Mix in the current time (w/milliseconds) into the pool
|
|
function rng_seed_time() {
|
|
// Use pre-computed date to avoid making the benchmark
|
|
// results dependent on the current date.
|
|
rng_seed_int(1122926989487);
|
|
}
|
|
|
|
// Initialize the pool with junk if needed.
|
|
if(rng_pool == null) {
|
|
rng_pool = new Array();
|
|
rng_pptr = 0;
|
|
var t;
|
|
while(rng_pptr < rng_psize) { // extract some randomness from Math.random()
|
|
t = Math.floor(65536 * Math.random());
|
|
rng_pool[rng_pptr++] = t >>> 8;
|
|
rng_pool[rng_pptr++] = t & 255;
|
|
}
|
|
rng_pptr = 0;
|
|
rng_seed_time();
|
|
//rng_seed_int(window.screenX);
|
|
//rng_seed_int(window.screenY);
|
|
}
|
|
|
|
function rng_get_byte() {
|
|
if(rng_state == null) {
|
|
rng_seed_time();
|
|
rng_state = prng_newstate();
|
|
rng_state.init(rng_pool);
|
|
for(rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
|
|
rng_pool[rng_pptr] = 0;
|
|
rng_pptr = 0;
|
|
//rng_pool = null;
|
|
}
|
|
// TODO: allow reseeding after first request
|
|
return rng_state.next();
|
|
}
|
|
|
|
function rng_get_bytes(ba) {
|
|
var i;
|
|
for(i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();
|
|
}
|
|
|
|
function SecureRandom() {}
|
|
|
|
SecureRandom.prototype.nextBytes = rng_get_bytes;
|
|
// Depends on jsbn.js and rng.js
|
|
|
|
// convert a (hex) string to a bignum object
|
|
function parseBigInt(str,r) {
|
|
return new BigInteger(str,r);
|
|
}
|
|
|
|
function linebrk(s,n) {
|
|
var ret = "";
|
|
var i = 0;
|
|
while(i + n < s.length) {
|
|
ret += s.substring(i,i+n) + "\n";
|
|
i += n;
|
|
}
|
|
return ret + s.substring(i,s.length);
|
|
}
|
|
|
|
function byte2Hex(b) {
|
|
if(b < 0x10)
|
|
return "0" + b.toString(16);
|
|
else
|
|
return b.toString(16);
|
|
}
|
|
|
|
// PKCS#1 (type 2, random) pad input string s to n bytes, and return a bigint
|
|
function pkcs1pad2(s,n) {
|
|
if(n < s.length + 11) {
|
|
alert("Message too long for RSA");
|
|
return null;
|
|
}
|
|
var ba = new Array();
|
|
var i = s.length - 1;
|
|
while(i >= 0 && n > 0) ba[--n] = s.charCodeAt(i--);
|
|
ba[--n] = 0;
|
|
var rng = new SecureRandom();
|
|
var x = new Array();
|
|
while(n > 2) { // random non-zero pad
|
|
x[0] = 0;
|
|
while(x[0] == 0) rng.nextBytes(x);
|
|
ba[--n] = x[0];
|
|
}
|
|
ba[--n] = 2;
|
|
ba[--n] = 0;
|
|
return new BigInteger(ba);
|
|
}
|
|
|
|
// "empty" RSA key constructor
|
|
function RSAKey() {
|
|
this.n = null;
|
|
this.e = 0;
|
|
this.d = null;
|
|
this.p = null;
|
|
this.q = null;
|
|
this.dmp1 = null;
|
|
this.dmq1 = null;
|
|
this.coeff = null;
|
|
}
|
|
|
|
// Set the public key fields N and e from hex strings
|
|
function RSASetPublic(N,E) {
|
|
if(N != null && E != null && N.length > 0 && E.length > 0) {
|
|
this.n = parseBigInt(N,16);
|
|
this.e = parseInt(E,16);
|
|
}
|
|
else
|
|
alert("Invalid RSA public key");
|
|
}
|
|
|
|
// Perform raw public operation on "x": return x^e (mod n)
|
|
function RSADoPublic(x) {
|
|
return x.modPowInt(this.e, this.n);
|
|
}
|
|
|
|
// Return the PKCS#1 RSA encryption of "text" as an even-length hex string
|
|
function RSAEncrypt(text) {
|
|
var m = pkcs1pad2(text,(this.n.bitLength()+7)>>3);
|
|
if(m == null) return null;
|
|
var c = this.doPublic(m);
|
|
if(c == null) return null;
|
|
var h = c.toString(16);
|
|
if((h.length & 1) == 0) return h; else return "0" + h;
|
|
}
|
|
|
|
// Return the PKCS#1 RSA encryption of "text" as a Base64-encoded string
|
|
//function RSAEncryptB64(text) {
|
|
// var h = this.encrypt(text);
|
|
// if(h) return hex2b64(h); else return null;
|
|
//}
|
|
|
|
// protected
|
|
RSAKey.prototype.doPublic = RSADoPublic;
|
|
|
|
// public
|
|
RSAKey.prototype.setPublic = RSASetPublic;
|
|
RSAKey.prototype.encrypt = RSAEncrypt;
|
|
//RSAKey.prototype.encrypt_b64 = RSAEncryptB64;
|
|
// Depends on rsa.js and jsbn2.js
|
|
|
|
// Undo PKCS#1 (type 2, random) padding and, if valid, return the plaintext
|
|
function pkcs1unpad2(d,n) {
|
|
var b = d.toByteArray();
|
|
var i = 0;
|
|
while(i < b.length && b[i] == 0) ++i;
|
|
if(b.length-i != n-1 || b[i] != 2)
|
|
return null;
|
|
++i;
|
|
while(b[i] != 0)
|
|
if(++i >= b.length) return null;
|
|
var ret = "";
|
|
while(++i < b.length)
|
|
ret += String.fromCharCode(b[i]);
|
|
return ret;
|
|
}
|
|
|
|
// Set the private key fields N, e, and d from hex strings
|
|
function RSASetPrivate(N,E,D) {
|
|
if(N != null && E != null && N.length > 0 && E.length > 0) {
|
|
this.n = parseBigInt(N,16);
|
|
this.e = parseInt(E,16);
|
|
this.d = parseBigInt(D,16);
|
|
}
|
|
else
|
|
alert("Invalid RSA private key");
|
|
}
|
|
|
|
// Set the private key fields N, e, d and CRT params from hex strings
|
|
function RSASetPrivateEx(N,E,D,P,Q,DP,DQ,C) {
|
|
if(N != null && E != null && N.length > 0 && E.length > 0) {
|
|
this.n = parseBigInt(N,16);
|
|
this.e = parseInt(E,16);
|
|
this.d = parseBigInt(D,16);
|
|
this.p = parseBigInt(P,16);
|
|
this.q = parseBigInt(Q,16);
|
|
this.dmp1 = parseBigInt(DP,16);
|
|
this.dmq1 = parseBigInt(DQ,16);
|
|
this.coeff = parseBigInt(C,16);
|
|
}
|
|
else
|
|
alert("Invalid RSA private key");
|
|
}
|
|
|
|
// Generate a new random private key B bits long, using public expt E
|
|
function RSAGenerate(B,E) {
|
|
var rng = new SecureRandom();
|
|
var qs = B>>1;
|
|
this.e = parseInt(E,16);
|
|
var ee = new BigInteger(E,16);
|
|
for(;;) {
|
|
for(;;) {
|
|
this.p = new BigInteger(B-qs,1,rng);
|
|
if(this.p.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.p.isProbablePrime(10)) break;
|
|
}
|
|
for(;;) {
|
|
this.q = new BigInteger(qs,1,rng);
|
|
if(this.q.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) == 0 && this.q.isProbablePrime(10)) break;
|
|
}
|
|
if(this.p.compareTo(this.q) <= 0) {
|
|
var t = this.p;
|
|
this.p = this.q;
|
|
this.q = t;
|
|
}
|
|
var p1 = this.p.subtract(BigInteger.ONE);
|
|
var q1 = this.q.subtract(BigInteger.ONE);
|
|
var phi = p1.multiply(q1);
|
|
if(phi.gcd(ee).compareTo(BigInteger.ONE) == 0) {
|
|
this.n = this.p.multiply(this.q);
|
|
this.d = ee.modInverse(phi);
|
|
this.dmp1 = this.d.mod(p1);
|
|
this.dmq1 = this.d.mod(q1);
|
|
this.coeff = this.q.modInverse(this.p);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Perform raw private operation on "x": return x^d (mod n)
|
|
function RSADoPrivate(x) {
|
|
if(this.p == null || this.q == null)
|
|
return x.modPow(this.d, this.n);
|
|
|
|
// TODO: re-calculate any missing CRT params
|
|
var xp = x.mod(this.p).modPow(this.dmp1, this.p);
|
|
var xq = x.mod(this.q).modPow(this.dmq1, this.q);
|
|
|
|
while(xp.compareTo(xq) < 0)
|
|
xp = xp.add(this.p);
|
|
return xp.subtract(xq).multiply(this.coeff).mod(this.p).multiply(this.q).add(xq);
|
|
}
|
|
|
|
// Return the PKCS#1 RSA decryption of "ctext".
|
|
// "ctext" is an even-length hex string and the output is a plain string.
|
|
function RSADecrypt(ctext) {
|
|
var c = parseBigInt(ctext, 16);
|
|
var m = this.doPrivate(c);
|
|
if(m == null) return null;
|
|
return pkcs1unpad2(m, (this.n.bitLength()+7)>>3);
|
|
}
|
|
|
|
// Return the PKCS#1 RSA decryption of "ctext".
|
|
// "ctext" is a Base64-encoded string and the output is a plain string.
|
|
//function RSAB64Decrypt(ctext) {
|
|
// var h = b64tohex(ctext);
|
|
// if(h) return this.decrypt(h); else return null;
|
|
//}
|
|
|
|
// protected
|
|
RSAKey.prototype.doPrivate = RSADoPrivate;
|
|
|
|
// public
|
|
RSAKey.prototype.setPrivate = RSASetPrivate;
|
|
RSAKey.prototype.setPrivateEx = RSASetPrivateEx;
|
|
RSAKey.prototype.generate = RSAGenerate;
|
|
RSAKey.prototype.decrypt = RSADecrypt;
|
|
//RSAKey.prototype.b64_decrypt = RSAB64Decrypt;
|
|
|
|
|
|
nValue="a5261939975948bb7a58dffe5ff54e65f0498f9175f5a09288810b8975871e99af3b5dd94057b0fc07535f5f97444504fa35169d461d0d30cf0192e307727c065168c788771c561a9400fb49175e9e6aa4e23fe11af69e9412dd23b0cb6684c4c2429bce139e848ab26d0829073351f4acd36074eafd036a5eb83359d2a698d3";
|
|
eValue="10001";
|
|
dValue="8e9912f6d3645894e8d38cb58c0db81ff516cf4c7e5a14c7f1eddb1459d2cded4d8d293fc97aee6aefb861859c8b6a3d1dfe710463e1f9ddc72048c09751971c4a580aa51eb523357a3cc48d31cfad1d4a165066ed92d4748fb6571211da5cb14bc11b6e2df7c1a559e6d5ac1cd5c94703a22891464fba23d0d965086277a161";
|
|
pValue="d090ce58a92c75233a6486cb0a9209bf3583b64f540c76f5294bb97d285eed33aec220bde14b2417951178ac152ceab6da7090905b478195498b352048f15e7d";
|
|
qValue="cab575dc652bb66df15a0359609d51d1db184750c00c6698b90ef3465c99655103edbf0d54c56aec0ce3c4d22592338092a126a0cc49f65a4a30d222b411e58f";
|
|
dmp1Value="1a24bca8e273df2f0e47c199bbf678604e7df7215480c77c8db39f49b000ce2cf7500038acfff5433b7d582a01f1826e6f4d42e1c57f5e1fef7b12aabc59fd25";
|
|
dmq1Value="3d06982efbbe47339e1f6d36b1216b8a741d410b0c662f54f7118b27b9a4ec9d914337eb39841d8666f3034408cf94f5b62f11c402fc994fe15a05493150d9fd";
|
|
coeffValue="3a3e731acd8960b7ff9eb81a7ff93bd1cfa74cbd56987db58b4594fb09c09084db1734c8143f98b602b981aaa9243ca28deb69b5b280ee8dcee0fd2625e53250";
|
|
|
|
setupEngine(am3, 28);
|
|
|
|
var TEXT = "The quick brown fox jumped over the extremely lazy frog! " +
|
|
"Now is the time for all good men to come to the party.";
|
|
var encrypted;
|
|
|
|
function encrypt() {
|
|
var RSA = new RSAKey();
|
|
RSA.setPublic(nValue, eValue);
|
|
RSA.setPrivateEx(nValue, eValue, dValue, pValue, qValue, dmp1Value, dmq1Value, coeffValue);
|
|
encrypted = RSA.encrypt(TEXT);
|
|
}
|
|
|
|
function decrypt() {
|
|
var RSA = new RSAKey();
|
|
RSA.setPublic(nValue, eValue);
|
|
RSA.setPrivateEx(nValue, eValue, dValue, pValue, qValue, dmp1Value, dmq1Value, coeffValue);
|
|
var decrypted = RSA.decrypt(encrypted);
|
|
if (decrypted != TEXT) {
|
|
throw new Error("Crypto operation failed");
|
|
}
|
|
}
|
|
// The ray tracer code in this file is written by Adam Burmister. It
|
|
// is available in its original form from:
|
|
//
|
|
// http://labs.flog.nz.co/raytracer/
|
|
//
|
|
// It has been modified slightly by Google to work as a standalone
|
|
// benchmark, but the all the computational code remains
|
|
// untouched. This file also contains a copy of parts of the Prototype
|
|
// JavaScript framework which is used by the ray tracer.
|
|
|
|
var RayTrace = new BenchmarkSuite('RayTrace', 739989, [
|
|
new Benchmark('RayTrace', renderScene)
|
|
]);
|
|
|
|
|
|
// Variable used to hold a number that can be used to verify that
|
|
// the scene was ray traced correctly.
|
|
var checkNumber;
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
// ------------------------------------------------------------------------
|
|
|
|
// The following is a copy of parts of the Prototype JavaScript library:
|
|
|
|
// Prototype JavaScript framework, version 1.5.0
|
|
// (c) 2005-2007 Sam Stephenson
|
|
//
|
|
// Prototype is freely distributable under the terms of an MIT-style license.
|
|
// For details, see the Prototype web site: http://prototype.conio.net/
|
|
|
|
|
|
var Class = {
|
|
create: function() {
|
|
return function() {
|
|
this.initialize.apply(this, arguments);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
Object.extend = function(destination, source) {
|
|
for (var property in source) {
|
|
destination[property] = source[property];
|
|
}
|
|
return destination;
|
|
};
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
// ------------------------------------------------------------------------
|
|
|
|
// The rest of this file is the actual ray tracer written by Adam
|
|
// Burmister. It's a concatenation of the following files:
|
|
//
|
|
// flog/color.js
|
|
// flog/light.js
|
|
// flog/vector.js
|
|
// flog/ray.js
|
|
// flog/scene.js
|
|
// flog/material/basematerial.js
|
|
// flog/material/solid.js
|
|
// flog/material/chessboard.js
|
|
// flog/shape/baseshape.js
|
|
// flog/shape/sphere.js
|
|
// flog/shape/plane.js
|
|
// flog/intersectioninfo.js
|
|
// flog/camera.js
|
|
// flog/background.js
|
|
// flog/engine.js
|
|
|
|
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Color = Class.create();
|
|
|
|
Flog.RayTracer.Color.prototype = {
|
|
red : 0.0,
|
|
green : 0.0,
|
|
blue : 0.0,
|
|
|
|
initialize : function(r, g, b) {
|
|
if(!r) r = 0.0;
|
|
if(!g) g = 0.0;
|
|
if(!b) b = 0.0;
|
|
|
|
this.red = r;
|
|
this.green = g;
|
|
this.blue = b;
|
|
},
|
|
|
|
add : function(c1, c2){
|
|
var result = new Flog.RayTracer.Color(0,0,0);
|
|
|
|
result.red = c1.red + c2.red;
|
|
result.green = c1.green + c2.green;
|
|
result.blue = c1.blue + c2.blue;
|
|
|
|
return result;
|
|
},
|
|
|
|
addScalar: function(c1, s){
|
|
var result = new Flog.RayTracer.Color(0,0,0);
|
|
|
|
result.red = c1.red + s;
|
|
result.green = c1.green + s;
|
|
result.blue = c1.blue + s;
|
|
|
|
result.limit();
|
|
|
|
return result;
|
|
},
|
|
|
|
subtract: function(c1, c2){
|
|
var result = new Flog.RayTracer.Color(0,0,0);
|
|
|
|
result.red = c1.red - c2.red;
|
|
result.green = c1.green - c2.green;
|
|
result.blue = c1.blue - c2.blue;
|
|
|
|
return result;
|
|
},
|
|
|
|
multiply : function(c1, c2) {
|
|
var result = new Flog.RayTracer.Color(0,0,0);
|
|
|
|
result.red = c1.red * c2.red;
|
|
result.green = c1.green * c2.green;
|
|
result.blue = c1.blue * c2.blue;
|
|
|
|
return result;
|
|
},
|
|
|
|
multiplyScalar : function(c1, f) {
|
|
var result = new Flog.RayTracer.Color(0,0,0);
|
|
|
|
result.red = c1.red * f;
|
|
result.green = c1.green * f;
|
|
result.blue = c1.blue * f;
|
|
|
|
return result;
|
|
},
|
|
|
|
divideFactor : function(c1, f) {
|
|
var result = new Flog.RayTracer.Color(0,0,0);
|
|
|
|
result.red = c1.red / f;
|
|
result.green = c1.green / f;
|
|
result.blue = c1.blue / f;
|
|
|
|
return result;
|
|
},
|
|
|
|
limit: function(){
|
|
this.red = (this.red > 0.0) ? ( (this.red > 1.0) ? 1.0 : this.red ) : 0.0;
|
|
this.green = (this.green > 0.0) ? ( (this.green > 1.0) ? 1.0 : this.green ) : 0.0;
|
|
this.blue = (this.blue > 0.0) ? ( (this.blue > 1.0) ? 1.0 : this.blue ) : 0.0;
|
|
},
|
|
|
|
distance : function(color) {
|
|
var d = Math.abs(this.red - color.red) + Math.abs(this.green - color.green) + Math.abs(this.blue - color.blue);
|
|
return d;
|
|
},
|
|
|
|
blend: function(c1, c2, w){
|
|
var result = new Flog.RayTracer.Color(0,0,0);
|
|
result = Flog.RayTracer.Color.prototype.add(
|
|
Flog.RayTracer.Color.prototype.multiplyScalar(c1, 1 - w),
|
|
Flog.RayTracer.Color.prototype.multiplyScalar(c2, w)
|
|
);
|
|
return result;
|
|
},
|
|
|
|
brightness : function() {
|
|
var r = Math.floor(this.red*255);
|
|
var g = Math.floor(this.green*255);
|
|
var b = Math.floor(this.blue*255);
|
|
return (r * 77 + g * 150 + b * 29) >> 8;
|
|
},
|
|
|
|
toString : function () {
|
|
var r = Math.floor(this.red*255);
|
|
var g = Math.floor(this.green*255);
|
|
var b = Math.floor(this.blue*255);
|
|
|
|
return "rgb("+ r +","+ g +","+ b +")";
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Light = Class.create();
|
|
|
|
Flog.RayTracer.Light.prototype = {
|
|
position: null,
|
|
color: null,
|
|
intensity: 10.0,
|
|
|
|
initialize : function(pos, color, intensity) {
|
|
this.position = pos;
|
|
this.color = color;
|
|
this.intensity = (intensity ? intensity : 10.0);
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Light [' + this.position.x + ',' + this.position.y + ',' + this.position.z + ']';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Vector = Class.create();
|
|
|
|
Flog.RayTracer.Vector.prototype = {
|
|
x : 0.0,
|
|
y : 0.0,
|
|
z : 0.0,
|
|
|
|
initialize : function(x, y, z) {
|
|
this.x = (x ? x : 0);
|
|
this.y = (y ? y : 0);
|
|
this.z = (z ? z : 0);
|
|
},
|
|
|
|
copy: function(vector){
|
|
this.x = vector.x;
|
|
this.y = vector.y;
|
|
this.z = vector.z;
|
|
},
|
|
|
|
normalize : function() {
|
|
var m = this.magnitude();
|
|
return new Flog.RayTracer.Vector(this.x / m, this.y / m, this.z / m);
|
|
},
|
|
|
|
magnitude : function() {
|
|
// return Math.hypot(this.x, this.y, this.z); but keep results Qt5-comparable:
|
|
return Math.sqrt((this.x * this.x) + (this.y * this.y) + (this.z * this.z));
|
|
},
|
|
|
|
cross : function(w) {
|
|
return new Flog.RayTracer.Vector(
|
|
-this.z * w.y + this.y * w.z,
|
|
this.z * w.x - this.x * w.z,
|
|
-this.y * w.x + this.x * w.y);
|
|
},
|
|
|
|
dot : function(w) {
|
|
return this.x * w.x + this.y * w.y + this.z * w.z;
|
|
},
|
|
|
|
add : function(v, w) {
|
|
return new Flog.RayTracer.Vector(w.x + v.x, w.y + v.y, w.z + v.z);
|
|
},
|
|
|
|
subtract : function(v, w) {
|
|
if(!w || !v) throw 'Vectors must be defined [' + v + ',' + w + ']';
|
|
return new Flog.RayTracer.Vector(v.x - w.x, v.y - w.y, v.z - w.z);
|
|
},
|
|
|
|
multiplyVector : function(v, w) {
|
|
return new Flog.RayTracer.Vector(v.x * w.x, v.y * w.y, v.z * w.z);
|
|
},
|
|
|
|
multiplyScalar : function(v, w) {
|
|
return new Flog.RayTracer.Vector(v.x * w, v.y * w, v.z * w);
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Vector [' + this.x + ',' + this.y + ',' + this.z + ']';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Ray = Class.create();
|
|
|
|
Flog.RayTracer.Ray.prototype = {
|
|
position : null,
|
|
direction : null,
|
|
initialize : function(pos, dir) {
|
|
this.position = pos;
|
|
this.direction = dir;
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Ray [' + this.position + ',' + this.direction + ']';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Scene = Class.create();
|
|
|
|
Flog.RayTracer.Scene.prototype = {
|
|
camera : null,
|
|
shapes : [],
|
|
lights : [],
|
|
background : null,
|
|
|
|
initialize : function() {
|
|
this.camera = new Flog.RayTracer.Camera(
|
|
new Flog.RayTracer.Vector(0,0,-5),
|
|
new Flog.RayTracer.Vector(0,0,1),
|
|
new Flog.RayTracer.Vector(0,1,0)
|
|
);
|
|
this.shapes = new Array();
|
|
this.lights = new Array();
|
|
this.background = new Flog.RayTracer.Background(new Flog.RayTracer.Color(0,0,0.5), 0.2);
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
if(typeof(Flog.RayTracer.Material) == 'undefined') Flog.RayTracer.Material = {};
|
|
|
|
Flog.RayTracer.Material.BaseMaterial = Class.create();
|
|
|
|
Flog.RayTracer.Material.BaseMaterial.prototype = {
|
|
|
|
gloss: 2.0, // [0...infinity] 0 = matt
|
|
transparency: 0.0, // 0=opaque
|
|
reflection: 0.0, // [0...infinity] 0 = no reflection
|
|
refraction: 0.50,
|
|
hasTexture: false,
|
|
|
|
initialize : function() {
|
|
|
|
},
|
|
|
|
getColor: function(u, v){
|
|
|
|
},
|
|
|
|
wrapUp: function(t){
|
|
t = t % 2.0;
|
|
if(t < -1) t += 2.0;
|
|
if(t >= 1) t -= 2.0;
|
|
return t;
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Material [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Material.Solid = Class.create();
|
|
|
|
Flog.RayTracer.Material.Solid.prototype = Object.extend(
|
|
new Flog.RayTracer.Material.BaseMaterial(), {
|
|
initialize : function(color, reflection, refraction, transparency, gloss) {
|
|
this.color = color;
|
|
this.reflection = reflection;
|
|
this.transparency = transparency;
|
|
this.gloss = gloss;
|
|
this.hasTexture = false;
|
|
},
|
|
|
|
getColor: function(u, v){
|
|
return this.color;
|
|
},
|
|
|
|
toString : function () {
|
|
return 'SolidMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
|
|
}
|
|
}
|
|
);
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Material.Chessboard = Class.create();
|
|
|
|
Flog.RayTracer.Material.Chessboard.prototype = Object.extend(
|
|
new Flog.RayTracer.Material.BaseMaterial(), {
|
|
colorEven: null,
|
|
colorOdd: null,
|
|
density: 0.5,
|
|
|
|
initialize : function(colorEven, colorOdd, reflection, transparency, gloss, density) {
|
|
this.colorEven = colorEven;
|
|
this.colorOdd = colorOdd;
|
|
this.reflection = reflection;
|
|
this.transparency = transparency;
|
|
this.gloss = gloss;
|
|
this.density = density;
|
|
this.hasTexture = true;
|
|
},
|
|
|
|
getColor: function(u, v){
|
|
var t = this.wrapUp(u * this.density) * this.wrapUp(v * this.density);
|
|
|
|
if(t < 0.0)
|
|
return this.colorEven;
|
|
else
|
|
return this.colorOdd;
|
|
},
|
|
|
|
toString : function () {
|
|
return 'ChessMaterial [gloss=' + this.gloss + ', transparency=' + this.transparency + ', hasTexture=' + this.hasTexture +']';
|
|
}
|
|
}
|
|
);
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};
|
|
|
|
Flog.RayTracer.Shape.Sphere = Class.create();
|
|
|
|
Flog.RayTracer.Shape.Sphere.prototype = {
|
|
initialize : function(pos, radius, material) {
|
|
this.radius = radius;
|
|
this.position = pos;
|
|
this.material = material;
|
|
},
|
|
|
|
intersect: function(ray){
|
|
var info = new Flog.RayTracer.IntersectionInfo();
|
|
info.shape = this;
|
|
|
|
var dst = Flog.RayTracer.Vector.prototype.subtract(ray.position, this.position);
|
|
|
|
var B = dst.dot(ray.direction);
|
|
var C = dst.dot(dst) - (this.radius * this.radius);
|
|
var D = (B * B) - C;
|
|
|
|
if(D > 0){ // intersection!
|
|
info.isHit = true;
|
|
info.distance = (-B) - Math.sqrt(D);
|
|
info.position = Flog.RayTracer.Vector.prototype.add(
|
|
ray.position,
|
|
Flog.RayTracer.Vector.prototype.multiplyScalar(
|
|
ray.direction,
|
|
info.distance
|
|
)
|
|
);
|
|
info.normal = Flog.RayTracer.Vector.prototype.subtract(
|
|
info.position,
|
|
this.position
|
|
).normalize();
|
|
|
|
info.color = this.material.getColor(0,0);
|
|
} else {
|
|
info.isHit = false;
|
|
}
|
|
return info;
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Sphere [position=' + this.position + ', radius=' + this.radius + ']';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
if(typeof(Flog.RayTracer.Shape) == 'undefined') Flog.RayTracer.Shape = {};
|
|
|
|
Flog.RayTracer.Shape.Plane = Class.create();
|
|
|
|
Flog.RayTracer.Shape.Plane.prototype = {
|
|
d: 0.0,
|
|
|
|
initialize : function(pos, d, material) {
|
|
this.position = pos;
|
|
this.d = d;
|
|
this.material = material;
|
|
},
|
|
|
|
intersect: function(ray){
|
|
var info = new Flog.RayTracer.IntersectionInfo();
|
|
|
|
var Vd = this.position.dot(ray.direction);
|
|
if(Vd == 0) return info; // no intersection
|
|
|
|
var t = -(this.position.dot(ray.position) + this.d) / Vd;
|
|
if(t <= 0) return info;
|
|
|
|
info.shape = this;
|
|
info.isHit = true;
|
|
info.position = Flog.RayTracer.Vector.prototype.add(
|
|
ray.position,
|
|
Flog.RayTracer.Vector.prototype.multiplyScalar(
|
|
ray.direction,
|
|
t
|
|
)
|
|
);
|
|
info.normal = this.position;
|
|
info.distance = t;
|
|
|
|
if(this.material.hasTexture){
|
|
var vU = new Flog.RayTracer.Vector(this.position.y, this.position.z, -this.position.x);
|
|
var vV = vU.cross(this.position);
|
|
var u = info.position.dot(vU);
|
|
var v = info.position.dot(vV);
|
|
info.color = this.material.getColor(u,v);
|
|
} else {
|
|
info.color = this.material.getColor(0,0);
|
|
}
|
|
|
|
return info;
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Plane [' + this.position + ', d=' + this.d + ']';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.IntersectionInfo = Class.create();
|
|
|
|
Flog.RayTracer.IntersectionInfo.prototype = {
|
|
isHit: false,
|
|
hitCount: 0,
|
|
shape: null,
|
|
position: null,
|
|
normal: null,
|
|
color: null,
|
|
distance: null,
|
|
|
|
initialize : function() {
|
|
this.color = new Flog.RayTracer.Color(0,0,0);
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Intersection [' + this.position + ']';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Camera = Class.create();
|
|
|
|
Flog.RayTracer.Camera.prototype = {
|
|
position: null,
|
|
lookAt: null,
|
|
equator: null,
|
|
up: null,
|
|
screen: null,
|
|
|
|
initialize : function(pos, lookAt, up) {
|
|
this.position = pos;
|
|
this.lookAt = lookAt;
|
|
this.up = up;
|
|
this.equator = lookAt.normalize().cross(this.up);
|
|
this.screen = Flog.RayTracer.Vector.prototype.add(this.position, this.lookAt);
|
|
},
|
|
|
|
getRay: function(vx, vy){
|
|
var pos = Flog.RayTracer.Vector.prototype.subtract(
|
|
this.screen,
|
|
Flog.RayTracer.Vector.prototype.subtract(
|
|
Flog.RayTracer.Vector.prototype.multiplyScalar(this.equator, vx),
|
|
Flog.RayTracer.Vector.prototype.multiplyScalar(this.up, vy)
|
|
)
|
|
);
|
|
pos.y = pos.y * -1;
|
|
var dir = Flog.RayTracer.Vector.prototype.subtract(
|
|
pos,
|
|
this.position
|
|
);
|
|
|
|
var ray = new Flog.RayTracer.Ray(pos, dir.normalize());
|
|
|
|
return ray;
|
|
},
|
|
|
|
toString : function () {
|
|
return 'Ray []';
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Background = Class.create();
|
|
|
|
Flog.RayTracer.Background.prototype = {
|
|
color : null,
|
|
ambience : 0.0,
|
|
|
|
initialize : function(color, ambience) {
|
|
this.color = color;
|
|
this.ambience = ambience;
|
|
}
|
|
}
|
|
/* Fake a Flog.* namespace */
|
|
if(typeof(Flog) == 'undefined') var Flog = {};
|
|
if(typeof(Flog.RayTracer) == 'undefined') Flog.RayTracer = {};
|
|
|
|
Flog.RayTracer.Engine = Class.create();
|
|
|
|
Flog.RayTracer.Engine.prototype = {
|
|
canvas: null, /* 2d context we can render to */
|
|
|
|
initialize: function(options){
|
|
this.options = Object.extend({
|
|
canvasHeight: 100,
|
|
canvasWidth: 100,
|
|
pixelWidth: 2,
|
|
pixelHeight: 2,
|
|
renderDiffuse: false,
|
|
renderShadows: false,
|
|
renderHighlights: false,
|
|
renderReflections: false,
|
|
rayDepth: 2
|
|
}, options || {});
|
|
|
|
this.options.canvasHeight /= this.options.pixelHeight;
|
|
this.options.canvasWidth /= this.options.pixelWidth;
|
|
|
|
/* TODO: dynamically include other scripts */
|
|
},
|
|
|
|
setPixel: function(x, y, color){
|
|
var pxW, pxH;
|
|
pxW = this.options.pixelWidth;
|
|
pxH = this.options.pixelHeight;
|
|
|
|
if (this.canvas) {
|
|
this.canvas.fillStyle = color.toString();
|
|
this.canvas.fillRect (x * pxW, y * pxH, pxW, pxH);
|
|
} else {
|
|
if (x === y) {
|
|
checkNumber += color.brightness();
|
|
}
|
|
// print(x * pxW, y * pxH, pxW, pxH);
|
|
}
|
|
},
|
|
|
|
renderScene: function(scene, canvas){
|
|
checkNumber = 0;
|
|
/* Get canvas */
|
|
if (canvas) {
|
|
this.canvas = canvas.getContext("2d");
|
|
} else {
|
|
this.canvas = null;
|
|
}
|
|
|
|
var canvasHeight = this.options.canvasHeight;
|
|
var canvasWidth = this.options.canvasWidth;
|
|
|
|
for(var y=0; y < canvasHeight; y++){
|
|
for(var x=0; x < canvasWidth; x++){
|
|
var yp = y * 1.0 / canvasHeight * 2 - 1;
|
|
var xp = x * 1.0 / canvasWidth * 2 - 1;
|
|
|
|
var ray = scene.camera.getRay(xp, yp);
|
|
|
|
var color = this.getPixelColor(ray, scene);
|
|
|
|
this.setPixel(x, y, color);
|
|
}
|
|
}
|
|
if (checkNumber !== 2321) {
|
|
throw new Error("Scene rendered incorrectly");
|
|
}
|
|
},
|
|
|
|
getPixelColor: function(ray, scene){
|
|
var info = this.testIntersection(ray, scene, null);
|
|
if(info.isHit){
|
|
var color = this.rayTrace(info, ray, scene, 0);
|
|
return color;
|
|
}
|
|
return scene.background.color;
|
|
},
|
|
|
|
testIntersection: function(ray, scene, exclude){
|
|
var hits = 0;
|
|
var best = new Flog.RayTracer.IntersectionInfo();
|
|
best.distance = 2000;
|
|
|
|
for(var i=0; i<scene.shapes.length; i++){
|
|
var shape = scene.shapes[i];
|
|
|
|
if(shape != exclude){
|
|
var info = shape.intersect(ray);
|
|
if(info.isHit && info.distance >= 0 && info.distance < best.distance){
|
|
best = info;
|
|
hits++;
|
|
}
|
|
}
|
|
}
|
|
best.hitCount = hits;
|
|
return best;
|
|
},
|
|
|
|
getReflectionRay: function(P,N,V){
|
|
var c1 = -N.dot(V);
|
|
var R1 = Flog.RayTracer.Vector.prototype.add(
|
|
Flog.RayTracer.Vector.prototype.multiplyScalar(N, 2*c1),
|
|
V
|
|
);
|
|
return new Flog.RayTracer.Ray(P, R1);
|
|
},
|
|
|
|
rayTrace: function(info, ray, scene, depth){
|
|
// Calc ambient
|
|
var color = Flog.RayTracer.Color.prototype.multiplyScalar(info.color, scene.background.ambience);
|
|
var oldColor = color;
|
|
var shininess = Math.pow(10, info.shape.material.gloss + 1);
|
|
|
|
for(var i=0; i<scene.lights.length; i++){
|
|
var light = scene.lights[i];
|
|
|
|
// Calc diffuse lighting
|
|
var v = Flog.RayTracer.Vector.prototype.subtract(
|
|
light.position,
|
|
info.position
|
|
).normalize();
|
|
|
|
if(this.options.renderDiffuse){
|
|
var L = v.dot(info.normal);
|
|
if(L > 0.0){
|
|
color = Flog.RayTracer.Color.prototype.add(
|
|
color,
|
|
Flog.RayTracer.Color.prototype.multiply(
|
|
info.color,
|
|
Flog.RayTracer.Color.prototype.multiplyScalar(
|
|
light.color,
|
|
L
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
// The greater the depth the more accurate the colours, but
|
|
// this is exponentially (!) expensive
|
|
if(depth <= this.options.rayDepth){
|
|
// calculate reflection ray
|
|
if(this.options.renderReflections && info.shape.material.reflection > 0)
|
|
{
|
|
var reflectionRay = this.getReflectionRay(info.position, info.normal, ray.direction);
|
|
var refl = this.testIntersection(reflectionRay, scene, info.shape);
|
|
|
|
if (refl.isHit && refl.distance > 0){
|
|
refl.color = this.rayTrace(refl, reflectionRay, scene, depth + 1);
|
|
} else {
|
|
refl.color = scene.background.color;
|
|
}
|
|
|
|
color = Flog.RayTracer.Color.prototype.blend(
|
|
color,
|
|
refl.color,
|
|
info.shape.material.reflection
|
|
);
|
|
}
|
|
|
|
// Refraction
|
|
/* TODO */
|
|
}
|
|
|
|
/* Render shadows and highlights */
|
|
|
|
var shadowInfo = new Flog.RayTracer.IntersectionInfo();
|
|
|
|
if(this.options.renderShadows){
|
|
var shadowRay = new Flog.RayTracer.Ray(info.position, v);
|
|
|
|
shadowInfo = this.testIntersection(shadowRay, scene, info.shape);
|
|
if(shadowInfo.isHit && shadowInfo.shape != info.shape /*&& shadowInfo.shape.type != 'PLANE'*/){
|
|
var vA = Flog.RayTracer.Color.prototype.multiplyScalar(color, 0.5);
|
|
var dB = (0.5 * Math.pow(shadowInfo.shape.material.transparency, 0.5));
|
|
color = Flog.RayTracer.Color.prototype.addScalar(vA,dB);
|
|
}
|
|
}
|
|
|
|
// Phong specular highlights
|
|
if(this.options.renderHighlights && !shadowInfo.isHit && info.shape.material.gloss > 0){
|
|
var Lv = Flog.RayTracer.Vector.prototype.subtract(
|
|
info.shape.position,
|
|
light.position
|
|
).normalize();
|
|
|
|
var E = Flog.RayTracer.Vector.prototype.subtract(
|
|
scene.camera.position,
|
|
info.shape.position
|
|
).normalize();
|
|
|
|
var H = Flog.RayTracer.Vector.prototype.subtract(
|
|
E,
|
|
Lv
|
|
).normalize();
|
|
|
|
var glossWeight = Math.pow(Math.max(info.normal.dot(H), 0), shininess);
|
|
color = Flog.RayTracer.Color.prototype.add(
|
|
Flog.RayTracer.Color.prototype.multiplyScalar(light.color, glossWeight),
|
|
color
|
|
);
|
|
}
|
|
}
|
|
color.limit();
|
|
return color;
|
|
}
|
|
};
|
|
|
|
|
|
function renderScene(){
|
|
var scene = new Flog.RayTracer.Scene();
|
|
|
|
scene.camera = new Flog.RayTracer.Camera(
|
|
new Flog.RayTracer.Vector(0, 0, -15),
|
|
new Flog.RayTracer.Vector(-0.2, 0, 5),
|
|
new Flog.RayTracer.Vector(0, 1, 0)
|
|
);
|
|
|
|
scene.background = new Flog.RayTracer.Background(
|
|
new Flog.RayTracer.Color(0.5, 0.5, 0.5),
|
|
0.4
|
|
);
|
|
|
|
var sphere = new Flog.RayTracer.Shape.Sphere(
|
|
new Flog.RayTracer.Vector(-1.5, 1.5, 2),
|
|
1.5,
|
|
new Flog.RayTracer.Material.Solid(
|
|
new Flog.RayTracer.Color(0,0.5,0.5),
|
|
0.3,
|
|
0.0,
|
|
0.0,
|
|
2.0
|
|
)
|
|
);
|
|
|
|
var sphere1 = new Flog.RayTracer.Shape.Sphere(
|
|
new Flog.RayTracer.Vector(1, 0.25, 1),
|
|
0.5,
|
|
new Flog.RayTracer.Material.Solid(
|
|
new Flog.RayTracer.Color(0.9,0.9,0.9),
|
|
0.1,
|
|
0.0,
|
|
0.0,
|
|
1.5
|
|
)
|
|
);
|
|
|
|
var plane = new Flog.RayTracer.Shape.Plane(
|
|
new Flog.RayTracer.Vector(0.1, 0.9, -0.5).normalize(),
|
|
1.2,
|
|
new Flog.RayTracer.Material.Chessboard(
|
|
new Flog.RayTracer.Color(1,1,1),
|
|
new Flog.RayTracer.Color(0,0,0),
|
|
0.2,
|
|
0.0,
|
|
1.0,
|
|
0.7
|
|
)
|
|
);
|
|
|
|
scene.shapes.push(plane);
|
|
scene.shapes.push(sphere);
|
|
scene.shapes.push(sphere1);
|
|
|
|
var light = new Flog.RayTracer.Light(
|
|
new Flog.RayTracer.Vector(5, 10, -1),
|
|
new Flog.RayTracer.Color(0.8, 0.8, 0.8)
|
|
);
|
|
|
|
var light1 = new Flog.RayTracer.Light(
|
|
new Flog.RayTracer.Vector(-3, 5, -15),
|
|
new Flog.RayTracer.Color(0.8, 0.8, 0.8),
|
|
100
|
|
);
|
|
|
|
scene.lights.push(light);
|
|
scene.lights.push(light1);
|
|
|
|
var imageWidth = 100; // $F('imageWidth');
|
|
var imageHeight = 100; // $F('imageHeight');
|
|
var pixelSize = "5,5".split(','); // $F('pixelSize').split(',');
|
|
var renderDiffuse = true; // $F('renderDiffuse');
|
|
var renderShadows = true; // $F('renderShadows');
|
|
var renderHighlights = true; // $F('renderHighlights');
|
|
var renderReflections = true; // $F('renderReflections');
|
|
var rayDepth = 2;//$F('rayDepth');
|
|
|
|
var raytracer = new Flog.RayTracer.Engine(
|
|
{
|
|
canvasWidth: imageWidth,
|
|
canvasHeight: imageHeight,
|
|
pixelWidth: pixelSize[0],
|
|
pixelHeight: pixelSize[1],
|
|
"renderDiffuse": renderDiffuse,
|
|
"renderHighlights": renderHighlights,
|
|
"renderShadows": renderShadows,
|
|
"renderReflections": renderReflections,
|
|
"rayDepth": rayDepth
|
|
}
|
|
);
|
|
|
|
raytracer.renderScene(scene, null, 0);
|
|
}
|
|
// This file is automatically generated by scheme2js, except for the
|
|
// benchmark harness code at the beginning and end of the file.
|
|
|
|
var EarleyBoyer = new BenchmarkSuite('EarleyBoyer', 666463, [
|
|
new Benchmark("Earley", function () { BgL_earleyzd2benchmarkzd2(); }),
|
|
new Benchmark("Boyer", function () { BgL_nboyerzd2benchmarkzd2(); })
|
|
]);
|
|
|
|
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/************* GENERATED FILE - DO NOT EDIT *************/
|
|
/*
|
|
* To use write/prints/... the default-output port has to be set first.
|
|
* Simply setting SC_DEFAULT_OUT and SC_ERROR_OUT to the desired values
|
|
* should do the trick.
|
|
* In the following example the std-out and error-port are redirected to
|
|
* a DIV.
|
|
function initRuntime() {
|
|
function escapeHTML(s) {
|
|
var tmp = s;
|
|
tmp = tmp.replace(/&/g, "&");
|
|
tmp = tmp.replace(/</g, "<");
|
|
tmp = tmp.replace(/>/g, ">");
|
|
tmp = tmp.replace(/ /g, " ");
|
|
tmp = tmp.replace(/\n/g, "<br />");
|
|
tmp = tmp.replace(/\t/g, "  ");
|
|
return tmp;
|
|
|
|
}
|
|
|
|
document.write("<div id='stdout'></div>");
|
|
SC_DEFAULT_OUT = new sc_GenericOutputPort(
|
|
function(s) {
|
|
var stdout = document.getElementById('stdout');
|
|
stdout.innerHTML = stdout.innerHTML + escapeHTML(s);
|
|
});
|
|
SC_ERROR_OUT = SC_DEFAULT_OUT;
|
|
}
|
|
*/
|
|
|
|
|
|
function sc_print_debug() {
|
|
sc_print.apply(null, arguments);
|
|
}
|
|
/*** META ((export *js*)) */
|
|
var sc_JS_GLOBALS = this;
|
|
|
|
var __sc_LINE=-1;
|
|
var __sc_FILE="";
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_alert() {
|
|
var len = arguments.length;
|
|
var s = "";
|
|
var i;
|
|
|
|
for( i = 0; i < len; i++ ) {
|
|
s += sc_toDisplayString(arguments[ i ]);
|
|
}
|
|
|
|
return alert( s );
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_typeof( x ) {
|
|
return typeof x;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_error() {
|
|
var a = [sc_jsstring2symbol("*error*")];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
a[i+1] = arguments[i];
|
|
}
|
|
throw a;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "throw ")))
|
|
*/
|
|
function sc_raise(obj) {
|
|
throw obj;
|
|
}
|
|
|
|
/*** META ((export with-handler-lambda)) */
|
|
function sc_withHandlerLambda(handler, body) {
|
|
try {
|
|
return body();
|
|
} catch(e) {
|
|
if (!e._internalException)
|
|
return handler(e);
|
|
else
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
var sc_properties = new Object();
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_putpropBang(sym, key, val) {
|
|
var ht = sc_properties[sym];
|
|
if (!ht) {
|
|
ht = new Object();
|
|
sc_properties[sym] = ht;
|
|
}
|
|
ht[key] = val;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_getprop(sym, key) {
|
|
var ht = sc_properties[sym];
|
|
if (ht) {
|
|
if (key in ht)
|
|
return ht[key];
|
|
else
|
|
return false;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_rempropBang(sym, key) {
|
|
var ht = sc_properties[sym];
|
|
if (ht)
|
|
delete ht[key];
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_any2String(o) {
|
|
return jsstring2string(sc_toDisplayString(o));
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 "==="))
|
|
(type bool))
|
|
*/
|
|
function sc_isEqv(o1, o2) {
|
|
return (o1 === o2);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 "==="))
|
|
(type bool))
|
|
*/
|
|
function sc_isEq(o1, o2) {
|
|
return (o1 === o2);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isNumber(n) {
|
|
return (typeof n === "number");
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isComplex(n) {
|
|
return sc_isNumber(n);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isReal(n) {
|
|
return sc_isNumber(n);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isRational(n) {
|
|
return sc_isReal(n);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isInteger(n) {
|
|
return (parseInt(n) === n);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix ", false")))
|
|
*/
|
|
// we don't have exact numbers...
|
|
function sc_isExact(n) {
|
|
return false;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ", true"))
|
|
(type bool))
|
|
*/
|
|
function sc_isInexact(n) {
|
|
return true;
|
|
}
|
|
|
|
/*** META ((export = =fx =fl)
|
|
(type bool)
|
|
(peephole (infix 2 2 "===")))
|
|
*/
|
|
function sc_equal(x) {
|
|
for (var i = 1; i < arguments.length; i++)
|
|
if (x !== arguments[i])
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/*** META ((export < <fx <fl)
|
|
(type bool)
|
|
(peephole (infix 2 2 "<")))
|
|
*/
|
|
function sc_less(x) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
if (x >= arguments[i])
|
|
return false;
|
|
x = arguments[i];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*** META ((export > >fx >fl)
|
|
(type bool)
|
|
(peephole (infix 2 2 ">")))
|
|
*/
|
|
function sc_greater(x, y) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
if (x <= arguments[i])
|
|
return false;
|
|
x = arguments[i];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*** META ((export <= <=fx <=fl)
|
|
(type bool)
|
|
(peephole (infix 2 2 "<=")))
|
|
*/
|
|
function sc_lessEqual(x, y) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
if (x > arguments[i])
|
|
return false;
|
|
x = arguments[i];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*** META ((export >= >=fl >=fx)
|
|
(type bool)
|
|
(peephole (infix 2 2 ">=")))
|
|
*/
|
|
function sc_greaterEqual(x, y) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
if (x < arguments[i])
|
|
return false;
|
|
x = arguments[i];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix "=== 0")))
|
|
*/
|
|
function sc_isZero(x) {
|
|
return (x === 0);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix "> 0")))
|
|
*/
|
|
function sc_isPositive(x) {
|
|
return (x > 0);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix "< 0")))
|
|
*/
|
|
function sc_isNegative(x) {
|
|
return (x < 0);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix "%2===1")))
|
|
*/
|
|
function sc_isOdd(x) {
|
|
return (x % 2 === 1);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix "%2===0")))
|
|
*/
|
|
function sc_isEven(x) {
|
|
return (x % 2 === 0);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_max = Math.max;
|
|
/*** META ((export #t)) */
|
|
var sc_min = Math.min;
|
|
|
|
/*** META ((export + +fx +fl)
|
|
(peephole (infix 0 #f "+" "0")))
|
|
*/
|
|
function sc_plus() {
|
|
var sum = 0;
|
|
for (var i = 0; i < arguments.length; i++)
|
|
sum += arguments[i];
|
|
return sum;
|
|
}
|
|
|
|
/*** META ((export * *fx *fl)
|
|
(peephole (infix 0 #f "*" "1")))
|
|
*/
|
|
function sc_multi() {
|
|
var product = 1;
|
|
for (var i = 0; i < arguments.length; i++)
|
|
product *= arguments[i];
|
|
return product;
|
|
}
|
|
|
|
/*** META ((export - -fx -fl)
|
|
(peephole (minus)))
|
|
*/
|
|
function sc_minus(x) {
|
|
if (arguments.length === 1)
|
|
return -x;
|
|
else {
|
|
var res = x;
|
|
for (var i = 1; i < arguments.length; i++)
|
|
res -= arguments[i];
|
|
return res;
|
|
}
|
|
}
|
|
|
|
/*** META ((export / /fl)
|
|
(peephole (div)))
|
|
*/
|
|
function sc_div(x) {
|
|
if (arguments.length === 1)
|
|
return 1/x;
|
|
else {
|
|
var res = x;
|
|
for (var i = 1; i < arguments.length; i++)
|
|
res /= arguments[i];
|
|
return res;
|
|
}
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_abs = Math.abs;
|
|
|
|
/*** META ((export quotient /fx)
|
|
(peephole (hole 2 "parseInt(" x "/" y ")")))
|
|
*/
|
|
function sc_quotient(x, y) {
|
|
return parseInt(x / y);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 "%")))
|
|
*/
|
|
function sc_remainder(x, y) {
|
|
return x % y;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (modulo)))
|
|
*/
|
|
function sc_modulo(x, y) {
|
|
var remainder = x % y;
|
|
// if they don't have the same sign
|
|
if ((remainder * y) < 0)
|
|
return remainder + y;
|
|
else
|
|
return remainder;
|
|
}
|
|
|
|
function sc_euclid_gcd(a, b) {
|
|
var temp;
|
|
if (a === 0) return b;
|
|
if (b === 0) return a;
|
|
if (a < 0) {a = -a;};
|
|
if (b < 0) {b = -b;};
|
|
if (b > a) {temp = a; a = b; b = temp;};
|
|
while (true) {
|
|
a %= b;
|
|
if(a === 0) {return b;};
|
|
b %= a;
|
|
if(b === 0) {return a;};
|
|
};
|
|
return b;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_gcd() {
|
|
var gcd = 0;
|
|
for (var i = 0; i < arguments.length; i++)
|
|
gcd = sc_euclid_gcd(gcd, arguments[i]);
|
|
return gcd;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_lcm() {
|
|
var lcm = 1;
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
var f = Math.round(arguments[i] / sc_euclid_gcd(arguments[i], lcm));
|
|
lcm *= Math.abs(f);
|
|
}
|
|
return lcm;
|
|
}
|
|
|
|
// LIMITATION: numerator and denominator don't make sense in floating point world.
|
|
//var SC_MAX_DECIMALS = 1000000
|
|
//
|
|
// function sc_numerator(x) {
|
|
// var rounded = Math.round(x * SC_MAX_DECIMALS);
|
|
// return Math.round(rounded / sc_euclid_gcd(rounded, SC_MAX_DECIMALS));
|
|
// }
|
|
|
|
// function sc_denominator(x) {
|
|
// var rounded = Math.round(x * SC_MAX_DECIMALS);
|
|
// return Math.round(SC_MAX_DECIMALS / sc_euclid_gcd(rounded, SC_MAX_DECIMALS));
|
|
// }
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_floor = Math.floor;
|
|
/*** META ((export #t)) */
|
|
var sc_ceiling = Math.ceil;
|
|
/*** META ((export #t)) */
|
|
var sc_truncate = parseInt;
|
|
/*** META ((export #t)) */
|
|
var sc_round = Math.round;
|
|
|
|
// LIMITATION: sc_rationalize doesn't make sense in a floating point world.
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_exp = Math.exp;
|
|
/*** META ((export #t)) */
|
|
var sc_log = Math.log;
|
|
/*** META ((export #t)) */
|
|
var sc_sin = Math.sin;
|
|
/*** META ((export #t)) */
|
|
var sc_cos = Math.cos;
|
|
/*** META ((export #t)) */
|
|
var sc_tan = Math.tan;
|
|
/*** META ((export #t)) */
|
|
var sc_asin = Math.asin;
|
|
/*** META ((export #t)) */
|
|
var sc_acos = Math.acos;
|
|
/*** META ((export #t)) */
|
|
var sc_atan = Math.atan;
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_sqrt = Math.sqrt;
|
|
/*** META ((export #t)) */
|
|
var sc_expt = Math.pow;
|
|
|
|
// LIMITATION: we don't have complex numbers.
|
|
// LIMITATION: the following functions are hence not implemented.
|
|
// LIMITATION: make-rectangular, make-polar, real-part, imag-part, magnitude, angle
|
|
// LIMITATION: 2 argument atan
|
|
|
|
/*** META ((export #t)
|
|
(peephole (id)))
|
|
*/
|
|
function sc_exact2inexact(x) {
|
|
return x;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (id)))
|
|
*/
|
|
function sc_inexact2exact(x) {
|
|
return x;
|
|
}
|
|
|
|
function sc_number2jsstring(x, radix) {
|
|
if (radix)
|
|
return x.toString(radix);
|
|
else
|
|
return x.toString();
|
|
}
|
|
|
|
function sc_jsstring2number(s, radix) {
|
|
if (s === "") return false;
|
|
|
|
if (radix) {
|
|
var t = parseInt(s, radix);
|
|
if (!t && t !== 0) return false;
|
|
// verify that each char is in range. (parseInt ignores leading
|
|
// white and trailing chars)
|
|
var allowedChars = "01234567890abcdefghijklmnopqrstuvwxyz".substring(0, radix+1);
|
|
if ((new RegExp("^["+allowedChars+"]*$", "i")).test(s))
|
|
return t;
|
|
else return false;
|
|
} else {
|
|
var t = +s; // does not ignore trailing chars.
|
|
if (!t && t !== 0) return false;
|
|
// simply verify that first char is not whitespace.
|
|
var c = s.charAt(0);
|
|
// if +c is 0, but the char is not "0", then we have a whitespace.
|
|
if (+c === 0 && c !== "0") return false;
|
|
return t;
|
|
}
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (not)))
|
|
*/
|
|
function sc_not(b) {
|
|
return b === false;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isBoolean(b) {
|
|
return (b === true) || (b === false);
|
|
}
|
|
|
|
function sc_Pair(car, cdr) {
|
|
this.car = car;
|
|
this.cdr = cdr;
|
|
}
|
|
|
|
sc_Pair.prototype.toString = function() {
|
|
return sc_toDisplayString(this);
|
|
};
|
|
sc_Pair.prototype.sc_toWriteOrDisplayString = function(writeOrDisplay) {
|
|
var current = this;
|
|
|
|
var res = "(";
|
|
|
|
while(true) {
|
|
res += writeOrDisplay(current.car);
|
|
if (sc_isPair(current.cdr)) {
|
|
res += " ";
|
|
current = current.cdr;
|
|
} else if (current.cdr !== null) {
|
|
res += " . " + writeOrDisplay(current.cdr);
|
|
break;
|
|
} else // current.cdr == null
|
|
break;
|
|
}
|
|
|
|
res += ")";
|
|
|
|
return res;
|
|
};
|
|
sc_Pair.prototype.sc_toDisplayString = function() {
|
|
return this.sc_toWriteOrDisplayString(sc_toDisplayString);
|
|
};
|
|
sc_Pair.prototype.sc_toWriteString = function() {
|
|
return this.sc_toWriteOrDisplayString(sc_toWriteString);
|
|
};
|
|
// sc_Pair.prototype.sc_toWriteCircleString in IO.js
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix " instanceof sc_Pair")))
|
|
*/
|
|
function sc_isPair(p) {
|
|
return (p instanceof sc_Pair);
|
|
}
|
|
|
|
function sc_isPairEqual(p1, p2, comp) {
|
|
return (comp(p1.car, p2.car) && comp(p1.cdr, p2.cdr));
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 2 "new sc_Pair(" car ", " cdr ")")))
|
|
*/
|
|
function sc_cons(car, cdr) {
|
|
return new sc_Pair(car, cdr);
|
|
}
|
|
|
|
/*** META ((export cons*)) */
|
|
function sc_consStar() {
|
|
var res = arguments[arguments.length - 1];
|
|
for (var i = arguments.length-2; i >= 0; i--)
|
|
res = new sc_Pair(arguments[i], res);
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car")))
|
|
*/
|
|
function sc_car(p) {
|
|
return p.car;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr")))
|
|
*/
|
|
function sc_cdr(p) {
|
|
return p.cdr;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 2 p ".car = " val)))
|
|
*/
|
|
function sc_setCarBang(p, val) {
|
|
p.car = val;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 2 p ".cdr = " val)))
|
|
*/
|
|
function sc_setCdrBang(p, val) {
|
|
p.cdr = val;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.car")))
|
|
*/
|
|
function sc_caar(p) { return p.car.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.car")))
|
|
*/
|
|
function sc_cadr(p) { return p.cdr.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.cdr")))
|
|
*/
|
|
function sc_cdar(p) { return p.car.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.cdr")))
|
|
*/
|
|
function sc_cddr(p) { return p.cdr.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.car.car")))
|
|
*/
|
|
function sc_caaar(p) { return p.car.car.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.cdr.car")))
|
|
*/
|
|
function sc_cadar(p) { return p.car.cdr.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.car.car")))
|
|
*/
|
|
function sc_caadr(p) { return p.cdr.car.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.cdr.car")))
|
|
*/
|
|
function sc_caddr(p) { return p.cdr.cdr.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.car.cdr")))
|
|
*/
|
|
function sc_cdaar(p) { return p.car.car.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.car.cdr")))
|
|
*/
|
|
function sc_cdadr(p) { return p.cdr.car.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.cdr.cdr")))
|
|
*/
|
|
function sc_cddar(p) { return p.car.cdr.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.cdr.cdr")))
|
|
*/
|
|
function sc_cdddr(p) { return p.cdr.cdr.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.car.car.car")))
|
|
*/
|
|
function sc_caaaar(p) { return p.car.car.car.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.cdr.car.car")))
|
|
*/
|
|
function sc_caadar(p) { return p.car.cdr.car.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.car.car.car")))
|
|
*/
|
|
function sc_caaadr(p) { return p.cdr.car.car.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.cdr.car.car")))
|
|
*/
|
|
function sc_caaddr(p) { return p.cdr.cdr.car.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.car.car.cdr")))
|
|
*/
|
|
function sc_cdaaar(p) { return p.car.car.car.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.cdr.car.cdr")))
|
|
*/
|
|
function sc_cdadar(p) { return p.car.cdr.car.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.car.car.cdr")))
|
|
*/
|
|
function sc_cdaadr(p) { return p.cdr.car.car.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.cdr.car.cdr")))
|
|
*/
|
|
function sc_cdaddr(p) { return p.cdr.cdr.car.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.car.cdr.car")))
|
|
*/
|
|
function sc_cadaar(p) { return p.car.car.cdr.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.cdr.cdr.car")))
|
|
*/
|
|
function sc_caddar(p) { return p.car.cdr.cdr.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.car.cdr.car")))
|
|
*/
|
|
function sc_cadadr(p) { return p.cdr.car.cdr.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.cdr.cdr.car")))
|
|
*/
|
|
function sc_cadddr(p) { return p.cdr.cdr.cdr.car; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.car.cdr.cdr")))
|
|
*/
|
|
function sc_cddaar(p) { return p.car.car.cdr.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".car.cdr.cdr.cdr")))
|
|
*/
|
|
function sc_cdddar(p) { return p.car.cdr.cdr.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.car.cdr.cdr")))
|
|
*/
|
|
function sc_cddadr(p) { return p.cdr.car.cdr.cdr; }
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".cdr.cdr.cdr.cdr")))
|
|
*/
|
|
function sc_cddddr(p) { return p.cdr.cdr.cdr.cdr; }
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_lastPair(l) {
|
|
if (!sc_isPair(l)) sc_error("sc_lastPair: pair expected");
|
|
var res = l;
|
|
var cdr = l.cdr;
|
|
while (sc_isPair(cdr)) {
|
|
res = cdr;
|
|
cdr = res.cdr;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix " === null")))
|
|
*/
|
|
function sc_isNull(o) {
|
|
return (o === null);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isList(o) {
|
|
var rabbit;
|
|
var turtle;
|
|
|
|
var rabbit = o;
|
|
var turtle = o;
|
|
while (true) {
|
|
if (rabbit === null ||
|
|
(rabbit instanceof sc_Pair && rabbit.cdr === null))
|
|
return true; // end of list
|
|
else if ((rabbit instanceof sc_Pair) &&
|
|
(rabbit.cdr instanceof sc_Pair)) {
|
|
rabbit = rabbit.cdr.cdr;
|
|
turtle = turtle.cdr;
|
|
if (rabbit === turtle) return false; // cycle
|
|
} else
|
|
return false; // not pair
|
|
}
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_list() {
|
|
var res = null;
|
|
var a = arguments;
|
|
for (var i = a.length-1; i >= 0; i--)
|
|
res = new sc_Pair(a[i], res);
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_iota(num, init) {
|
|
var res = null;
|
|
if (!init) init = 0;
|
|
for (var i = num - 1; i >= 0; i--)
|
|
res = new sc_Pair(i + init, res);
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_makeList(nbEls, fill) {
|
|
var res = null;
|
|
for (var i = 0; i < nbEls; i++)
|
|
res = new sc_Pair(fill, res);
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_length(l) {
|
|
var res = 0;
|
|
while (l !== null) {
|
|
res++;
|
|
l = l.cdr;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_remq(o, l) {
|
|
var dummy = { cdr : null };
|
|
var tail = dummy;
|
|
while (l !== null) {
|
|
if (l.car !== o) {
|
|
tail.cdr = sc_cons(l.car, null);
|
|
tail = tail.cdr;
|
|
}
|
|
l = l.cdr;
|
|
}
|
|
return dummy.cdr;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_remqBang(o, l) {
|
|
var dummy = { cdr : null };
|
|
var tail = dummy;
|
|
var needsAssig = true;
|
|
while (l !== null) {
|
|
if (l.car === o) {
|
|
needsAssig = true;
|
|
} else {
|
|
if (needsAssig) {
|
|
tail.cdr = l;
|
|
needsAssig = false;
|
|
}
|
|
tail = l;
|
|
}
|
|
l = l.cdr;
|
|
}
|
|
tail.cdr = null;
|
|
return dummy.cdr;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_delete(o, l) {
|
|
var dummy = { cdr : null };
|
|
var tail = dummy;
|
|
while (l !== null) {
|
|
if (!sc_isEqual(l.car, o)) {
|
|
tail.cdr = sc_cons(l.car, null);
|
|
tail = tail.cdr;
|
|
}
|
|
l = l.cdr;
|
|
}
|
|
return dummy.cdr;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_deleteBang(o, l) {
|
|
var dummy = { cdr : null };
|
|
var tail = dummy;
|
|
var needsAssig = true;
|
|
while (l !== null) {
|
|
if (sc_isEqual(l.car, o)) {
|
|
needsAssig = true;
|
|
} else {
|
|
if (needsAssig) {
|
|
tail.cdr = l;
|
|
needsAssig = false;
|
|
}
|
|
tail = l;
|
|
}
|
|
l = l.cdr;
|
|
}
|
|
tail.cdr = null;
|
|
return dummy.cdr;
|
|
}
|
|
|
|
function sc_reverseAppendBang(l1, l2) {
|
|
var res = l2;
|
|
while (l1 !== null) {
|
|
var tmp = res;
|
|
res = l1;
|
|
l1 = l1.cdr;
|
|
res.cdr = tmp;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
function sc_dualAppend(l1, l2) {
|
|
if (l1 === null) return l2;
|
|
if (l2 === null) return l1;
|
|
var rev = sc_reverse(l1);
|
|
return sc_reverseAppendBang(rev, l2);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_append() {
|
|
if (arguments.length === 0)
|
|
return null;
|
|
var res = arguments[arguments.length - 1];
|
|
for (var i = arguments.length - 2; i >= 0; i--)
|
|
res = sc_dualAppend(arguments[i], res);
|
|
return res;
|
|
}
|
|
|
|
function sc_dualAppendBang(l1, l2) {
|
|
if (l1 === null) return l2;
|
|
if (l2 === null) return l1;
|
|
var tmp = l1;
|
|
while (tmp.cdr !== null) tmp=tmp.cdr;
|
|
tmp.cdr = l2;
|
|
return l1;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_appendBang() {
|
|
var res = null;
|
|
for (var i = 0; i < arguments.length; i++)
|
|
res = sc_dualAppendBang(res, arguments[i]);
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_reverse(l1) {
|
|
var res = null;
|
|
while (l1 !== null) {
|
|
res = sc_cons(l1.car, res);
|
|
l1 = l1.cdr;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_reverseBang(l) {
|
|
return sc_reverseAppendBang(l, null);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_listTail(l, k) {
|
|
var res = l;
|
|
for (var i = 0; i < k; i++) {
|
|
res = res.cdr;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_listRef(l, k) {
|
|
return sc_listTail(l, k).car;
|
|
}
|
|
|
|
/* // unoptimized generic versions
|
|
function sc_memX(o, l, comp) {
|
|
while (l != null) {
|
|
if (comp(l.car, o))
|
|
return l;
|
|
l = l.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
function sc_memq(o, l) { return sc_memX(o, l, sc_isEq); }
|
|
function sc_memv(o, l) { return sc_memX(o, l, sc_isEqv); }
|
|
function sc_member(o, l) { return sc_memX(o, l, sc_isEqual); }
|
|
*/
|
|
|
|
/* optimized versions */
|
|
/*** META ((export #t)) */
|
|
function sc_memq(o, l) {
|
|
while (l !== null) {
|
|
if (l.car === o)
|
|
return l;
|
|
l = l.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
/*** META ((export #t)) */
|
|
function sc_memv(o, l) {
|
|
while (l !== null) {
|
|
if (l.car === o)
|
|
return l;
|
|
l = l.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
/*** META ((export #t)) */
|
|
function sc_member(o, l) {
|
|
while (l !== null) {
|
|
if (sc_isEqual(l.car,o))
|
|
return l;
|
|
l = l.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* // generic unoptimized versions
|
|
function sc_assX(o, al, comp) {
|
|
while (al != null) {
|
|
if (comp(al.car.car, o))
|
|
return al.car;
|
|
al = al.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
function sc_assq(o, al) { return sc_assX(o, al, sc_isEq); }
|
|
function sc_assv(o, al) { return sc_assX(o, al, sc_isEqv); }
|
|
function sc_assoc(o, al) { return sc_assX(o, al, sc_isEqual); }
|
|
*/
|
|
// optimized versions
|
|
/*** META ((export #t)) */
|
|
function sc_assq(o, al) {
|
|
while (al !== null) {
|
|
if (al.car.car === o)
|
|
return al.car;
|
|
al = al.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
/*** META ((export #t)) */
|
|
function sc_assv(o, al) {
|
|
while (al !== null) {
|
|
if (al.car.car === o)
|
|
return al.car;
|
|
al = al.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
/*** META ((export #t)) */
|
|
function sc_assoc(o, al) {
|
|
while (al !== null) {
|
|
if (sc_isEqual(al.car.car, o))
|
|
return al.car;
|
|
al = al.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* can be used for mutable strings and characters */
|
|
function sc_isCharStringEqual(cs1, cs2) { return cs1.val === cs2.val; }
|
|
function sc_isCharStringLess(cs1, cs2) { return cs1.val < cs2.val; }
|
|
function sc_isCharStringGreater(cs1, cs2) { return cs1.val > cs2.val; }
|
|
function sc_isCharStringLessEqual(cs1, cs2) { return cs1.val <= cs2.val; }
|
|
function sc_isCharStringGreaterEqual(cs1, cs2) { return cs1.val >= cs2.val; }
|
|
function sc_isCharStringCIEqual(cs1, cs2)
|
|
{ return cs1.val.toLowerCase() === cs2.val.toLowerCase(); }
|
|
function sc_isCharStringCILess(cs1, cs2)
|
|
{ return cs1.val.toLowerCase() < cs2.val.toLowerCase(); }
|
|
function sc_isCharStringCIGreater(cs1, cs2)
|
|
{ return cs1.val.toLowerCase() > cs2.val.toLowerCase(); }
|
|
function sc_isCharStringCILessEqual(cs1, cs2)
|
|
{ return cs1.val.toLowerCase() <= cs2.val.toLowerCase(); }
|
|
function sc_isCharStringCIGreaterEqual(cs1, cs2)
|
|
{ return cs1.val.toLowerCase() >= cs2.val.toLowerCase(); }
|
|
|
|
|
|
|
|
|
|
function sc_Char(c) {
|
|
var cached = sc_Char.lazy[c];
|
|
if (cached)
|
|
return cached;
|
|
this.val = c;
|
|
sc_Char.lazy[c] = this;
|
|
// add return, so FF does not complain.
|
|
return undefined;
|
|
}
|
|
sc_Char.lazy = new Object();
|
|
// thanks to Eric
|
|
sc_Char.char2readable = {
|
|
// "\000": "#\\null",
|
|
// "\007": "#\\bell",
|
|
// "\010": "#\\backspace",
|
|
// "\011": "#\\tab",
|
|
// "\012": "#\\newline",
|
|
// "\014": "#\\page",
|
|
// "\015": "#\\return",
|
|
// "\033": "#\\escape",
|
|
// "\040": "#\\space",
|
|
// "\177": "#\\delete",
|
|
|
|
// /* poeticless names */
|
|
// "\001": "#\\soh",
|
|
// "\002": "#\\stx",
|
|
// "\003": "#\\etx",
|
|
// "\004": "#\\eot",
|
|
// "\005": "#\\enq",
|
|
// "\006": "#\\ack",
|
|
|
|
// "\013": "#\\vt",
|
|
// "\016": "#\\so",
|
|
// "\017": "#\\si",
|
|
|
|
// "\020": "#\\dle",
|
|
// "\021": "#\\dc1",
|
|
// "\022": "#\\dc2",
|
|
// "\023": "#\\dc3",
|
|
// "\024": "#\\dc4",
|
|
// "\025": "#\\nak",
|
|
// "\026": "#\\syn",
|
|
// "\027": "#\\etb",
|
|
|
|
// "\030": "#\\can",
|
|
// "\031": "#\\em",
|
|
// "\032": "#\\sub",
|
|
// "\033": "#\\esc",
|
|
// "\034": "#\\fs",
|
|
// "\035": "#\\gs",
|
|
// "\036": "#\\rs",
|
|
// "\037": "#\\us"
|
|
};
|
|
|
|
sc_Char.readable2char = {
|
|
// "null": "\000",
|
|
// "bell": "\007",
|
|
// "backspace": "\010",
|
|
// "tab": "\011",
|
|
// "newline": "\012",
|
|
// "page": "\014",
|
|
// "return": "\015",
|
|
// "escape": "\033",
|
|
// "space": "\040",
|
|
// "delete": "\000",
|
|
// "soh": "\001",
|
|
// "stx": "\002",
|
|
// "etx": "\003",
|
|
// "eot": "\004",
|
|
// "enq": "\005",
|
|
// "ack": "\006",
|
|
// "bel": "\007",
|
|
// "bs": "\010",
|
|
// "ht": "\011",
|
|
// "nl": "\012",
|
|
// "vt": "\013",
|
|
// "np": "\014",
|
|
// "cr": "\015",
|
|
// "so": "\016",
|
|
// "si": "\017",
|
|
// "dle": "\020",
|
|
// "dc1": "\021",
|
|
// "dc2": "\022",
|
|
// "dc3": "\023",
|
|
// "dc4": "\024",
|
|
// "nak": "\025",
|
|
// "syn": "\026",
|
|
// "etb": "\027",
|
|
// "can": "\030",
|
|
// "em": "\031",
|
|
// "sub": "\032",
|
|
// "esc": "\033",
|
|
// "fs": "\034",
|
|
// "gs": "\035",
|
|
// "rs": "\036",
|
|
// "us": "\037",
|
|
// "sp": "\040",
|
|
// "del": "\177"
|
|
};
|
|
|
|
sc_Char.prototype.toString = function() {
|
|
return this.val;
|
|
};
|
|
// sc_toDisplayString == toString
|
|
sc_Char.prototype.sc_toWriteString = function() {
|
|
var entry = sc_Char.char2readable[this.val];
|
|
if (entry)
|
|
return entry;
|
|
else
|
|
return "#\\" + this.val;
|
|
};
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix "instanceof sc_Char")))
|
|
*/
|
|
function sc_isChar(c) {
|
|
return (c instanceof sc_Char);
|
|
}
|
|
|
|
/*** META ((export char=?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val === " c2 ".val")))
|
|
*/
|
|
var sc_isCharEqual = sc_isCharStringEqual;
|
|
/*** META ((export char<?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val < " c2 ".val")))
|
|
*/
|
|
var sc_isCharLess = sc_isCharStringLess;
|
|
/*** META ((export char>?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val > " c2 ".val")))
|
|
*/
|
|
var sc_isCharGreater = sc_isCharStringGreater;
|
|
/*** META ((export char<=?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val <= " c2 ".val")))
|
|
*/
|
|
var sc_isCharLessEqual = sc_isCharStringLessEqual;
|
|
/*** META ((export char>=?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val >= " c2 ".val")))
|
|
*/
|
|
var sc_isCharGreaterEqual = sc_isCharStringGreaterEqual;
|
|
/*** META ((export char-ci=?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val.toLowerCase() === " c2 ".val.toLowerCase()")))
|
|
*/
|
|
var sc_isCharCIEqual = sc_isCharStringCIEqual;
|
|
/*** META ((export char-ci<?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val.toLowerCase() < " c2 ".val.toLowerCase()")))
|
|
*/
|
|
var sc_isCharCILess = sc_isCharStringCILess;
|
|
/*** META ((export char-ci>?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val.toLowerCase() > " c2 ".val.toLowerCase()")))
|
|
*/
|
|
var sc_isCharCIGreater = sc_isCharStringCIGreater;
|
|
/*** META ((export char-ci<=?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val.toLowerCase() <= " c2 ".val.toLowerCase()")))
|
|
*/
|
|
var sc_isCharCILessEqual = sc_isCharStringCILessEqual;
|
|
/*** META ((export char-ci>=?)
|
|
(type bool)
|
|
(peephole (hole 2 c1 ".val.toLowerCase() >= " c2 ".val.toLowerCase()")))
|
|
*/
|
|
var sc_isCharCIGreaterEqual = sc_isCharStringCIGreaterEqual;
|
|
|
|
var SC_NUMBER_CLASS = "0123456789";
|
|
var SC_WHITESPACE_CLASS = ' \r\n\t\f';
|
|
var SC_LOWER_CLASS = 'abcdefghijklmnopqrstuvwxyz';
|
|
var SC_UPPER_CLASS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
|
|
|
|
function sc_isCharOfClass(c, cl) { return (cl.indexOf(c) != -1); }
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isCharAlphabetic(c)
|
|
{ return sc_isCharOfClass(c.val, SC_LOWER_CLASS) ||
|
|
sc_isCharOfClass(c.val, SC_UPPER_CLASS); }
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (hole 1 "SC_NUMBER_CLASS.indexOf(" c ".val) != -1")))
|
|
*/
|
|
function sc_isCharNumeric(c)
|
|
{ return sc_isCharOfClass(c.val, SC_NUMBER_CLASS); }
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isCharWhitespace(c) {
|
|
var tmp = c.val;
|
|
return tmp === " " || tmp === "\r" || tmp === "\n" || tmp === "\t" || tmp === "\f";
|
|
}
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (hole 1 "SC_UPPER_CLASS.indexOf(" c ".val) != -1")))
|
|
*/
|
|
function sc_isCharUpperCase(c)
|
|
{ return sc_isCharOfClass(c.val, SC_UPPER_CLASS); }
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (hole 1 "SC_LOWER_CLASS.indexOf(" c ".val) != -1")))
|
|
*/
|
|
function sc_isCharLowerCase(c)
|
|
{ return sc_isCharOfClass(c.val, SC_LOWER_CLASS); }
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".val.charCodeAt(0)")))
|
|
*/
|
|
function sc_char2integer(c)
|
|
{ return c.val.charCodeAt(0); }
|
|
/*** META ((export #t)
|
|
(peephole (hole 1 "new sc_Char(String.fromCharCode(" n "))")))
|
|
*/
|
|
function sc_integer2char(n)
|
|
{ return new sc_Char(String.fromCharCode(n)); }
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 1 "new sc_Char(" c ".val.toUpperCase())")))
|
|
*/
|
|
function sc_charUpcase(c)
|
|
{ return new sc_Char(c.val.toUpperCase()); }
|
|
/*** META ((export #t)
|
|
(peephole (hole 1 "new sc_Char(" c ".val.toLowerCase())")))
|
|
*/
|
|
function sc_charDowncase(c)
|
|
{ return new sc_Char(c.val.toLowerCase()); }
|
|
|
|
function sc_makeJSStringOfLength(k, c) {
|
|
var fill;
|
|
if (c === undefined)
|
|
fill = " ";
|
|
else
|
|
fill = c;
|
|
var res = "";
|
|
var len = 1;
|
|
// every round doubles the size of fill.
|
|
while (k >= len) {
|
|
if (k & len)
|
|
res = res.concat(fill);
|
|
fill = fill.concat(fill);
|
|
len *= 2;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
function sc_makejsString(k, c) {
|
|
var fill;
|
|
if (c)
|
|
fill = c.val;
|
|
else
|
|
fill = " ";
|
|
return sc_makeJSStringOfLength(k, fill);
|
|
}
|
|
|
|
function sc_jsstring2list(s) {
|
|
var res = null;
|
|
for (var i = s.length - 1; i >= 0; i--)
|
|
res = sc_cons(new sc_Char(s.charAt(i)), res);
|
|
return res;
|
|
}
|
|
|
|
function sc_list2jsstring(l) {
|
|
var a = new Array();
|
|
while(l !== null) {
|
|
a.push(l.car.val);
|
|
l = l.cdr;
|
|
}
|
|
return "".concat.apply("", a);
|
|
}
|
|
|
|
var sc_Vector = Array;
|
|
|
|
sc_Vector.prototype.sc_toWriteOrDisplayString = function(writeOrDisplay) {
|
|
if (this.length === 0) return "#()";
|
|
|
|
var res = "#(" + writeOrDisplay(this[0]);
|
|
for (var i = 1; i < this.length; i++)
|
|
res += " " + writeOrDisplay(this[i]);
|
|
res += ")";
|
|
return res;
|
|
};
|
|
sc_Vector.prototype.sc_toDisplayString = function() {
|
|
return this.sc_toWriteOrDisplayString(sc_toDisplayString);
|
|
};
|
|
sc_Vector.prototype.sc_toWriteString = function() {
|
|
return this.sc_toWriteOrDisplayString(sc_toWriteString);
|
|
};
|
|
|
|
/*** META ((export vector? array?)
|
|
(type bool)
|
|
(peephole (postfix " instanceof sc_Vector")))
|
|
*/
|
|
function sc_isVector(v) {
|
|
return (v instanceof sc_Vector);
|
|
}
|
|
|
|
// only applies to vectors
|
|
function sc_isVectorEqual(v1, v2, comp) {
|
|
if (v1.length !== v2.length) return false;
|
|
for (var i = 0; i < v1.length; i++)
|
|
if (!comp(v1[i], v2[i])) return false;
|
|
return true;
|
|
}
|
|
|
|
/*** META ((export make-vector make-array)) */
|
|
function sc_makeVector(size, fill) {
|
|
var a = new sc_Vector(size);
|
|
if (fill !== undefined)
|
|
sc_vectorFillBang(a, fill);
|
|
return a;
|
|
}
|
|
|
|
/*** META ((export vector array)
|
|
(peephole (vector)))
|
|
*/
|
|
function sc_vector() {
|
|
var a = new sc_Vector();
|
|
for (var i = 0; i < arguments.length; i++)
|
|
a.push(arguments[i]);
|
|
return a;
|
|
}
|
|
|
|
/*** META ((export vector-length array-length)
|
|
(peephole (postfix ".length")))
|
|
*/
|
|
function sc_vectorLength(v) {
|
|
return v.length;
|
|
}
|
|
|
|
/*** META ((export vector-ref array-ref)
|
|
(peephole (hole 2 v "[" pos "]")))
|
|
*/
|
|
function sc_vectorRef(v, pos) {
|
|
return v[pos];
|
|
}
|
|
|
|
/*** META ((export vector-set! array-set!)
|
|
(peephole (hole 3 v "[" pos "] = " val)))
|
|
*/
|
|
function sc_vectorSetBang(v, pos, val) {
|
|
v[pos] = val;
|
|
}
|
|
|
|
/*** META ((export vector->list array->list)) */
|
|
function sc_vector2list(a) {
|
|
var res = null;
|
|
for (var i = a.length-1; i >= 0; i--)
|
|
res = sc_cons(a[i], res);
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export list->vector list->array)) */
|
|
function sc_list2vector(l) {
|
|
var a = new sc_Vector();
|
|
while(l !== null) {
|
|
a.push(l.car);
|
|
l = l.cdr;
|
|
}
|
|
return a;
|
|
}
|
|
|
|
/*** META ((export vector-fill! array-fill!)) */
|
|
function sc_vectorFillBang(a, fill) {
|
|
for (var i = 0; i < a.length; i++)
|
|
a[i] = fill;
|
|
}
|
|
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_copyVector(a, len) {
|
|
if (len <= a.length)
|
|
return a.slice(0, len);
|
|
else {
|
|
var tmp = a.concat();
|
|
tmp.length = len;
|
|
return tmp;
|
|
}
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 3 a ".slice(" start "," end ")")))
|
|
*/
|
|
function sc_vectorCopy(a, start, end) {
|
|
return a.slice(start, end);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_vectorCopyBang(target, tstart, source, sstart, send) {
|
|
if (!sstart) sstart = 0;
|
|
if (!send) send = source.length;
|
|
|
|
// if target == source we don't want to overwrite not yet copied elements.
|
|
if (tstart <= sstart) {
|
|
for (var i = tstart, j = sstart; j < send; i++, j++) {
|
|
target[i] = source[j];
|
|
}
|
|
} else {
|
|
var diff = send - sstart;
|
|
for (var i = tstart + diff - 1, j = send - 1;
|
|
j >= sstart;
|
|
i--, j--) {
|
|
target[i] = source[j];
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (hole 1 "typeof " o " === 'function'")))
|
|
*/
|
|
function sc_isProcedure(o) {
|
|
return (typeof o === "function");
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_apply(proc) {
|
|
var args = new Array();
|
|
// first part of arguments are not in list-form.
|
|
for (var i = 1; i < arguments.length - 1; i++)
|
|
args.push(arguments[i]);
|
|
var l = arguments[arguments.length - 1];
|
|
while (l !== null) {
|
|
args.push(l.car);
|
|
l = l.cdr;
|
|
}
|
|
return proc.apply(null, args);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_map(proc, l1) {
|
|
if (l1 === undefined)
|
|
return null;
|
|
// else
|
|
var nbApplyArgs = arguments.length - 1;
|
|
var applyArgs = new Array(nbApplyArgs);
|
|
var revres = null;
|
|
while (l1 !== null) {
|
|
for (var i = 0; i < nbApplyArgs; i++) {
|
|
applyArgs[i] = arguments[i + 1].car;
|
|
arguments[i + 1] = arguments[i + 1].cdr;
|
|
}
|
|
revres = sc_cons(proc.apply(null, applyArgs), revres);
|
|
}
|
|
return sc_reverseAppendBang(revres, null);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_mapBang(proc, l1) {
|
|
if (l1 === undefined)
|
|
return null;
|
|
// else
|
|
var l1_orig = l1;
|
|
var nbApplyArgs = arguments.length - 1;
|
|
var applyArgs = new Array(nbApplyArgs);
|
|
while (l1 !== null) {
|
|
var tmp = l1;
|
|
for (var i = 0; i < nbApplyArgs; i++) {
|
|
applyArgs[i] = arguments[i + 1].car;
|
|
arguments[i + 1] = arguments[i + 1].cdr;
|
|
}
|
|
tmp.car = proc.apply(null, applyArgs);
|
|
}
|
|
return l1_orig;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_forEach(proc, l1) {
|
|
if (l1 === undefined)
|
|
return undefined;
|
|
// else
|
|
var nbApplyArgs = arguments.length - 1;
|
|
var applyArgs = new Array(nbApplyArgs);
|
|
while (l1 !== null) {
|
|
for (var i = 0; i < nbApplyArgs; i++) {
|
|
applyArgs[i] = arguments[i + 1].car;
|
|
arguments[i + 1] = arguments[i + 1].cdr;
|
|
}
|
|
proc.apply(null, applyArgs);
|
|
}
|
|
// add return so FF does not complain.
|
|
return undefined;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_filter(proc, l1) {
|
|
var dummy = { cdr : null };
|
|
var tail = dummy;
|
|
while (l1 !== null) {
|
|
if (proc(l1.car) !== false) {
|
|
tail.cdr = sc_cons(l1.car, null);
|
|
tail = tail.cdr;
|
|
}
|
|
l1 = l1.cdr;
|
|
}
|
|
return dummy.cdr;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_filterBang(proc, l1) {
|
|
var head = sc_cons("dummy", l1);
|
|
var it = head;
|
|
var next = l1;
|
|
while (next !== null) {
|
|
if (proc(next.car) !== false) {
|
|
it.cdr = next
|
|
it = next;
|
|
}
|
|
next = next.cdr;
|
|
}
|
|
it.cdr = null;
|
|
return head.cdr;
|
|
}
|
|
|
|
function sc_filterMap1(proc, l1) {
|
|
var revres = null;
|
|
while (l1 !== null) {
|
|
var tmp = proc(l1.car)
|
|
if (tmp !== false) revres = sc_cons(tmp, revres);
|
|
l1 = l1.cdr;
|
|
}
|
|
return sc_reverseAppendBang(revres, null);
|
|
}
|
|
function sc_filterMap2(proc, l1, l2) {
|
|
var revres = null;
|
|
while (l1 !== null) {
|
|
var tmp = proc(l1.car, l2.car);
|
|
if(tmp !== false) revres = sc_cons(tmp, revres);
|
|
l1 = l1.cdr;
|
|
l2 = l2.cdr
|
|
}
|
|
return sc_reverseAppendBang(revres, null);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_filterMap(proc, l1, l2, l3) {
|
|
if (l2 === undefined)
|
|
return sc_filterMap1(proc, l1);
|
|
else if (l3 === undefined)
|
|
return sc_filterMap2(proc, l1, l2);
|
|
// else
|
|
var nbApplyArgs = arguments.length - 1;
|
|
var applyArgs = new Array(nbApplyArgs);
|
|
var revres = null;
|
|
while (l1 !== null) {
|
|
for (var i = 0; i < nbApplyArgs; i++) {
|
|
applyArgs[i] = arguments[i + 1].car;
|
|
arguments[i + 1] = arguments[i + 1].cdr;
|
|
}
|
|
var tmp = proc.apply(null, applyArgs);
|
|
if(tmp !== false) revres = sc_cons(tmp, revres);
|
|
}
|
|
return sc_reverseAppendBang(revres, null);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_any(proc, l) {
|
|
var revres = null;
|
|
while (l !== null) {
|
|
var tmp = proc(l.car);
|
|
if(tmp !== false) return tmp;
|
|
l = l.cdr;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*** META ((export any?)
|
|
(peephole (hole 2 "sc_any(" proc "," l ") !== false")))
|
|
*/
|
|
function sc_anyPred(proc, l) {
|
|
return sc_any(proc, l)!== false;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_every(proc, l) {
|
|
var revres = null;
|
|
var tmp = true;
|
|
while (l !== null) {
|
|
tmp = proc(l.car);
|
|
if (tmp === false) return false;
|
|
l = l.cdr;
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
/*** META ((export every?)
|
|
(peephole (hole 2 "sc_every(" proc "," l ") !== false")))
|
|
*/
|
|
function sc_everyPred(proc, l) {
|
|
var tmp = sc_every(proc, l);
|
|
if (tmp !== false) return true;
|
|
return false;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix "()")))
|
|
*/
|
|
function sc_force(o) {
|
|
return o();
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_makePromise(proc) {
|
|
var isResultReady = false;
|
|
var result = undefined;
|
|
return function() {
|
|
if (!isResultReady) {
|
|
var tmp = proc();
|
|
if (!isResultReady) {
|
|
isResultReady = true;
|
|
result = tmp;
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
|
|
function sc_Values(values) {
|
|
this.values = values;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (values)))
|
|
*/
|
|
function sc_values() {
|
|
if (arguments.length === 1)
|
|
return arguments[0];
|
|
else
|
|
return new sc_Values(arguments);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_callWithValues(producer, consumer) {
|
|
var produced = producer();
|
|
if (produced instanceof sc_Values)
|
|
return consumer.apply(null, produced.values);
|
|
else
|
|
return consumer(produced);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_dynamicWind(before, thunk, after) {
|
|
before();
|
|
try {
|
|
var res = thunk();
|
|
return res;
|
|
} finally {
|
|
after();
|
|
}
|
|
}
|
|
|
|
|
|
// TODO: eval/scheme-report-environment/null-environment/interaction-environment
|
|
|
|
// LIMITATION: 'load' doesn't exist without files.
|
|
// LIMITATION: transcript-on/transcript-off doesn't exist without files.
|
|
|
|
|
|
function sc_Struct(name) {
|
|
this.name = name;
|
|
}
|
|
sc_Struct.prototype.sc_toDisplayString = function() {
|
|
return "#<struct" + sc_hash(this) + ">";
|
|
};
|
|
sc_Struct.prototype.sc_toWriteString = sc_Struct.prototype.sc_toDisplayString;
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 1 "new sc_Struct(" name ")")))
|
|
*/
|
|
function sc_makeStruct(name) {
|
|
return new sc_Struct(name);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix " instanceof sc_Struct")))
|
|
*/
|
|
function sc_isStruct(o) {
|
|
return (o instanceof sc_Struct);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (hole 2 "(" 1 " instanceof sc_Struct) && ( " 1 ".name === " 0 ")")))
|
|
*/
|
|
function sc_isStructNamed(name, s) {
|
|
return ((s instanceof sc_Struct) && (s.name === name));
|
|
}
|
|
|
|
/*** META ((export struct-field)
|
|
(peephole (hole 3 0 "[" 2 "]")))
|
|
*/
|
|
function sc_getStructField(s, name, field) {
|
|
return s[field];
|
|
}
|
|
|
|
/*** META ((export struct-field-set!)
|
|
(peephole (hole 4 0 "[" 2 "] = " 3)))
|
|
*/
|
|
function sc_setStructFieldBang(s, name, field, val) {
|
|
s[field] = val;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "~")))
|
|
*/
|
|
function sc_bitNot(x) {
|
|
return ~x;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 "&")))
|
|
*/
|
|
function sc_bitAnd(x, y) {
|
|
return x & y;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 "|")))
|
|
*/
|
|
function sc_bitOr(x, y) {
|
|
return x | y;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 "^")))
|
|
*/
|
|
function sc_bitXor(x, y) {
|
|
return x ^ y;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 "<<")))
|
|
*/
|
|
function sc_bitLsh(x, y) {
|
|
return x << y;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 ">>")))
|
|
*/
|
|
function sc_bitRsh(x, y) {
|
|
return x >> y;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 2 2 ">>>")))
|
|
*/
|
|
function sc_bitUrsh(x, y) {
|
|
return x >>> y;
|
|
}
|
|
|
|
/*** META ((export js-field js-property)
|
|
(peephole (hole 2 o "[" field "]")))
|
|
*/
|
|
function sc_jsField(o, field) {
|
|
return o[field];
|
|
}
|
|
|
|
/*** META ((export js-field-set! js-property-set!)
|
|
(peephole (hole 3 o "[" field "] = " val)))
|
|
*/
|
|
function sc_setJsFieldBang(o, field, val) {
|
|
return o[field] = val;
|
|
}
|
|
|
|
/*** META ((export js-field-delete! js-property-delete!)
|
|
(peephole (hole 2 "delete" o "[" field "]")))
|
|
*/
|
|
function sc_deleteJsFieldBang(o, field) {
|
|
delete o[field];
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (jsCall)))
|
|
*/
|
|
function sc_jsCall(o, fun) {
|
|
var args = new Array();
|
|
for (var i = 2; i < arguments.length; i++)
|
|
args[i-2] = arguments[i];
|
|
return fun.apply(o, args);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (jsMethodCall)))
|
|
*/
|
|
function sc_jsMethodCall(o, field) {
|
|
var args = new Array();
|
|
for (var i = 2; i < arguments.length; i++)
|
|
args[i-2] = arguments[i];
|
|
return o[field].apply(o, args);
|
|
}
|
|
|
|
/*** META ((export new js-new)
|
|
(peephole (jsNew)))
|
|
*/
|
|
function sc_jsNew(c) {
|
|
var evalStr = "new c(";
|
|
evalStr +=arguments.length > 1? "arguments[1]": "";
|
|
for (var i = 2; i < arguments.length; i++)
|
|
evalStr += ", arguments[" + i + "]";
|
|
evalStr +=")";
|
|
return eval(evalStr);
|
|
}
|
|
|
|
// ======================== RegExp ====================
|
|
/*** META ((export #t)) */
|
|
function sc_pregexp(re) {
|
|
return new RegExp(sc_string2jsstring(re));
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_pregexpMatch(re, s) {
|
|
var reg = (re instanceof RegExp) ? re : sc_pregexp(re);
|
|
var tmp = reg.exec(sc_string2jsstring(s));
|
|
|
|
if (tmp == null) return false;
|
|
|
|
var res = null;
|
|
for (var i = tmp.length-1; i >= 0; i--) {
|
|
if (tmp[i] !== null) {
|
|
res = sc_cons(sc_jsstring2string(tmp[i]), res);
|
|
} else {
|
|
res = sc_cons(false, res);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_pregexpReplace(re, s1, s2) {
|
|
var reg;
|
|
var jss1 = sc_string2jsstring(s1);
|
|
var jss2 = sc_string2jsstring(s2);
|
|
|
|
if (re instanceof RegExp) {
|
|
if (re.global)
|
|
reg = re;
|
|
else
|
|
reg = new RegExp(re.source);
|
|
} else {
|
|
reg = new RegExp(sc_string2jsstring(re));
|
|
}
|
|
|
|
return jss1.replace(reg, jss2);
|
|
}
|
|
|
|
/*** META ((export pregexp-replace*)) */
|
|
function sc_pregexpReplaceAll(re, s1, s2) {
|
|
var reg;
|
|
var jss1 = sc_string2jsstring(s1);
|
|
var jss2 = sc_string2jsstring(s2);
|
|
|
|
if (re instanceof RegExp) {
|
|
if (re.global)
|
|
reg = re;
|
|
else
|
|
reg = new RegExp(re.source, "g");
|
|
} else {
|
|
reg = new RegExp(sc_string2jsstring(re), "g");
|
|
}
|
|
|
|
return jss1.replace(reg, jss2);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_pregexpSplit(re, s) {
|
|
var reg = ((re instanceof RegExp) ?
|
|
re :
|
|
new RegExp(sc_string2jsstring(re)));
|
|
var jss = sc_string2jsstring(s);
|
|
var tmp = jss.split(reg);
|
|
|
|
if (tmp == null) return false;
|
|
|
|
return sc_vector2list(tmp);
|
|
}
|
|
|
|
|
|
/* =========================================================================== */
|
|
/* Other library stuff */
|
|
/* =========================================================================== */
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 1 "Math.floor(Math.random()*" 'n ")")))
|
|
*/
|
|
function sc_random(n) {
|
|
return Math.floor(Math.random()*n);
|
|
}
|
|
|
|
/*** META ((export current-date)
|
|
(peephole (hole 0 "new Date()")))
|
|
*/
|
|
function sc_currentDate() {
|
|
return new Date();
|
|
}
|
|
|
|
function sc_Hashtable() {
|
|
}
|
|
sc_Hashtable.prototype.toString = function() {
|
|
return "#{%hashtable}";
|
|
};
|
|
// sc_toWriteString == sc_toDisplayString == toString
|
|
|
|
function sc_HashtableElement(key, val) {
|
|
this.key = key;
|
|
this.val = val;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 0 "new sc_Hashtable()")))
|
|
*/
|
|
function sc_makeHashtable() {
|
|
return new sc_Hashtable();
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_hashtablePutBang(ht, key, val) {
|
|
var hash = sc_hash(key);
|
|
ht[hash] = new sc_HashtableElement(key, val);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_hashtableGet(ht, key) {
|
|
var hash = sc_hash(key);
|
|
if (hash in ht)
|
|
return ht[hash].val;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_hashtableForEach(ht, f) {
|
|
for (var v in ht) {
|
|
if (ht[v] instanceof sc_HashtableElement)
|
|
f(ht[v].key, ht[v].val);
|
|
}
|
|
}
|
|
|
|
/*** META ((export hashtable-contains?)
|
|
(peephole (hole 2 "sc_hash(" 1 ") in " 0)))
|
|
*/
|
|
function sc_hashtableContains(ht, key) {
|
|
var hash = sc_hash(key);
|
|
if (hash in ht)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
var SC_HASH_COUNTER = 0;
|
|
|
|
function sc_hash(o) {
|
|
if (o === null)
|
|
return "null";
|
|
else if (o === undefined)
|
|
return "undefined";
|
|
else if (o === true)
|
|
return "true";
|
|
else if (o === false)
|
|
return "false";
|
|
else if (typeof o === "number")
|
|
return "num-" + o;
|
|
else if (typeof o === "string")
|
|
return "jsstr-" + o;
|
|
else if (o.sc_getHash)
|
|
return o.sc_getHash();
|
|
else
|
|
return sc_counterHash.call(o);
|
|
}
|
|
function sc_counterHash() {
|
|
if (!this.sc_hash) {
|
|
this.sc_hash = "hash-" + SC_HASH_COUNTER;
|
|
SC_HASH_COUNTER++;
|
|
}
|
|
return this.sc_hash;
|
|
}
|
|
|
|
function sc_Trampoline(args, maxTailCalls) {
|
|
this['__trampoline return__'] = true;
|
|
this.args = args;
|
|
this.MAX_TAIL_CALLs = maxTailCalls;
|
|
}
|
|
// TODO: call/cc stuff
|
|
sc_Trampoline.prototype.restart = function() {
|
|
var o = this;
|
|
while (true) {
|
|
// set both globals.
|
|
SC_TAIL_OBJECT.calls = o.MAX_TAIL_CALLs-1;
|
|
var fun = o.args.callee;
|
|
var res = fun.apply(SC_TAIL_OBJECT, o.args);
|
|
if (res instanceof sc_Trampoline)
|
|
o = res;
|
|
else
|
|
return res;
|
|
}
|
|
}
|
|
|
|
/*** META ((export bind-exit-lambda)) */
|
|
function sc_bindExitLambda(proc) {
|
|
var escape_obj = new sc_BindExitException();
|
|
var escape = function(res) {
|
|
escape_obj.res = res;
|
|
throw escape_obj;
|
|
};
|
|
try {
|
|
return proc(escape);
|
|
} catch(e) {
|
|
if (e === escape_obj) {
|
|
return e.res;
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
function sc_BindExitException() {
|
|
this._internalException = true;
|
|
}
|
|
|
|
var SC_SCM2JS_GLOBALS = new Object();
|
|
|
|
// default tail-call depth.
|
|
// normally the program should set it again. but just in case...
|
|
var SC_TAIL_OBJECT = new Object();
|
|
SC_SCM2JS_GLOBALS.TAIL_OBJECT = SC_TAIL_OBJECT;
|
|
// ======================== I/O =======================
|
|
|
|
/*------------------------------------------------------------------*/
|
|
|
|
function sc_EOF() {
|
|
}
|
|
var SC_EOF_OBJECT = new sc_EOF();
|
|
|
|
function sc_Port() {
|
|
}
|
|
|
|
/* --------------- Input ports -------------------------------------*/
|
|
|
|
function sc_InputPort() {
|
|
}
|
|
sc_InputPort.prototype = new sc_Port();
|
|
|
|
sc_InputPort.prototype.peekChar = function() {
|
|
if (!("peeked" in this))
|
|
this.peeked = this.getNextChar();
|
|
return this.peeked;
|
|
}
|
|
sc_InputPort.prototype.readChar = function() {
|
|
var tmp = this.peekChar();
|
|
delete this.peeked;
|
|
return tmp;
|
|
}
|
|
sc_InputPort.prototype.isCharReady = function() {
|
|
return true;
|
|
}
|
|
sc_InputPort.prototype.close = function() {
|
|
// do nothing
|
|
}
|
|
|
|
/* .............. String port ..........................*/
|
|
function sc_ErrorInputPort() {
|
|
};
|
|
sc_ErrorInputPort.prototype = new sc_InputPort();
|
|
sc_ErrorInputPort.prototype.getNextChar = function() {
|
|
throw "can't read from error-port.";
|
|
};
|
|
sc_ErrorInputPort.prototype.isCharReady = function() {
|
|
return false;
|
|
};
|
|
|
|
|
|
/* .............. String port ..........................*/
|
|
|
|
function sc_StringInputPort(jsStr) {
|
|
// we are going to do some charAts on the str.
|
|
// instead of recreating all the time a String-object, we
|
|
// create one in the beginning. (not sure, if this is really an optim)
|
|
this.str = new String(jsStr);
|
|
this.pos = 0;
|
|
}
|
|
sc_StringInputPort.prototype = new sc_InputPort();
|
|
sc_StringInputPort.prototype.getNextChar = function() {
|
|
if (this.pos >= this.str.length)
|
|
return SC_EOF_OBJECT;
|
|
return this.str.charAt(this.pos++);
|
|
};
|
|
|
|
/* ------------- Read and other lib-funs -------------------------------*/
|
|
function sc_Token(type, val, pos) {
|
|
this.type = type;
|
|
this.val = val;
|
|
this.pos = pos;
|
|
}
|
|
sc_Token.EOF = 0/*EOF*/;
|
|
sc_Token.OPEN_PAR = 1/*OPEN_PAR*/;
|
|
sc_Token.CLOSE_PAR = 2/*CLOSE_PAR*/;
|
|
sc_Token.OPEN_BRACE = 3/*OPEN_BRACE*/;
|
|
sc_Token.CLOSE_BRACE = 4/*CLOSE_BRACE*/;
|
|
sc_Token.OPEN_BRACKET = 5/*OPEN_BRACKET*/;
|
|
sc_Token.CLOSE_BRACKET = 6/*CLOSE_BRACKET*/;
|
|
sc_Token.WHITESPACE = 7/*WHITESPACE*/;
|
|
sc_Token.QUOTE = 8/*QUOTE*/;
|
|
sc_Token.ID = 9/*ID*/;
|
|
sc_Token.DOT = 10/*DOT*/;
|
|
sc_Token.STRING = 11/*STRING*/;
|
|
sc_Token.NUMBER = 12/*NUMBER*/;
|
|
sc_Token.ERROR = 13/*ERROR*/;
|
|
sc_Token.VECTOR_BEGIN = 14/*VECTOR_BEGIN*/;
|
|
sc_Token.TRUE = 15/*TRUE*/;
|
|
sc_Token.FALSE = 16/*FALSE*/;
|
|
sc_Token.UNSPECIFIED = 17/*UNSPECIFIED*/;
|
|
sc_Token.REFERENCE = 18/*REFERENCE*/;
|
|
sc_Token.STORE = 19/*STORE*/;
|
|
sc_Token.CHAR = 20/*CHAR*/;
|
|
|
|
var SC_ID_CLASS = SC_LOWER_CLASS + SC_UPPER_CLASS + "!$%*+-./:<=>?@^_~";
|
|
function sc_Tokenizer(port) {
|
|
this.port = port;
|
|
}
|
|
sc_Tokenizer.prototype.peekToken = function() {
|
|
if (this.peeked)
|
|
return this.peeked;
|
|
var newToken = this.nextToken();
|
|
this.peeked = newToken;
|
|
return newToken;
|
|
};
|
|
sc_Tokenizer.prototype.readToken = function() {
|
|
var tmp = this.peekToken();
|
|
delete this.peeked;
|
|
return tmp;
|
|
};
|
|
sc_Tokenizer.prototype.nextToken = function() {
|
|
var port = this.port;
|
|
|
|
function isNumberChar(c) {
|
|
return (c >= "0" && c <= "9");
|
|
};
|
|
function isIdOrNumberChar(c) {
|
|
return SC_ID_CLASS.indexOf(c) != -1 || // ID-char
|
|
(c >= "0" && c <= "9");
|
|
}
|
|
function isWhitespace(c) {
|
|
return c === " " || c === "\r" || c === "\n" || c === "\t" || c === "\f";
|
|
};
|
|
function isWhitespaceOrEOF(c) {
|
|
return isWhitespace(c) || c === SC_EOF_OBJECT;
|
|
};
|
|
|
|
function readString() {
|
|
res = "";
|
|
while (true) {
|
|
var c = port.readChar();
|
|
switch (c) {
|
|
case '"':
|
|
return new sc_Token(11/*STRING*/, res);
|
|
case "\\":
|
|
var tmp = port.readChar();
|
|
switch (tmp) {
|
|
case '0': res += "\0"; break;
|
|
case 'a': res += "\a"; break;
|
|
case 'b': res += "\b"; break;
|
|
case 'f': res += "\f"; break;
|
|
case 'n': res += "\n"; break;
|
|
case 'r': res += "\r"; break;
|
|
case 't': res += "\t"; break;
|
|
case 'v': res += "\v"; break;
|
|
case '"': res += '"'; break;
|
|
case '\\': res += '\\'; break;
|
|
case 'x':
|
|
/* hexa-number */
|
|
var nb = 0;
|
|
while (true) {
|
|
var hexC = port.peekChar();
|
|
if (hexC >= '0' && hexC <= '9') {
|
|
port.readChar();
|
|
nb = nb * 16 + hexC.charCodeAt(0) - '0'.charCodeAt(0);
|
|
} else if (hexC >= 'a' && hexC <= 'f') {
|
|
port.readChar();
|
|
nb = nb * 16 + hexC.charCodeAt(0) - 'a'.charCodeAt(0);
|
|
} else if (hexC >= 'A' && hexC <= 'F') {
|
|
port.readChar();
|
|
nb = nb * 16 + hexC.charCodeAt(0) - 'A'.charCodeAt(0);
|
|
} else {
|
|
// next char isn't part of hex.
|
|
res += String.fromCharCode(nb);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
if (tmp === SC_EOF_OBJECT) {
|
|
return new sc_Token(13/*ERROR*/, "unclosed string-literal" + res);
|
|
}
|
|
res += tmp;
|
|
}
|
|
break;
|
|
default:
|
|
if (c === SC_EOF_OBJECT) {
|
|
return new sc_Token(13/*ERROR*/, "unclosed string-literal" + res);
|
|
}
|
|
res += c;
|
|
}
|
|
}
|
|
};
|
|
function readIdOrNumber(firstChar) {
|
|
var res = firstChar;
|
|
while (isIdOrNumberChar(port.peekChar()))
|
|
res += port.readChar();
|
|
if (isNaN(res))
|
|
return new sc_Token(9/*ID*/, res);
|
|
else
|
|
return new sc_Token(12/*NUMBER*/, res - 0);
|
|
};
|
|
|
|
function skipWhitespaceAndComments() {
|
|
var done = false;
|
|
while (!done) {
|
|
done = true;
|
|
while (isWhitespace(port.peekChar()))
|
|
port.readChar();
|
|
if (port.peekChar() === ';') {
|
|
port.readChar();
|
|
done = false;
|
|
while (true) {
|
|
curChar = port.readChar();
|
|
if (curChar === SC_EOF_OBJECT ||
|
|
curChar === '\n')
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
function readDot() {
|
|
if (isWhitespace(port.peekChar()))
|
|
return new sc_Token(10/*DOT*/);
|
|
else
|
|
return readIdOrNumber(".");
|
|
};
|
|
|
|
function readSharp() {
|
|
var c = port.readChar();
|
|
if (isWhitespace(c))
|
|
return new sc_Token(13/*ERROR*/, "bad #-pattern0.");
|
|
|
|
// reference
|
|
if (isNumberChar(c)) {
|
|
var nb = c - 0;
|
|
while (isNumberChar(port.peekChar()))
|
|
nb = nb*10 + (port.readChar() - 0);
|
|
switch (port.readChar()) {
|
|
case '#':
|
|
return new sc_Token(18/*REFERENCE*/, nb);
|
|
case '=':
|
|
return new sc_Token(19/*STORE*/, nb);
|
|
default:
|
|
return new sc_Token(13/*ERROR*/, "bad #-pattern1." + nb);
|
|
}
|
|
}
|
|
|
|
if (c === "(")
|
|
return new sc_Token(14/*VECTOR_BEGIN*/);
|
|
|
|
if (c === "\\") { // character
|
|
var tmp = ""
|
|
while (!isWhitespaceOrEOF(port.peekChar()))
|
|
tmp += port.readChar();
|
|
switch (tmp.length) {
|
|
case 0: // it's escaping a whitespace char:
|
|
if (sc_isEOFObject(port.peekChar))
|
|
return new sc_Token(13/*ERROR*/, "bad #-pattern2.");
|
|
else
|
|
return new sc_Token(20/*CHAR*/, port.readChar());
|
|
case 1:
|
|
return new sc_Token(20/*CHAR*/, tmp);
|
|
default:
|
|
var entry = sc_Char.readable2char[tmp.toLowerCase()];
|
|
if (entry)
|
|
return new sc_Token(20/*CHAR*/, entry);
|
|
else
|
|
return new sc_Token(13/*ERROR*/, "unknown character description: #\\" + tmp);
|
|
}
|
|
}
|
|
|
|
// some constants (#t, #f, #unspecified)
|
|
var res;
|
|
var needing;
|
|
switch (c) {
|
|
case 't': res = new sc_Token(15/*TRUE*/, true); needing = ""; break;
|
|
case 'f': res = new sc_Token(16/*FALSE*/, false); needing = ""; break;
|
|
case 'u': res = new sc_Token(17/*UNSPECIFIED*/, undefined); needing = "nspecified"; break;
|
|
default:
|
|
return new sc_Token(13/*ERROR*/, "bad #-pattern3: " + c);
|
|
}
|
|
while(true) {
|
|
c = port.peekChar();
|
|
if ((isWhitespaceOrEOF(c) || c === ')') &&
|
|
needing == "")
|
|
return res;
|
|
else if (isWhitespace(c) || needing == "")
|
|
return new sc_Token(13/*ERROR*/, "bad #-pattern4 " + c + " " + needing);
|
|
else if (needing.charAt(0) == c) {
|
|
port.readChar(); // consume
|
|
needing = needing.slice(1);
|
|
} else
|
|
return new sc_Token(13/*ERROR*/, "bad #-pattern5");
|
|
}
|
|
|
|
};
|
|
|
|
skipWhitespaceAndComments();
|
|
var curChar = port.readChar();
|
|
if (curChar === SC_EOF_OBJECT)
|
|
return new sc_Token(0/*EOF*/, curChar);
|
|
switch (curChar)
|
|
{
|
|
case " ":
|
|
case "\n":
|
|
case "\t":
|
|
return readWhitespace();
|
|
case "(":
|
|
return new sc_Token(1/*OPEN_PAR*/);
|
|
case ")":
|
|
return new sc_Token(2/*CLOSE_PAR*/);
|
|
case "{":
|
|
return new sc_Token(3/*OPEN_BRACE*/);
|
|
case "}":
|
|
return new sc_Token(4/*CLOSE_BRACE*/);
|
|
case "[":
|
|
return new sc_Token(5/*OPEN_BRACKET*/);
|
|
case "]":
|
|
return new sc_Token(6/*CLOSE_BRACKET*/);
|
|
case "'":
|
|
return new sc_Token(8/*QUOTE*/);
|
|
case "#":
|
|
return readSharp();
|
|
case ".":
|
|
return readDot();
|
|
case '"':
|
|
return readString();
|
|
default:
|
|
if (isIdOrNumberChar(curChar))
|
|
return readIdOrNumber(curChar);
|
|
throw "unexpected character: " + curChar;
|
|
}
|
|
};
|
|
|
|
function sc_Reader(tokenizer) {
|
|
this.tokenizer = tokenizer;
|
|
this.backref = new Array();
|
|
}
|
|
sc_Reader.prototype.read = function() {
|
|
function readList(listBeginType) {
|
|
function matchesPeer(open, close) {
|
|
return open === 1/*OPEN_PAR*/ && close === 2/*CLOSE_PAR*/
|
|
|| open === 3/*OPEN_BRACE*/ && close === 4/*CLOSE_BRACE*/
|
|
|| open === 5/*OPEN_BRACKET*/ && close === 6/*CLOSE_BRACKET*/;
|
|
};
|
|
var res = null;
|
|
|
|
while (true) {
|
|
var token = tokenizer.peekToken();
|
|
|
|
switch (token.type) {
|
|
case 2/*CLOSE_PAR*/:
|
|
case 4/*CLOSE_BRACE*/:
|
|
case 6/*CLOSE_BRACKET*/:
|
|
if (matchesPeer(listBeginType, token.type)) {
|
|
tokenizer.readToken(); // consume token
|
|
return sc_reverseBang(res);
|
|
} else
|
|
throw "closing par doesn't match: " + listBeginType
|
|
+ " " + listEndType;
|
|
|
|
case 0/*EOF*/:
|
|
throw "unexpected end of file";
|
|
|
|
case 10/*DOT*/:
|
|
tokenizer.readToken(); // consume token
|
|
var cdr = this.read();
|
|
var par = tokenizer.readToken();
|
|
if (!matchesPeer(listBeginType, par.type))
|
|
throw "closing par doesn't match: " + listBeginType
|
|
+ " " + par.type;
|
|
else
|
|
return sc_reverseAppendBang(res, cdr);
|
|
|
|
|
|
default:
|
|
res = sc_cons(this.read(), res);
|
|
}
|
|
}
|
|
};
|
|
function readQuote() {
|
|
return sc_cons("quote", sc_cons(this.read(), null));
|
|
};
|
|
function readVector() {
|
|
// opening-parenthesis is already consumed
|
|
var a = new Array();
|
|
while (true) {
|
|
var token = tokenizer.peekToken();
|
|
switch (token.type) {
|
|
case 2/*CLOSE_PAR*/:
|
|
tokenizer.readToken();
|
|
return a;
|
|
|
|
default:
|
|
a.push(this.read());
|
|
}
|
|
}
|
|
};
|
|
|
|
function storeRefence(nb) {
|
|
var tmp = this.read();
|
|
this.backref[nb] = tmp;
|
|
return tmp;
|
|
};
|
|
|
|
function readReference(nb) {
|
|
if (nb in this.backref)
|
|
return this.backref[nb];
|
|
else
|
|
throw "bad reference: " + nb;
|
|
};
|
|
|
|
var tokenizer = this.tokenizer;
|
|
|
|
var token = tokenizer.readToken();
|
|
|
|
// handle error
|
|
if (token.type === 13/*ERROR*/)
|
|
throw token.val;
|
|
|
|
switch (token.type) {
|
|
case 1/*OPEN_PAR*/:
|
|
case 3/*OPEN_BRACE*/:
|
|
case 5/*OPEN_BRACKET*/:
|
|
return readList.call(this, token.type);
|
|
case 8/*QUOTE*/:
|
|
return readQuote.call(this);
|
|
case 11/*STRING*/:
|
|
return sc_jsstring2string(token.val);
|
|
case 20/*CHAR*/:
|
|
return new sc_Char(token.val);
|
|
case 14/*VECTOR_BEGIN*/:
|
|
return readVector.call(this);
|
|
case 18/*REFERENCE*/:
|
|
return readReference.call(this, token.val);
|
|
case 19/*STORE*/:
|
|
return storeRefence.call(this, token.val);
|
|
case 9/*ID*/:
|
|
return sc_jsstring2symbol(token.val);
|
|
case 0/*EOF*/:
|
|
case 12/*NUMBER*/:
|
|
case 15/*TRUE*/:
|
|
case 16/*FALSE*/:
|
|
case 17/*UNSPECIFIED*/:
|
|
return token.val;
|
|
default:
|
|
throw "unexpected token " + token.type + " " + token.val;
|
|
}
|
|
};
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_read(port) {
|
|
if (port === undefined) // we assume the port hasn't been given.
|
|
port = SC_DEFAULT_IN; // THREAD: shared var...
|
|
var reader = new sc_Reader(new sc_Tokenizer(port));
|
|
return reader.read();
|
|
}
|
|
/*** META ((export #t)) */
|
|
function sc_readChar(port) {
|
|
if (port === undefined) // we assume the port hasn't been given.
|
|
port = SC_DEFAULT_IN; // THREAD: shared var...
|
|
var t = port.readChar();
|
|
return t === SC_EOF_OBJECT? t: new sc_Char(t);
|
|
}
|
|
/*** META ((export #t)) */
|
|
function sc_peekChar(port) {
|
|
if (port === undefined) // we assume the port hasn't been given.
|
|
port = SC_DEFAULT_IN; // THREAD: shared var...
|
|
var t = port.peekChar();
|
|
return t === SC_EOF_OBJECT? t: new sc_Char(t);
|
|
}
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isCharReady(port) {
|
|
if (port === undefined) // we assume the port hasn't been given.
|
|
port = SC_DEFAULT_IN; // THREAD: shared var...
|
|
return port.isCharReady();
|
|
}
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".close()")))
|
|
*/
|
|
function sc_closeInputPort(p) {
|
|
return p.close();
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix " instanceof sc_InputPort")))
|
|
*/
|
|
function sc_isInputPort(o) {
|
|
return (o instanceof sc_InputPort);
|
|
}
|
|
|
|
/*** META ((export eof-object?)
|
|
(type bool)
|
|
(peephole (postfix " === SC_EOF_OBJECT")))
|
|
*/
|
|
function sc_isEOFObject(o) {
|
|
return o === SC_EOF_OBJECT;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 0 "SC_DEFAULT_IN")))
|
|
*/
|
|
function sc_currentInputPort() {
|
|
return SC_DEFAULT_IN;
|
|
}
|
|
|
|
/* ------------ file operations are not supported -----------*/
|
|
/*** META ((export #t)) */
|
|
function sc_callWithInputFile(s, proc) {
|
|
throw "can't open " + s;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_callWithOutputFile(s, proc) {
|
|
throw "can't open " + s;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_withInputFromFile(s, thunk) {
|
|
throw "can't open " + s;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_withOutputToFile(s, thunk) {
|
|
throw "can't open " + s;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_openInputFile(s) {
|
|
throw "can't open " + s;
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_openOutputFile(s) {
|
|
throw "can't open " + s;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------*/
|
|
/*** META ((export #t)) */
|
|
function sc_basename(p) {
|
|
var i = p.lastIndexOf('/');
|
|
|
|
if(i >= 0)
|
|
return p.substring(i + 1, p.length);
|
|
else
|
|
return '';
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_dirname(p) {
|
|
var i = p.lastIndexOf('/');
|
|
|
|
if(i >= 0)
|
|
return p.substring(0, i);
|
|
else
|
|
return '';
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------*/
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_withInputFromPort(p, thunk) {
|
|
try {
|
|
var tmp = SC_DEFAULT_IN; // THREAD: shared var.
|
|
SC_DEFAULT_IN = p;
|
|
return thunk();
|
|
} finally {
|
|
SC_DEFAULT_IN = tmp;
|
|
}
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_withInputFromString(s, thunk) {
|
|
return sc_withInputFromPort(new sc_StringInputPort(sc_string2jsstring(s)), thunk);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_withOutputToPort(p, thunk) {
|
|
try {
|
|
var tmp = SC_DEFAULT_OUT; // THREAD: shared var.
|
|
SC_DEFAULT_OUT = p;
|
|
return thunk();
|
|
} finally {
|
|
SC_DEFAULT_OUT = tmp;
|
|
}
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_withOutputToString(thunk) {
|
|
var p = new sc_StringOutputPort();
|
|
sc_withOutputToPort(p, thunk);
|
|
return p.close();
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_withOutputToProcedure(proc, thunk) {
|
|
var t = function(s) { proc(sc_jsstring2string(s)); };
|
|
return sc_withOutputToPort(new sc_GenericOutputPort(t), thunk);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 0 "new sc_StringOutputPort()")))
|
|
*/
|
|
function sc_openOutputString() {
|
|
return new sc_StringOutputPort();
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_openInputString(str) {
|
|
return new sc_StringInputPort(sc_string2jsstring(str));
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------------*/
|
|
|
|
function sc_OutputPort() {
|
|
}
|
|
sc_OutputPort.prototype = new sc_Port();
|
|
sc_OutputPort.prototype.appendJSString = function(obj) {
|
|
/* do nothing */
|
|
}
|
|
sc_OutputPort.prototype.close = function() {
|
|
/* do nothing */
|
|
}
|
|
|
|
function sc_StringOutputPort() {
|
|
this.res = "";
|
|
}
|
|
sc_StringOutputPort.prototype = new sc_OutputPort();
|
|
sc_StringOutputPort.prototype.appendJSString = function(s) {
|
|
this.res += s;
|
|
}
|
|
sc_StringOutputPort.prototype.close = function() {
|
|
return sc_jsstring2string(this.res);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_getOutputString(sp) {
|
|
return sc_jsstring2string(sp.res);
|
|
}
|
|
|
|
|
|
function sc_ErrorOutputPort() {
|
|
}
|
|
sc_ErrorOutputPort.prototype = new sc_OutputPort();
|
|
sc_ErrorOutputPort.prototype.appendJSString = function(s) {
|
|
throw "don't write on ErrorPort!";
|
|
}
|
|
sc_ErrorOutputPort.prototype.close = function() {
|
|
/* do nothing */
|
|
}
|
|
|
|
function sc_GenericOutputPort(appendJSString, close) {
|
|
this.appendJSString = appendJSString;
|
|
if (close)
|
|
this.close = close;
|
|
}
|
|
sc_GenericOutputPort.prototype = new sc_OutputPort();
|
|
|
|
/*** META ((export #t)
|
|
(type bool)
|
|
(peephole (postfix " instanceof sc_OutputPort")))
|
|
*/
|
|
function sc_isOutputPort(o) {
|
|
return (o instanceof sc_OutputPort);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".close()")))
|
|
*/
|
|
function sc_closeOutputPort(p) {
|
|
return p.close();
|
|
}
|
|
|
|
/* ------------------ write ---------------------------------------------------*/
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_write(o, p) {
|
|
if (p === undefined) // we assume not given
|
|
p = SC_DEFAULT_OUT;
|
|
p.appendJSString(sc_toWriteString(o));
|
|
}
|
|
|
|
function sc_toWriteString(o) {
|
|
if (o === null)
|
|
return "()";
|
|
else if (o === true)
|
|
return "#t";
|
|
else if (o === false)
|
|
return "#f";
|
|
else if (o === undefined)
|
|
return "#unspecified";
|
|
else if (typeof o === 'function')
|
|
return "#<procedure " + sc_hash(o) + ">";
|
|
else if (o.sc_toWriteString)
|
|
return o.sc_toWriteString();
|
|
else
|
|
return o.toString();
|
|
}
|
|
|
|
function sc_escapeWriteString(s) {
|
|
var res = "";
|
|
var j = 0;
|
|
for (i = 0; i < s.length; i++) {
|
|
switch (s.charAt(i)) {
|
|
case "\0": res += s.substring(j, i) + "\\0"; j = i + 1; break;
|
|
case "\b": res += s.substring(j, i) + "\\b"; j = i + 1; break;
|
|
case "\f": res += s.substring(j, i) + "\\f"; j = i + 1; break;
|
|
case "\n": res += s.substring(j, i) + "\\n"; j = i + 1; break;
|
|
case "\r": res += s.substring(j, i) + "\\r"; j = i + 1; break;
|
|
case "\t": res += s.substring(j, i) + "\\t"; j = i + 1; break;
|
|
case "\v": res += s.substring(j, i) + "\\v"; j = i + 1; break;
|
|
case '"': res += s.substring(j, i) + '\\"'; j = i + 1; break;
|
|
case "\\": res += s.substring(j, i) + "\\\\"; j = i + 1; break;
|
|
default:
|
|
var c = s.charAt(i);
|
|
if ("\a" !== "a" && c == "\a") {
|
|
res += s.substring(j, i) + "\\a"; j = i + 1; continue;
|
|
}
|
|
if ("\v" !== "v" && c == "\v") {
|
|
res += s.substring(j, i) + "\\v"; j = i + 1; continue;
|
|
}
|
|
//if (s.charAt(i) < ' ' || s.charCodeAt(i) > 127) {
|
|
// CARE: Manuel is this OK with HOP?
|
|
if (s.charAt(i) < ' ') {
|
|
/* non printable character and special chars */
|
|
res += s.substring(j, i) + "\\x" + s.charCodeAt(i).toString(16);
|
|
j = i + 1;
|
|
}
|
|
// else just let i increase...
|
|
}
|
|
}
|
|
res += s.substring(j, i);
|
|
return res;
|
|
}
|
|
|
|
/* ------------------ display ---------------------------------------------------*/
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_display(o, p) {
|
|
if (p === undefined) // we assume not given
|
|
p = SC_DEFAULT_OUT;
|
|
p.appendJSString(sc_toDisplayString(o));
|
|
}
|
|
|
|
function sc_toDisplayString(o) {
|
|
if (o === null)
|
|
return "()";
|
|
else if (o === true)
|
|
return "#t";
|
|
else if (o === false)
|
|
return "#f";
|
|
else if (o === undefined)
|
|
return "#unspecified";
|
|
else if (typeof o === 'function')
|
|
return "#<procedure " + sc_hash(o) + ">";
|
|
else if (o.sc_toDisplayString)
|
|
return o.sc_toDisplayString();
|
|
else
|
|
return o.toString();
|
|
}
|
|
|
|
/* ------------------ newline ---------------------------------------------------*/
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_newline(p) {
|
|
if (p === undefined) // we assume not given
|
|
p = SC_DEFAULT_OUT;
|
|
p.appendJSString("\n");
|
|
}
|
|
|
|
/* ------------------ write-char ---------------------------------------------------*/
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_writeChar(c, p) {
|
|
if (p === undefined) // we assume not given
|
|
p = SC_DEFAULT_OUT;
|
|
p.appendJSString(c.val);
|
|
}
|
|
|
|
/* ------------------ write-circle ---------------------------------------------------*/
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_writeCircle(o, p) {
|
|
if (p === undefined) // we assume not given
|
|
p = SC_DEFAULT_OUT;
|
|
p.appendJSString(sc_toWriteCircleString(o));
|
|
}
|
|
|
|
function sc_toWriteCircleString(o) {
|
|
var symb = sc_gensym("writeCircle");
|
|
var nbPointer = new Object();
|
|
nbPointer.nb = 0;
|
|
sc_prepWriteCircle(o, symb, nbPointer);
|
|
return sc_genToWriteCircleString(o, symb);
|
|
}
|
|
|
|
function sc_prepWriteCircle(o, symb, nbPointer) {
|
|
// TODO sc_Struct
|
|
if (o instanceof sc_Pair ||
|
|
o instanceof sc_Vector) {
|
|
if (o[symb] !== undefined) {
|
|
// not the first visit.
|
|
o[symb]++;
|
|
// unless there is already a number, assign one.
|
|
if (!o[symb + "nb"]) o[symb + "nb"] = nbPointer.nb++;
|
|
return;
|
|
}
|
|
o[symb] = 0;
|
|
if (o instanceof sc_Pair) {
|
|
sc_prepWriteCircle(o.car, symb, nbPointer);
|
|
sc_prepWriteCircle(o.cdr, symb, nbPointer);
|
|
} else {
|
|
for (var i = 0; i < o.length; i++)
|
|
sc_prepWriteCircle(o[i], symb, nbPointer);
|
|
}
|
|
}
|
|
}
|
|
|
|
function sc_genToWriteCircleString(o, symb) {
|
|
if (!(o instanceof sc_Pair ||
|
|
o instanceof sc_Vector))
|
|
return sc_toWriteString(o);
|
|
return o.sc_toWriteCircleString(symb);
|
|
}
|
|
sc_Pair.prototype.sc_toWriteCircleString = function(symb, inList) {
|
|
if (this[symb + "use"]) { // use-flag is set. Just use it.
|
|
var nb = this[symb + "nb"];
|
|
if (this[symb]-- === 0) { // if we are the last use. remove all fields.
|
|
delete this[symb];
|
|
delete this[symb + "nb"];
|
|
delete this[symb + "use"];
|
|
}
|
|
if (inList)
|
|
return '. #' + nb + '#';
|
|
else
|
|
return '#' + nb + '#';
|
|
}
|
|
if (this[symb]-- === 0) { // if we are the last use. remove all fields.
|
|
delete this[symb];
|
|
delete this[symb + "nb"];
|
|
delete this[symb + "use"];
|
|
}
|
|
|
|
var res = "";
|
|
|
|
if (this[symb] !== undefined) { // implies > 0
|
|
this[symb + "use"] = true;
|
|
if (inList)
|
|
res += '. #' + this[symb + "nb"] + '=';
|
|
else
|
|
res += '#' + this[symb + "nb"] + '=';
|
|
inList = false;
|
|
}
|
|
|
|
if (!inList)
|
|
res += "(";
|
|
|
|
// print car
|
|
res += sc_genToWriteCircleString(this.car, symb);
|
|
|
|
if (sc_isPair(this.cdr)) {
|
|
res += " " + this.cdr.sc_toWriteCircleString(symb, true);
|
|
} else if (this.cdr !== null) {
|
|
res += " . " + sc_genToWriteCircleString(this.cdr, symb);
|
|
}
|
|
if (!inList)
|
|
res += ")";
|
|
return res;
|
|
};
|
|
sc_Vector.prototype.sc_toWriteCircleString = function(symb) {
|
|
if (this[symb + "use"]) { // use-flag is set. Just use it.
|
|
var nb = this[symb + "nb"];
|
|
if (this[symb]-- === 0) { // if we are the last use. remove all fields.
|
|
delete this[symb];
|
|
delete this[symb + "nb"];
|
|
delete this[symb + "use"];
|
|
}
|
|
return '#' + nb + '#';
|
|
}
|
|
if (this[symb]-- === 0) { // if we are the last use. remove all fields.
|
|
delete this[symb];
|
|
delete this[symb + "nb"];
|
|
delete this[symb + "use"];
|
|
}
|
|
|
|
var res = "";
|
|
if (this[symb] !== undefined) { // implies > 0
|
|
this[symb + "use"] = true;
|
|
res += '#' + this[symb + "nb"] + '=';
|
|
}
|
|
res += "#(";
|
|
for (var i = 0; i < this.length; i++) {
|
|
res += sc_genToWriteCircleString(this[i], symb);
|
|
if (i < this.length - 1) res += " ";
|
|
}
|
|
res += ")";
|
|
return res;
|
|
};
|
|
|
|
|
|
/* ------------------ print ---------------------------------------------------*/
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_print(s) {
|
|
if (arguments.length === 1) {
|
|
sc_display(s);
|
|
sc_newline();
|
|
}
|
|
else {
|
|
for (var i = 0; i < arguments.length; i++)
|
|
sc_display(arguments[i]);
|
|
sc_newline();
|
|
}
|
|
}
|
|
|
|
/* ------------------ format ---------------------------------------------------*/
|
|
/*** META ((export #t)) */
|
|
function sc_format(s, args) {
|
|
var len = s.length;
|
|
var p = new sc_StringOutputPort();
|
|
var i = 0, j = 1;
|
|
|
|
while( i < len ) {
|
|
var i2 = s.indexOf("~", i);
|
|
|
|
if (i2 == -1) {
|
|
p.appendJSString( s.substring( i, len ) );
|
|
return p.close();
|
|
} else {
|
|
if (i2 > i) {
|
|
if (i2 == (len - 1)) {
|
|
p.appendJSString(s.substring(i, len));
|
|
return p.close();
|
|
} else {
|
|
p.appendJSString(s.substring(i, i2));
|
|
i = i2;
|
|
}
|
|
}
|
|
|
|
switch(s.charCodeAt(i2 + 1)) {
|
|
case 65:
|
|
case 97:
|
|
// a
|
|
sc_display(arguments[j], p);
|
|
i += 2; j++;
|
|
break;
|
|
|
|
case 83:
|
|
case 115:
|
|
// s
|
|
sc_write(arguments[j], p);
|
|
i += 2; j++;
|
|
break;
|
|
|
|
case 86:
|
|
case 118:
|
|
// v
|
|
sc_display(arguments[j], p);
|
|
p.appendJSString("\n");
|
|
i += 2; j++;
|
|
break;
|
|
|
|
case 67:
|
|
case 99:
|
|
// c
|
|
p.appendJSString(String.fromCharCode(arguments[j]));
|
|
i += 2; j++;
|
|
break;
|
|
|
|
case 88:
|
|
case 120:
|
|
// x
|
|
p.appendJSString(arguments[j].toString(6));
|
|
i += 2; j++;
|
|
break;
|
|
|
|
case 79:
|
|
case 111:
|
|
// o
|
|
p.appendJSString(arguments[j].toString(8));
|
|
i += 2; j++;
|
|
break;
|
|
|
|
case 66:
|
|
case 98:
|
|
// b
|
|
p.appendJSString(arguments[j].toString(2));
|
|
i += 2; j++;
|
|
break;
|
|
|
|
case 37:
|
|
case 110:
|
|
// %, n
|
|
p.appendJSString("\n");
|
|
i += 2; break;
|
|
|
|
case 114:
|
|
// r
|
|
p.appendJSString("\r");
|
|
i += 2; break;
|
|
|
|
case 126:
|
|
// ~
|
|
p.appendJSString("~");
|
|
i += 2; break;
|
|
|
|
default:
|
|
sc_error( "format: illegal ~"
|
|
+ String.fromCharCode(s.charCodeAt(i2 + 1))
|
|
+ " sequence" );
|
|
return "";
|
|
}
|
|
}
|
|
}
|
|
|
|
return p.close();
|
|
}
|
|
|
|
/* ------------------ global ports ---------------------------------------------------*/
|
|
|
|
var SC_DEFAULT_IN = new sc_ErrorInputPort();
|
|
var SC_DEFAULT_OUT = new sc_ErrorOutputPort();
|
|
var SC_ERROR_OUT = new sc_ErrorOutputPort();
|
|
|
|
var sc_SYMBOL_PREFIX = "\u1E9C";
|
|
var sc_KEYWORD_PREFIX = "\u1E9D";
|
|
|
|
/*** META ((export #t)
|
|
(peephole (id))) */
|
|
function sc_jsstring2string(s) {
|
|
return s;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "'\\u1E9C' +")))
|
|
*/
|
|
function sc_jsstring2symbol(s) {
|
|
return sc_SYMBOL_PREFIX + s;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (id)))
|
|
*/
|
|
function sc_string2jsstring(s) {
|
|
return s;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (symbol2jsstring_immutable)))
|
|
*/
|
|
function sc_symbol2jsstring(s) {
|
|
return s.slice(1);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".slice(1)")))
|
|
*/
|
|
function sc_keyword2jsstring(k) {
|
|
return k.slice(1);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "'\\u1E9D' +")))
|
|
*/
|
|
function sc_jsstring2keyword(s) {
|
|
return sc_KEYWORD_PREFIX + s;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isKeyword(s) {
|
|
return (typeof s === "string") &&
|
|
(s.charAt(0) === sc_KEYWORD_PREFIX);
|
|
}
|
|
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_gensym = function() {
|
|
var counter = 1000;
|
|
return function(sym) {
|
|
counter++;
|
|
if (!sym) sym = sc_SYMBOL_PREFIX;
|
|
return sym + "s" + counter + "~" + "^sC-GeNsYm ";
|
|
};
|
|
}();
|
|
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isEqual(o1, o2) {
|
|
return ((o1 === o2) ||
|
|
(sc_isPair(o1) && sc_isPair(o2)
|
|
&& sc_isPairEqual(o1, o2, sc_isEqual)) ||
|
|
(sc_isVector(o1) && sc_isVector(o2)
|
|
&& sc_isVectorEqual(o1, o2, sc_isEqual)));
|
|
}
|
|
|
|
/*** META ((export number->symbol integer->symbol)) */
|
|
function sc_number2symbol(x, radix) {
|
|
return sc_SYMBOL_PREFIX + sc_number2jsstring(x, radix);
|
|
}
|
|
|
|
/*** META ((export number->string integer->string)) */
|
|
var sc_number2string = sc_number2jsstring;
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_symbol2number(s, radix) {
|
|
return sc_jsstring2number(s.slice(1), radix);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_string2number = sc_jsstring2number;
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "+" s)))
|
|
;; peephole will only apply if no radix is given.
|
|
*/
|
|
function sc_string2integer(s, radix) {
|
|
if (!radix) return +s;
|
|
return parseInt(s, radix);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "+")))
|
|
*/
|
|
function sc_string2real(s) {
|
|
return +s;
|
|
}
|
|
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isSymbol(s) {
|
|
return (typeof s === "string") &&
|
|
(s.charAt(0) === sc_SYMBOL_PREFIX);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (symbol2string_immutable)))
|
|
*/
|
|
function sc_symbol2string(s) {
|
|
return s.slice(1);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "'\\u1E9C' +")))
|
|
*/
|
|
function sc_string2symbol(s) {
|
|
return sc_SYMBOL_PREFIX + s;
|
|
}
|
|
|
|
/*** META ((export symbol-append)
|
|
(peephole (symbolAppend_immutable)))
|
|
*/
|
|
function sc_symbolAppend() {
|
|
var res = sc_SYMBOL_PREFIX;
|
|
for (var i = 0; i < arguments.length; i++)
|
|
res += arguments[i].slice(1);
|
|
return res;
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".val")))
|
|
*/
|
|
function sc_char2string(c) { return c.val; }
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 1 "'\\u1E9C' + " c ".val")))
|
|
*/
|
|
function sc_char2symbol(c) { return sc_SYMBOL_PREFIX + c.val; }
|
|
|
|
/*** META ((export #t)
|
|
(type bool))
|
|
*/
|
|
function sc_isString(s) {
|
|
return (typeof s === "string") &&
|
|
(s.charAt(0) !== sc_SYMBOL_PREFIX);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_makeString = sc_makejsString;
|
|
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_string() {
|
|
for (var i = 0; i < arguments.length; i++)
|
|
arguments[i] = arguments[i].val;
|
|
return "".concat.apply("", arguments);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".length")))
|
|
*/
|
|
function sc_stringLength(s) { return s.length; }
|
|
|
|
/*** META ((export #t)) */
|
|
function sc_stringRef(s, k) {
|
|
return new sc_Char(s.charAt(k));
|
|
}
|
|
|
|
/* there's no stringSet in the immutable version
|
|
function sc_stringSet(s, k, c)
|
|
*/
|
|
|
|
|
|
/*** META ((export string=?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 " === " str2)))
|
|
*/
|
|
function sc_isStringEqual(s1, s2) {
|
|
return s1 === s2;
|
|
}
|
|
/*** META ((export string<?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 " < " str2)))
|
|
*/
|
|
function sc_isStringLess(s1, s2) {
|
|
return s1 < s2;
|
|
}
|
|
/*** META ((export string>?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 " > " str2)))
|
|
*/
|
|
function sc_isStringGreater(s1, s2) {
|
|
return s1 > s2;
|
|
}
|
|
/*** META ((export string<=?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 " <= " str2)))
|
|
*/
|
|
function sc_isStringLessEqual(s1, s2) {
|
|
return s1 <= s2;
|
|
}
|
|
/*** META ((export string>=?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 " >= " str2)))
|
|
*/
|
|
function sc_isStringGreaterEqual(s1, s2) {
|
|
return s1 >= s2;
|
|
}
|
|
/*** META ((export string-ci=?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 ".toLowerCase() === " str2 ".toLowerCase()")))
|
|
*/
|
|
function sc_isStringCIEqual(s1, s2) {
|
|
return s1.toLowerCase() === s2.toLowerCase();
|
|
}
|
|
/*** META ((export string-ci<?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 ".toLowerCase() < " str2 ".toLowerCase()")))
|
|
*/
|
|
function sc_isStringCILess(s1, s2) {
|
|
return s1.toLowerCase() < s2.toLowerCase();
|
|
}
|
|
/*** META ((export string-ci>?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 ".toLowerCase() > " str2 ".toLowerCase()")))
|
|
*/
|
|
function sc_isStringCIGreater(s1, s2) {
|
|
return s1.toLowerCase() > s2.toLowerCase();
|
|
}
|
|
/*** META ((export string-ci<=?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 ".toLowerCase() <= " str2 ".toLowerCase()")))
|
|
*/
|
|
function sc_isStringCILessEqual(s1, s2) {
|
|
return s1.toLowerCase() <= s2.toLowerCase();
|
|
}
|
|
/*** META ((export string-ci>=?)
|
|
(type bool)
|
|
(peephole (hole 2 str1 ".toLowerCase() >= " str2 ".toLowerCase()")))
|
|
*/
|
|
function sc_isStringCIGreaterEqual(s1, s2) {
|
|
return s1.toLowerCase() >= s2.toLowerCase();
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (hole 3 s ".substring(" start ", " end ")")))
|
|
*/
|
|
function sc_substring(s, start, end) {
|
|
return s.substring(start, end);
|
|
}
|
|
|
|
/*** META ((export #t))
|
|
*/
|
|
function sc_isSubstring_at(s1, s2, i) {
|
|
return s2 == s1.substring(i, i+ s2.length);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (infix 0 #f "+" "''")))
|
|
*/
|
|
function sc_stringAppend() {
|
|
return "".concat.apply("", arguments);
|
|
}
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_string2list = sc_jsstring2list;
|
|
|
|
/*** META ((export #t)) */
|
|
var sc_list2string = sc_list2jsstring;
|
|
|
|
/*** META ((export #t)
|
|
(peephole (id)))
|
|
*/
|
|
function sc_stringCopy(s) {
|
|
return s;
|
|
}
|
|
|
|
/* there's no string-fill in the immutable version
|
|
function sc_stringFill(s, c)
|
|
*/
|
|
|
|
/*** META ((export #t)
|
|
(peephole (postfix ".slice(1)")))
|
|
*/
|
|
function sc_keyword2string(o) {
|
|
return o.slice(1);
|
|
}
|
|
|
|
/*** META ((export #t)
|
|
(peephole (prefix "'\\u1E9D' +")))
|
|
*/
|
|
function sc_string2keyword(o) {
|
|
return sc_KEYWORD_PREFIX + o;
|
|
}
|
|
|
|
String.prototype.sc_toDisplayString = function() {
|
|
if (this.charAt(0) === sc_SYMBOL_PREFIX)
|
|
// TODO: care for symbols with spaces (escape-chars symbols).
|
|
return this.slice(1);
|
|
else if (this.charAt(0) === sc_KEYWORD_PREFIX)
|
|
return ":" + this.slice(1);
|
|
else
|
|
return this.toString();
|
|
};
|
|
|
|
String.prototype.sc_toWriteString = function() {
|
|
if (this.charAt(0) === sc_SYMBOL_PREFIX)
|
|
// TODO: care for symbols with spaces (escape-chars symbols).
|
|
return this.slice(1);
|
|
else if (this.charAt(0) === sc_KEYWORD_PREFIX)
|
|
return ":" + this.slice(1);
|
|
else
|
|
return '"' + sc_escapeWriteString(this) + '"';
|
|
};
|
|
/* Exported Variables */
|
|
var BgL_testzd2boyerzd2;
|
|
var BgL_nboyerzd2benchmarkzd2;
|
|
var BgL_setupzd2boyerzd2;
|
|
/* End Exports */
|
|
|
|
var translate_term_nboyer;
|
|
var translate_args_nboyer;
|
|
var untranslate_term_nboyer;
|
|
var BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer;
|
|
var BgL_sc_za2symbolzd2recordszd2alistza2_2z00_nboyer;
|
|
var translate_alist_nboyer;
|
|
var apply_subst_nboyer;
|
|
var apply_subst_lst_nboyer;
|
|
var tautologyp_nboyer;
|
|
var if_constructor_nboyer;
|
|
var rewrite_count_nboyer;
|
|
var rewrite_nboyer;
|
|
var rewrite_args_nboyer;
|
|
var unify_subst_nboyer;
|
|
var one_way_unify1_nboyer;
|
|
var false_term_nboyer;
|
|
var true_term_nboyer;
|
|
var trans_of_implies1_nboyer;
|
|
var is_term_equal_nboyer;
|
|
var is_term_member_nboyer;
|
|
var const_nboyer;
|
|
var sc_const_3_nboyer;
|
|
var sc_const_4_nboyer;
|
|
{
|
|
(sc_const_4_nboyer = (new sc_Pair("\u1E9Cimplies",(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cz",(new sc_Pair("\u1E9Cu",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cu",(new sc_Pair("\u1E9Cw",null)))))),null)))))),null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cw",null)))))),null)))))));
|
|
(sc_const_3_nboyer = sc_list((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ccompile",(new sc_Pair("\u1E9Cform",null)))),(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair((new sc_Pair("\u1E9Ccodegen",(new sc_Pair((new sc_Pair("\u1E9Coptimize",(new sc_Pair("\u1E9Cform",null)))),(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ceqp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cy",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cgreaterp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clesseqp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cgreatereqp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cboolean",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Ct",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cf",null)),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ciff",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ceven1",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Ct",null)),(new sc_Pair((new sc_Pair("\u1E9Codd",(new sc_Pair((new sc_Pair("\u1E9Csub1",(new sc_Pair("\u1E9Cx",null)))),null)))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ccountps-",(new sc_Pair("\u1E9Cl",(new sc_Pair("\u1E9Cpred",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ccountps-loop",(new sc_Pair("\u1E9Cl",(new sc_Pair("\u1E9Cpred",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cfact-",(new sc_Pair("\u1E9Ci",null)))),(new sc_Pair((new sc_Pair("\u1E9Cfact-loop",(new sc_Pair("\u1E9Ci",(new sc_Pair((1),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Creverse-",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Creverse-loop",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdivides",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cassume-true",(new sc_Pair("\u1E9Cvar",(new sc_Pair("\u1E9Calist",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cvar",(new sc_Pair((new sc_Pair("\u1E9Ct",null)),null)))))),(new sc_Pair("\u1E9Calist",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cassume-false",(new sc_Pair("\u1E9Cvar",(new sc_Pair("\u1E9Calist",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cvar",(new sc_Pair((new sc_Pair("\u1E9Cf",null)),null)))))),(new sc_Pair("\u1E9Calist",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctautology-checker",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Ctautologyp",(new sc_Pair((new sc_Pair("\u1E9Cnormalize",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cfalsify",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cfalsify1",(new sc_Pair((new sc_Pair("\u1E9Cnormalize",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cprime",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))),null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cprime1",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Csub1",(new sc_Pair("\u1E9Cx",null)))),null)))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair("\u1E9Cp",(new sc_Pair("\u1E9Cq",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cp",(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cq",(new sc_Pair((new sc_Pair("\u1E9Ct",null)),(new sc_Pair((new sc_Pair("\u1E9Cf",null)),null)))))))),(new sc_Pair((new sc_Pair("\u1E9Cf",null)),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair("\u1E9Cp",(new sc_Pair("\u1E9Cq",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cp",(new sc_Pair((new sc_Pair("\u1E9Ct",null)),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cq",(new sc_Pair((new sc_Pair("\u1E9Ct",null)),(new sc_Pair((new sc_Pair("\u1E9Cf",null)),null)))))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair("\u1E9Cp",null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cp",(new sc_Pair((new sc_Pair("\u1E9Cf",null)),(new sc_Pair((new sc_Pair("\u1E9Ct",null)),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cimplies",(new sc_Pair("\u1E9Cp",(new sc_Pair("\u1E9Cq",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cp",(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cq",(new sc_Pair((new sc_Pair("\u1E9Ct",null)),(new sc_Pair((new sc_Pair("\u1E9Cf",null)),null)))))))),(new sc_Pair((new sc_Pair("\u1E9Ct",null)),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",(new sc_Pair("\u1E9Cc",null)))))))),(new sc_Pair("\u1E9Cd",(new sc_Pair("\u1E9Ce",null)))))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Ca",(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cb",(new sc_Pair("\u1E9Cd",(new sc_Pair("\u1E9Ce",null)))))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair("\u1E9Cc",(new sc_Pair("\u1E9Cd",(new sc_Pair("\u1E9Ce",null)))))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cx",null)))),null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Ca",null)))),(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cb",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cc",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cb",null)))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cc",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cy",null)))),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair((new sc_Pair("\u1E9Cplus-tree",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair((new sc_Pair("\u1E9Cplus-tree",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair((new sc_Pair("\u1E9Cplus-tree",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair("\u1E9Ca",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair((new sc_Pair("\u1E9Cplus-tree",(new sc_Pair((new sc_Pair("\u1E9Cplus-fringe",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Ca",null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair("\u1E9Cb",null)))),(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair("\u1E9Ca",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cz",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cy",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cexec",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cpds",(new sc_Pair("\u1E9Cenvrn",null)))))))),(new sc_Pair((new sc_Pair("\u1E9Cexec",(new sc_Pair("\u1E9Cy",(new sc_Pair((new sc_Pair("\u1E9Cexec",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cpds",(new sc_Pair("\u1E9Cenvrn",null)))))))),(new sc_Pair("\u1E9Cenvrn",null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cmc-flatten",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair((new sc_Pair("\u1E9Cflatten",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair("\u1E9Cy",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cb",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair("\u1E9Cy",null)))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair("\u1E9Cx",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Ca",(new sc_Pair((new sc_Pair("\u1E9Cintersect",(new sc_Pair("\u1E9Cb",(new sc_Pair("\u1E9Cc",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cc",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cnth",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),(new sc_Pair("\u1E9Ci",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cexp",(new sc_Pair("\u1E9Ci",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cj",(new sc_Pair("\u1E9Ck",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair((new sc_Pair("\u1E9Cexp",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cj",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cexp",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Ck",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cexp",(new sc_Pair("\u1E9Ci",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cj",(new sc_Pair("\u1E9Ck",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cexp",(new sc_Pair((new sc_Pair("\u1E9Cexp",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cj",null)))))),(new sc_Pair("\u1E9Ck",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Creverse-loop",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair("\u1E9Cy",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Creverse-loop",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair("\u1E9Cx",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ccount-list",(new sc_Pair("\u1E9Cz",(new sc_Pair((new sc_Pair("\u1E9Csort-lp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Ccount-list",(new sc_Pair("\u1E9Cz",(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ccount-list",(new sc_Pair("\u1E9Cz",(new sc_Pair("\u1E9Cy",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cc",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cb",(new sc_Pair("\u1E9Cc",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cy",(new sc_Pair((new sc_Pair("\u1E9Cquotient",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cx",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cpower-eval",(new sc_Pair((new sc_Pair("\u1E9Cbig-plus1",(new sc_Pair("\u1E9Cl",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cbase",null)))))))),(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Cpower-eval",(new sc_Pair("\u1E9Cl",(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair("\u1E9Ci",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cpower-eval",(new sc_Pair((new sc_Pair("\u1E9Cbig-plus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cbase",null)))))))))),(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ci",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Cpower-eval",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cpower-eval",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cbase",null)))))),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair("\u1E9Cy",(new sc_Pair((1),null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cy",null)))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair((new sc_Pair("\u1E9Cquotient",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cj",null)))))),(new sc_Pair("\u1E9Ci",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Ci",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cj",null)))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cj",(new sc_Pair((1),null)))))),null)))),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cy",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cpower-eval",(new sc_Pair((new sc_Pair("\u1E9Cpower-rep",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Ci",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cpower-eval",(new sc_Pair((new sc_Pair("\u1E9Cbig-plus",(new sc_Pair((new sc_Pair("\u1E9Cpower-rep",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cpower-rep",(new sc_Pair("\u1E9Cj",(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),(new sc_Pair("\u1E9Cbase",null)))))))))),(new sc_Pair("\u1E9Cbase",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cj",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cgcd",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cgcd",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cnth",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair("\u1E9Ci",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair((new sc_Pair("\u1E9Cnth",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Ci",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnth",(new sc_Pair("\u1E9Cb",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Ci",(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair("\u1E9Ca",null)))),null)))))),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cy",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cy",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cz",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cc",(new sc_Pair("\u1E9Cw",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cc",(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cw",(new sc_Pair("\u1E9Cx",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cb",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cc",null)))))),null)))))),(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cb",(new sc_Pair("\u1E9Cc",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))),(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair("\u1E9Cy",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cz",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cz",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cy",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cx",null)))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cgcd",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cz",(new sc_Pair((new sc_Pair("\u1E9Cgcd",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cvalue",(new sc_Pair((new sc_Pair("\u1E9Cnormalize",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cvalue",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Ca",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cflatten",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cy",(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnlistp",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clistp",(new sc_Pair((new sc_Pair("\u1E9Cgopher",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Clistp",(new sc_Pair("\u1E9Cx",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Csamefringe",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cflatten",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cflatten",(new sc_Pair("\u1E9Cy",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cgreatest-factor",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cy",(new sc_Pair((1),null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cgreatest-factor",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((1),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((1),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair((new sc_Pair("\u1E9Cgreatest-factor",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cy",(new sc_Pair((1),null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cx",null)))),null)))),null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctimes-list",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair((new sc_Pair("\u1E9Ctimes-list",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Ctimes-list",(new sc_Pair("\u1E9Cy",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cprime-list",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cprime-list",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cprime-list",(new sc_Pair("\u1E9Cy",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cz",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cw",(new sc_Pair("\u1E9Cz",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cz",null)))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cz",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cw",(new sc_Pair((1),null)))))),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cgreatereqp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cor",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cand",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cy",(new sc_Pair((1),null)))))),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((1),null)))))),(new sc_Pair(sc_list("\u1E9Cand", (new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Ca",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),null)))), (new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair("\u1E9Cb",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),null)))), (new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Ca",null)))), (new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cb",null)))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Csub1",(new sc_Pair("\u1E9Ca",null)))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Csub1",(new sc_Pair("\u1E9Cb",null)))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair((new sc_Pair("\u1E9Cdelete",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cl",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair("\u1E9Cl",null)))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cl",null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Csort2",(new sc_Pair((new sc_Pair("\u1E9Cdelete",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cl",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cdelete",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Csort2",(new sc_Pair("\u1E9Cl",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdsort",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Csort2",(new sc_Pair("\u1E9Cx",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cx1",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cx2",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cx3",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cx4",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cx5",(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair("\u1E9Cx6",(new sc_Pair("\u1E9Cx7",null)))))),null)))))),null)))))),null)))))),null)))))),null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((6),(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair("\u1E9Cx7",null)))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((2),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cx",null)))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cquotient",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((2),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cquotient",(new sc_Pair("\u1E9Cy",(new sc_Pair((2),null)))))),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Csigma",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),(new sc_Pair("\u1E9Ci",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cquotient",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Ci",(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair("\u1E9Ci",null)))),null)))))),(new sc_Pair((2),null)))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair("\u1E9Cy",null)))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair("\u1E9Cx",null)))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cz",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cz",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cz",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnot",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cz",null)))),null)))))),null)))))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair((new sc_Pair("\u1E9Cplus-tree",(new sc_Pair((new sc_Pair("\u1E9Cdelete",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))),(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair((new sc_Pair("\u1E9Cplus-tree",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Ca",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmeaning",(new sc_Pair((new sc_Pair("\u1E9Cplus-tree",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair("\u1E9Ca",null)))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cadd1",(new sc_Pair("\u1E9Cy",null)))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Cnumberp",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cx",null)))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cnth",(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),(new sc_Pair("\u1E9Ci",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Ci",null)))),(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clast",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Clistp",(new sc_Pair("\u1E9Cb",null)))),(new sc_Pair((new sc_Pair("\u1E9Clast",(new sc_Pair("\u1E9Cb",null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Clistp",(new sc_Pair("\u1E9Ca",null)))),(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair((new sc_Pair("\u1E9Ccar",(new sc_Pair((new sc_Pair("\u1E9Clast",(new sc_Pair("\u1E9Ca",null)))),null)))),(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair("\u1E9Cb",null)))))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Clessp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ct",null)),(new sc_Pair("\u1E9Cz",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cf",null)),(new sc_Pair("\u1E9Cz",null)))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cassignment",(new sc_Pair("\u1E9Cx",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Cassignedp",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cassignment",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Ca",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cassignment",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cb",null)))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Ccar",(new sc_Pair((new sc_Pair("\u1E9Cgopher",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Clistp",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Ccar",(new sc_Pair((new sc_Pair("\u1E9Cflatten",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cflatten",(new sc_Pair((new sc_Pair("\u1E9Ccdr",(new sc_Pair((new sc_Pair("\u1E9Cgopher",(new sc_Pair("\u1E9Cx",null)))),null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Clistp",(new sc_Pair("\u1E9Cx",null)))),(new sc_Pair((new sc_Pair("\u1E9Ccdr",(new sc_Pair((new sc_Pair("\u1E9Cflatten",(new sc_Pair("\u1E9Cx",null)))),null)))),(new sc_Pair((new sc_Pair("\u1E9Ccons",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cquotient",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cx",null)))))),(new sc_Pair("\u1E9Cy",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Czerop",(new sc_Pair("\u1E9Cy",null)))),(new sc_Pair((new sc_Pair("\u1E9Czero",null)),(new sc_Pair((new sc_Pair("\u1E9Cfix",(new sc_Pair("\u1E9Cx",null)))),null)))))))),null)))))), (new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cget",(new sc_Pair("\u1E9Cj",(new sc_Pair((new sc_Pair("\u1E9Cset",(new sc_Pair("\u1E9Ci",(new sc_Pair("\u1E9Cval",(new sc_Pair("\u1E9Cmem",null)))))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cif",(new sc_Pair((new sc_Pair("\u1E9Ceqp",(new sc_Pair("\u1E9Cj",(new sc_Pair("\u1E9Ci",null)))))),(new sc_Pair("\u1E9Cval",(new sc_Pair((new sc_Pair("\u1E9Cget",(new sc_Pair("\u1E9Cj",(new sc_Pair("\u1E9Cmem",null)))))),null)))))))),null))))))));
|
|
(const_nboyer = (new sc_Pair((new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cf",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cc",(new sc_Pair((new sc_Pair("\u1E9Czero",null)),null)))))),null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cy",(new sc_Pair("\u1E9Cf",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair((new sc_Pair("\u1E9Ctimes",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Cc",(new sc_Pair("\u1E9Cd",null)))))),null)))))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cz",(new sc_Pair("\u1E9Cf",(new sc_Pair((new sc_Pair("\u1E9Creverse",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair((new sc_Pair("\u1E9Cappend",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cnil",null)),null)))))),null)))),null)))))),(new sc_Pair((new sc_Pair("\u1E9Cu",(new sc_Pair("\u1E9Cequal",(new sc_Pair((new sc_Pair("\u1E9Cplus",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cdifference",(new sc_Pair("\u1E9Cx",(new sc_Pair("\u1E9Cy",null)))))),null)))))))),(new sc_Pair((new sc_Pair("\u1E9Cw",(new sc_Pair("\u1E9Clessp",(new sc_Pair((new sc_Pair("\u1E9Cremainder",(new sc_Pair("\u1E9Ca",(new sc_Pair("\u1E9Cb",null)))))),(new sc_Pair((new sc_Pair("\u1E9Cmember",(new sc_Pair("\u1E9Ca",(new sc_Pair((new sc_Pair("\u1E9Clength",(new sc_Pair("\u1E9Cb",null)))),null)))))),null)))))))),null)))))))))));
|
|
BgL_nboyerzd2benchmarkzd2 = function() {
|
|
var args = null;
|
|
for (var sc_tmp = arguments.length - 1; sc_tmp >= 0; sc_tmp--) {
|
|
args = sc_cons(arguments[sc_tmp], args);
|
|
}
|
|
var n;
|
|
return ((n = ((args === null)?(0):(args.car))), (BgL_setupzd2boyerzd2()), (BgL_runzd2benchmarkzd2(("nboyer"+(sc_number2string(n))), (1), function() {
|
|
return (BgL_testzd2boyerzd2(n));
|
|
}, function(rewrites) {
|
|
if ((sc_isNumber(rewrites)))
|
|
switch (n) {
|
|
case (0):
|
|
return (rewrites===(95024));
|
|
break;
|
|
case (1):
|
|
return (rewrites===(591777));
|
|
break;
|
|
case (2):
|
|
return (rewrites===(1813975));
|
|
break;
|
|
case (3):
|
|
return (rewrites===(5375678));
|
|
break;
|
|
case (4):
|
|
return (rewrites===(16445406));
|
|
break;
|
|
case (5):
|
|
return (rewrites===(51507739));
|
|
break;
|
|
default:
|
|
return true;
|
|
break;
|
|
}
|
|
else
|
|
return false;
|
|
})));
|
|
};
|
|
BgL_setupzd2boyerzd2 = function() {
|
|
return true;
|
|
};
|
|
BgL_testzd2boyerzd2 = function() {
|
|
return true;
|
|
};
|
|
translate_term_nboyer = function(term) {
|
|
var lst;
|
|
return (!(term instanceof sc_Pair)?term:(new sc_Pair((BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer((term.car))), ((lst = (term.cdr)), ((lst === null)?null:(new sc_Pair((translate_term_nboyer((lst.car))), (translate_args_nboyer((lst.cdr))))))))));
|
|
};
|
|
translate_args_nboyer = function(lst) {
|
|
var sc_lst_5;
|
|
var term;
|
|
return ((lst === null)?null:(new sc_Pair(((term = (lst.car)), (!(term instanceof sc_Pair)?term:(new sc_Pair((BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer((term.car))), (translate_args_nboyer((term.cdr))))))), ((sc_lst_5 = (lst.cdr)), ((sc_lst_5 === null)?null:(new sc_Pair((translate_term_nboyer((sc_lst_5.car))), (translate_args_nboyer((sc_lst_5.cdr))))))))));
|
|
};
|
|
untranslate_term_nboyer = function(term) {
|
|
var optrOpnd;
|
|
var tail1131;
|
|
var L1127;
|
|
var falseHead1130;
|
|
var symbol_record;
|
|
if (!(term instanceof sc_Pair))
|
|
return term;
|
|
else
|
|
{
|
|
(falseHead1130 = (new sc_Pair(null, null)));
|
|
(L1127 = (term.cdr));
|
|
(tail1131 = falseHead1130);
|
|
while (!(L1127 === null)) {
|
|
{
|
|
(tail1131.cdr = (new sc_Pair((untranslate_term_nboyer((L1127.car))), null)));
|
|
(tail1131 = (tail1131.cdr));
|
|
(L1127 = (L1127.cdr));
|
|
}
|
|
}
|
|
(optrOpnd = (falseHead1130.cdr));
|
|
return (new sc_Pair(((symbol_record = (term.car)), (symbol_record[(0)])), optrOpnd));
|
|
}
|
|
};
|
|
BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer = function(sym) {
|
|
var r;
|
|
var x;
|
|
return ((x = (sc_assq(sym, BgL_sc_za2symbolzd2recordszd2alistza2_2z00_nboyer))), ((x!== false)?(x.cdr):((r = [sym, null]), (BgL_sc_za2symbolzd2recordszd2alistza2_2z00_nboyer = (new sc_Pair((new sc_Pair(sym, r)), BgL_sc_za2symbolzd2recordszd2alistza2_2z00_nboyer))), r)));
|
|
};
|
|
(BgL_sc_za2symbolzd2recordszd2alistza2_2z00_nboyer = null);
|
|
translate_alist_nboyer = function(alist) {
|
|
var sc_alist_6;
|
|
var term;
|
|
return ((alist === null)?null:(new sc_Pair((new sc_Pair((alist.car.car), ((term = (alist.car.cdr)), (!(term instanceof sc_Pair)?term:(new sc_Pair((BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer((term.car))), (translate_args_nboyer((term.cdr))))))))), ((sc_alist_6 = (alist.cdr)), ((sc_alist_6 === null)?null:(new sc_Pair((new sc_Pair((sc_alist_6.car.car), (translate_term_nboyer((sc_alist_6.car.cdr))))), (translate_alist_nboyer((sc_alist_6.cdr))))))))));
|
|
};
|
|
apply_subst_nboyer = function(alist, term) {
|
|
var lst;
|
|
var temp_temp;
|
|
return (!(term instanceof sc_Pair)?((temp_temp = (sc_assq(term, alist))), ((temp_temp!== false)?(temp_temp.cdr):term)):(new sc_Pair((term.car), ((lst = (term.cdr)), ((lst === null)?null:(new sc_Pair((apply_subst_nboyer(alist, (lst.car))), (apply_subst_lst_nboyer(alist, (lst.cdr))))))))));
|
|
};
|
|
apply_subst_lst_nboyer = function(alist, lst) {
|
|
var sc_lst_7;
|
|
return ((lst === null)?null:(new sc_Pair((apply_subst_nboyer(alist, (lst.car))), ((sc_lst_7 = (lst.cdr)), ((sc_lst_7 === null)?null:(new sc_Pair((apply_subst_nboyer(alist, (sc_lst_7.car))), (apply_subst_lst_nboyer(alist, (sc_lst_7.cdr))))))))));
|
|
};
|
|
tautologyp_nboyer = function(sc_x_11, true_lst, false_lst) {
|
|
var tmp1125;
|
|
var x;
|
|
var tmp1126;
|
|
var sc_x_8;
|
|
var sc_tmp1125_9;
|
|
var sc_tmp1126_10;
|
|
var sc_x_11;
|
|
var true_lst;
|
|
var false_lst;
|
|
while (true) {
|
|
if ((((sc_tmp1126_10 = (is_term_equal_nboyer(sc_x_11, true_term_nboyer))), ((sc_tmp1126_10!== false)?sc_tmp1126_10:(is_term_member_nboyer(sc_x_11, true_lst))))!== false))
|
|
return true;
|
|
else
|
|
if ((((sc_tmp1125_9 = (is_term_equal_nboyer(sc_x_11, false_term_nboyer))), ((sc_tmp1125_9!== false)?sc_tmp1125_9:(is_term_member_nboyer(sc_x_11, false_lst))))!== false))
|
|
return false;
|
|
else
|
|
if (!(sc_x_11 instanceof sc_Pair))
|
|
return false;
|
|
else
|
|
if (((sc_x_11.car)===if_constructor_nboyer))
|
|
if ((((sc_x_8 = (sc_x_11.cdr.car)), (tmp1126 = (is_term_equal_nboyer(sc_x_8, true_term_nboyer))), ((tmp1126!== false)?tmp1126:(is_term_member_nboyer(sc_x_8, true_lst))))!== false))
|
|
(sc_x_11 = (sc_x_11.cdr.cdr.car));
|
|
else
|
|
if ((((x = (sc_x_11.cdr.car)), (tmp1125 = (is_term_equal_nboyer(x, false_term_nboyer))), ((tmp1125!== false)?tmp1125:(is_term_member_nboyer(x, false_lst))))!== false))
|
|
(sc_x_11 = (sc_x_11.cdr.cdr.cdr.car));
|
|
else
|
|
if (((tautologyp_nboyer((sc_x_11.cdr.cdr.car), (new sc_Pair((sc_x_11.cdr.car), true_lst)), false_lst))!== false))
|
|
{
|
|
(false_lst = (new sc_Pair((sc_x_11.cdr.car), false_lst)));
|
|
(sc_x_11 = (sc_x_11.cdr.cdr.cdr.car));
|
|
}
|
|
else
|
|
return false;
|
|
else
|
|
return false;
|
|
}
|
|
};
|
|
(if_constructor_nboyer = "\u1E9C*");
|
|
(rewrite_count_nboyer = (0));
|
|
rewrite_nboyer = function(term) {
|
|
var term2;
|
|
var sc_term_12;
|
|
var lst;
|
|
var symbol_record;
|
|
var sc_lst_13;
|
|
{
|
|
(++rewrite_count_nboyer);
|
|
if (!(term instanceof sc_Pair))
|
|
return term;
|
|
else
|
|
{
|
|
(sc_term_12 = (new sc_Pair((term.car), ((sc_lst_13 = (term.cdr)), ((sc_lst_13 === null)?null:(new sc_Pair((rewrite_nboyer((sc_lst_13.car))), (rewrite_args_nboyer((sc_lst_13.cdr))))))))));
|
|
(lst = ((symbol_record = (term.car)), (symbol_record[(1)])));
|
|
while (true) {
|
|
if ((lst === null))
|
|
return sc_term_12;
|
|
else
|
|
if ((((term2 = ((lst.car).cdr.car)), (unify_subst_nboyer = null), (one_way_unify1_nboyer(sc_term_12, term2)))!== false))
|
|
return (rewrite_nboyer((apply_subst_nboyer(unify_subst_nboyer, ((lst.car).cdr.cdr.car)))));
|
|
else
|
|
(lst = (lst.cdr));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
rewrite_args_nboyer = function(lst) {
|
|
var sc_lst_14;
|
|
return ((lst === null)?null:(new sc_Pair((rewrite_nboyer((lst.car))), ((sc_lst_14 = (lst.cdr)), ((sc_lst_14 === null)?null:(new sc_Pair((rewrite_nboyer((sc_lst_14.car))), (rewrite_args_nboyer((sc_lst_14.cdr))))))))));
|
|
};
|
|
(unify_subst_nboyer = "\u1E9C*");
|
|
one_way_unify1_nboyer = function(term1, term2) {
|
|
var lst1;
|
|
var lst2;
|
|
var temp_temp;
|
|
if (!(term2 instanceof sc_Pair))
|
|
{
|
|
(temp_temp = (sc_assq(term2, unify_subst_nboyer)));
|
|
if ((temp_temp!== false))
|
|
return (is_term_equal_nboyer(term1, (temp_temp.cdr)));
|
|
else
|
|
if ((sc_isNumber(term2)))
|
|
return (sc_isEqual(term1, term2));
|
|
else
|
|
{
|
|
(unify_subst_nboyer = (new sc_Pair((new sc_Pair(term2, term1)), unify_subst_nboyer)));
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
if (!(term1 instanceof sc_Pair))
|
|
return false;
|
|
else
|
|
if (((term1.car)===(term2.car)))
|
|
{
|
|
(lst1 = (term1.cdr));
|
|
(lst2 = (term2.cdr));
|
|
while (true) {
|
|
if ((lst1 === null))
|
|
return (lst2 === null);
|
|
else
|
|
if ((lst2 === null))
|
|
return false;
|
|
else
|
|
if (((one_way_unify1_nboyer((lst1.car), (lst2.car)))!== false))
|
|
{
|
|
(lst1 = (lst1.cdr));
|
|
(lst2 = (lst2.cdr));
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
return false;
|
|
};
|
|
(false_term_nboyer = "\u1E9C*");
|
|
(true_term_nboyer = "\u1E9C*");
|
|
trans_of_implies1_nboyer = function(n) {
|
|
var sc_n_15;
|
|
return ((sc_isEqual(n, (1)))?(sc_list("\u1E9Cimplies", (0), (1))):(sc_list("\u1E9Cand", (sc_list("\u1E9Cimplies", (n-(1)), n)), ((sc_n_15 = (n-(1))), ((sc_isEqual(sc_n_15, (1)))?(sc_list("\u1E9Cimplies", (0), (1))):(sc_list("\u1E9Cand", (sc_list("\u1E9Cimplies", (sc_n_15-(1)), sc_n_15)), (trans_of_implies1_nboyer((sc_n_15-(1)))))))))));
|
|
};
|
|
is_term_equal_nboyer = function(x, y) {
|
|
var lst1;
|
|
var lst2;
|
|
var r2;
|
|
var r1;
|
|
if ((x instanceof sc_Pair))
|
|
if ((y instanceof sc_Pair))
|
|
if ((((r1 = (x.car)), (r2 = (y.car)), (r1===r2))!== false))
|
|
{
|
|
(lst1 = (x.cdr));
|
|
(lst2 = (y.cdr));
|
|
while (true) {
|
|
if ((lst1 === null))
|
|
return (lst2 === null);
|
|
else
|
|
if ((lst2 === null))
|
|
return false;
|
|
else
|
|
if (((is_term_equal_nboyer((lst1.car), (lst2.car)))!== false))
|
|
{
|
|
(lst1 = (lst1.cdr));
|
|
(lst2 = (lst2.cdr));
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
return false;
|
|
else
|
|
return false;
|
|
else
|
|
return (sc_isEqual(x, y));
|
|
};
|
|
is_term_member_nboyer = function(x, lst) {
|
|
var x;
|
|
var lst;
|
|
while (true) {
|
|
if ((lst === null))
|
|
return false;
|
|
else
|
|
if (((is_term_equal_nboyer(x, (lst.car)))!== false))
|
|
return true;
|
|
else
|
|
(lst = (lst.cdr));
|
|
}
|
|
};
|
|
BgL_setupzd2boyerzd2 = function() {
|
|
var symbol_record;
|
|
var value;
|
|
var BgL_sc_symbolzd2record_16zd2;
|
|
var sym;
|
|
var sc_sym_17;
|
|
var term;
|
|
var lst;
|
|
var sc_term_18;
|
|
var sc_term_19;
|
|
{
|
|
(BgL_sc_za2symbolzd2recordszd2alistza2_2z00_nboyer = null);
|
|
(if_constructor_nboyer = (BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer("\u1E9Cif")));
|
|
(false_term_nboyer = ((sc_term_19 = (new sc_Pair("\u1E9Cf",null))), (!(sc_term_19 instanceof sc_Pair)?sc_term_19:(new sc_Pair((BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer((sc_term_19.car))), (translate_args_nboyer((sc_term_19.cdr))))))));
|
|
(true_term_nboyer = ((sc_term_18 = (new sc_Pair("\u1E9Ct",null))), (!(sc_term_18 instanceof sc_Pair)?sc_term_18:(new sc_Pair((BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer((sc_term_18.car))), (translate_args_nboyer((sc_term_18.cdr))))))));
|
|
(lst = sc_const_3_nboyer);
|
|
while (!(lst === null)) {
|
|
{
|
|
(term = (lst.car));
|
|
if (((term instanceof sc_Pair)&&(((term.car)==="\u1E9Cequal")&&((term.cdr.car) instanceof sc_Pair))))
|
|
{
|
|
(sc_sym_17 = ((term.cdr.car).car));
|
|
(value = (new sc_Pair((!(term instanceof sc_Pair)?term:(new sc_Pair((BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer((term.car))), (translate_args_nboyer((term.cdr)))))), ((sym = ((term.cdr.car).car)), (BgL_sc_symbolzd2record_16zd2 = (BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer(sym))), (BgL_sc_symbolzd2record_16zd2[(1)])))));
|
|
(symbol_record = (BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer(sc_sym_17)));
|
|
(symbol_record[(1)] = value);
|
|
}
|
|
else
|
|
(sc_error("ADD-LEMMA did not like term: ", term));
|
|
(lst = (lst.cdr));
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
BgL_testzd2boyerzd2 = function(n) {
|
|
var optrOpnd;
|
|
var term;
|
|
var sc_n_20;
|
|
var answer;
|
|
var sc_term_21;
|
|
var sc_term_22;
|
|
{
|
|
(rewrite_count_nboyer = (0));
|
|
(term = sc_const_4_nboyer);
|
|
(sc_n_20 = n);
|
|
while (!(sc_n_20=== 0)) {
|
|
{
|
|
(term = (sc_list("\u1E9Cor", term, (new sc_Pair("\u1E9Cf",null)))));
|
|
(--sc_n_20);
|
|
}
|
|
}
|
|
(sc_term_22 = term);
|
|
if (!(sc_term_22 instanceof sc_Pair))
|
|
(optrOpnd = sc_term_22);
|
|
else
|
|
(optrOpnd = (new sc_Pair((BgL_sc_symbolzd2ze3symbolzd2record_1ze3_nboyer((sc_term_22.car))), (translate_args_nboyer((sc_term_22.cdr))))));
|
|
(sc_term_21 = (apply_subst_nboyer(((const_nboyer === null)?null:(new sc_Pair((new sc_Pair((const_nboyer.car.car), (translate_term_nboyer((const_nboyer.car.cdr))))), (translate_alist_nboyer((const_nboyer.cdr)))))), optrOpnd)));
|
|
(answer = (tautologyp_nboyer((rewrite_nboyer(sc_term_21)), null, null)));
|
|
(sc_write(rewrite_count_nboyer));
|
|
(sc_display(" rewrites"));
|
|
(sc_newline());
|
|
if ((answer!== false))
|
|
return rewrite_count_nboyer;
|
|
else
|
|
return false;
|
|
}
|
|
};
|
|
}
|
|
/* Exported Variables */
|
|
var BgL_parsezd2ze3nbzd2treesze3;
|
|
var BgL_earleyzd2benchmarkzd2;
|
|
var BgL_parsezd2ze3parsedzf3zc2;
|
|
var test;
|
|
var BgL_parsezd2ze3treesz31;
|
|
var BgL_makezd2parserzd2;
|
|
/* End Exports */
|
|
|
|
var const_earley;
|
|
{
|
|
(const_earley = (new sc_Pair((new sc_Pair("\u1E9Cs",(new sc_Pair((new sc_Pair("\u1E9Ca",null)),(new sc_Pair((new sc_Pair("\u1E9Cs",(new sc_Pair("\u1E9Cs",null)))),null)))))),null)));
|
|
BgL_makezd2parserzd2 = function(grammar, lexer) {
|
|
var i;
|
|
var parser_descr;
|
|
var def_loop;
|
|
var nb_nts;
|
|
var names;
|
|
var steps;
|
|
var predictors;
|
|
var enders;
|
|
var starters;
|
|
var nts;
|
|
var sc_names_1;
|
|
var sc_steps_2;
|
|
var sc_predictors_3;
|
|
var sc_enders_4;
|
|
var sc_starters_5;
|
|
var nb_confs;
|
|
var BgL_sc_defzd2loop_6zd2;
|
|
var BgL_sc_nbzd2nts_7zd2;
|
|
var sc_nts_8;
|
|
var BgL_sc_defzd2loop_9zd2;
|
|
var ind;
|
|
{
|
|
ind = function(nt, sc_nts_10) {
|
|
var i;
|
|
{
|
|
(i = ((sc_nts_10.length)-(1)));
|
|
while (true) {
|
|
if ((i>=(0)))
|
|
if ((sc_isEqual((sc_nts_10[i]), nt)))
|
|
return i;
|
|
else
|
|
(--i);
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
(sc_nts_8 = ((BgL_sc_defzd2loop_9zd2 = function(defs, sc_nts_11) {
|
|
var rule_loop;
|
|
var head;
|
|
var def;
|
|
return ((defs instanceof sc_Pair)?((def = (defs.car)), (head = (def.car)), (rule_loop = function(rules, sc_nts_12) {
|
|
var nt;
|
|
var l;
|
|
var sc_nts_13;
|
|
var rule;
|
|
if ((rules instanceof sc_Pair))
|
|
{
|
|
(rule = (rules.car));
|
|
(l = rule);
|
|
(sc_nts_13 = sc_nts_12);
|
|
while ((l instanceof sc_Pair)) {
|
|
{
|
|
(nt = (l.car));
|
|
(l = (l.cdr));
|
|
(sc_nts_13 = (((sc_member(nt, sc_nts_13))!== false)?sc_nts_13:(new sc_Pair(nt, sc_nts_13))));
|
|
}
|
|
}
|
|
return (rule_loop((rules.cdr), sc_nts_13));
|
|
}
|
|
else
|
|
return (BgL_sc_defzd2loop_9zd2((defs.cdr), sc_nts_12));
|
|
}), (rule_loop((def.cdr), (((sc_member(head, sc_nts_11))!== false)?sc_nts_11:(new sc_Pair(head, sc_nts_11)))))):(sc_list2vector((sc_reverse(sc_nts_11)))));
|
|
}), (BgL_sc_defzd2loop_9zd2(grammar, null))));
|
|
(BgL_sc_nbzd2nts_7zd2 = (sc_nts_8.length));
|
|
(nb_confs = (((BgL_sc_defzd2loop_6zd2 = function(defs, BgL_sc_nbzd2confs_14zd2) {
|
|
var rule_loop;
|
|
var def;
|
|
return ((defs instanceof sc_Pair)?((def = (defs.car)), (rule_loop = function(rules, BgL_sc_nbzd2confs_15zd2) {
|
|
var l;
|
|
var BgL_sc_nbzd2confs_16zd2;
|
|
var rule;
|
|
if ((rules instanceof sc_Pair))
|
|
{
|
|
(rule = (rules.car));
|
|
(l = rule);
|
|
(BgL_sc_nbzd2confs_16zd2 = BgL_sc_nbzd2confs_15zd2);
|
|
while ((l instanceof sc_Pair)) {
|
|
{
|
|
(l = (l.cdr));
|
|
(++BgL_sc_nbzd2confs_16zd2);
|
|
}
|
|
}
|
|
return (rule_loop((rules.cdr), (BgL_sc_nbzd2confs_16zd2+(1))));
|
|
}
|
|
else
|
|
return (BgL_sc_defzd2loop_6zd2((defs.cdr), BgL_sc_nbzd2confs_15zd2));
|
|
}), (rule_loop((def.cdr), BgL_sc_nbzd2confs_14zd2))):BgL_sc_nbzd2confs_14zd2);
|
|
}), (BgL_sc_defzd2loop_6zd2(grammar, (0))))+BgL_sc_nbzd2nts_7zd2));
|
|
(sc_starters_5 = (sc_makeVector(BgL_sc_nbzd2nts_7zd2, null)));
|
|
(sc_enders_4 = (sc_makeVector(BgL_sc_nbzd2nts_7zd2, null)));
|
|
(sc_predictors_3 = (sc_makeVector(BgL_sc_nbzd2nts_7zd2, null)));
|
|
(sc_steps_2 = (sc_makeVector(nb_confs, false)));
|
|
(sc_names_1 = (sc_makeVector(nb_confs, false)));
|
|
(nts = sc_nts_8);
|
|
(starters = sc_starters_5);
|
|
(enders = sc_enders_4);
|
|
(predictors = sc_predictors_3);
|
|
(steps = sc_steps_2);
|
|
(names = sc_names_1);
|
|
(nb_nts = (sc_nts_8.length));
|
|
(i = (nb_nts-(1)));
|
|
while ((i>=(0))) {
|
|
{
|
|
(sc_steps_2[i] = (i-nb_nts));
|
|
(sc_names_1[i] = (sc_list((sc_nts_8[i]), (0))));
|
|
(sc_enders_4[i] = (sc_list(i)));
|
|
(--i);
|
|
}
|
|
}
|
|
def_loop = function(defs, conf) {
|
|
var rule_loop;
|
|
var head;
|
|
var def;
|
|
return ((defs instanceof sc_Pair)?((def = (defs.car)), (head = (def.car)), (rule_loop = function(rules, conf, rule_num) {
|
|
var i;
|
|
var sc_i_17;
|
|
var nt;
|
|
var l;
|
|
var sc_conf_18;
|
|
var sc_i_19;
|
|
var rule;
|
|
if ((rules instanceof sc_Pair))
|
|
{
|
|
(rule = (rules.car));
|
|
(names[conf] = (sc_list(head, rule_num)));
|
|
(sc_i_19 = (ind(head, nts)));
|
|
(starters[sc_i_19] = (new sc_Pair(conf, (starters[sc_i_19]))));
|
|
(l = rule);
|
|
(sc_conf_18 = conf);
|
|
while ((l instanceof sc_Pair)) {
|
|
{
|
|
(nt = (l.car));
|
|
(steps[sc_conf_18] = (ind(nt, nts)));
|
|
(sc_i_17 = (ind(nt, nts)));
|
|
(predictors[sc_i_17] = (new sc_Pair(sc_conf_18, (predictors[sc_i_17]))));
|
|
(l = (l.cdr));
|
|
(++sc_conf_18);
|
|
}
|
|
}
|
|
(steps[sc_conf_18] = ((ind(head, nts))-nb_nts));
|
|
(i = (ind(head, nts)));
|
|
(enders[i] = (new sc_Pair(sc_conf_18, (enders[i]))));
|
|
return (rule_loop((rules.cdr), (sc_conf_18+(1)), (rule_num+(1))));
|
|
}
|
|
else
|
|
return (def_loop((defs.cdr), conf));
|
|
}), (rule_loop((def.cdr), conf, (1)))):undefined);
|
|
};
|
|
(def_loop(grammar, (sc_nts_8.length)));
|
|
(parser_descr = [lexer, sc_nts_8, sc_starters_5, sc_enders_4, sc_predictors_3, sc_steps_2, sc_names_1]);
|
|
return function(input) {
|
|
var optrOpnd;
|
|
var sc_optrOpnd_20;
|
|
var sc_optrOpnd_21;
|
|
var sc_optrOpnd_22;
|
|
var loop1;
|
|
var BgL_sc_stateza2_23za2;
|
|
var toks;
|
|
var BgL_sc_nbzd2nts_24zd2;
|
|
var sc_steps_25;
|
|
var sc_enders_26;
|
|
var state_num;
|
|
var BgL_sc_statesza2_27za2;
|
|
var states;
|
|
var i;
|
|
var conf;
|
|
var l;
|
|
var tok_nts;
|
|
var sc_i_28;
|
|
var sc_i_29;
|
|
var l1;
|
|
var l2;
|
|
var tok;
|
|
var tail1129;
|
|
var L1125;
|
|
var goal_enders;
|
|
var BgL_sc_statesza2_30za2;
|
|
var BgL_sc_nbzd2nts_31zd2;
|
|
var BgL_sc_nbzd2confs_32zd2;
|
|
var nb_toks;
|
|
var goal_starters;
|
|
var sc_states_33;
|
|
var BgL_sc_nbzd2confs_34zd2;
|
|
var BgL_sc_nbzd2toks_35zd2;
|
|
var sc_toks_36;
|
|
var falseHead1128;
|
|
var sc_names_37;
|
|
var sc_steps_38;
|
|
var sc_predictors_39;
|
|
var sc_enders_40;
|
|
var sc_starters_41;
|
|
var sc_nts_42;
|
|
var lexer;
|
|
var sc_ind_43;
|
|
var make_states;
|
|
var BgL_sc_confzd2setzd2getza2_44za2;
|
|
var conf_set_merge_new_bang;
|
|
var conf_set_adjoin;
|
|
var BgL_sc_confzd2setzd2adjoinza2_45za2;
|
|
var BgL_sc_confzd2setzd2adjoinza2za2_46z00;
|
|
var conf_set_union;
|
|
var forw;
|
|
var is_parsed;
|
|
var deriv_trees;
|
|
var BgL_sc_derivzd2treesza2_47z70;
|
|
var nb_deriv_trees;
|
|
var BgL_sc_nbzd2derivzd2treesza2_48za2;
|
|
{
|
|
sc_ind_43 = function(nt, sc_nts_49) {
|
|
var i;
|
|
{
|
|
(i = ((sc_nts_49.length)-(1)));
|
|
while (true) {
|
|
if ((i>=(0)))
|
|
if ((sc_isEqual((sc_nts_49[i]), nt)))
|
|
return i;
|
|
else
|
|
(--i);
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
make_states = function(BgL_sc_nbzd2toks_50zd2, BgL_sc_nbzd2confs_51zd2) {
|
|
var v;
|
|
var i;
|
|
var sc_states_52;
|
|
{
|
|
(sc_states_52 = (sc_makeVector((BgL_sc_nbzd2toks_50zd2+(1)), false)));
|
|
(i = BgL_sc_nbzd2toks_50zd2);
|
|
while ((i>=(0))) {
|
|
{
|
|
(v = (sc_makeVector((BgL_sc_nbzd2confs_51zd2+(1)), false)));
|
|
(v[(0)] = (-1));
|
|
(sc_states_52[i] = v);
|
|
(--i);
|
|
}
|
|
}
|
|
return sc_states_52;
|
|
}
|
|
};
|
|
BgL_sc_confzd2setzd2getza2_44za2 = function(state, BgL_sc_statezd2num_53zd2, sc_conf_54) {
|
|
var conf_set;
|
|
var BgL_sc_confzd2set_55zd2;
|
|
return ((BgL_sc_confzd2set_55zd2 = (state[(sc_conf_54+(1))])), ((BgL_sc_confzd2set_55zd2!== false)?BgL_sc_confzd2set_55zd2:((conf_set = (sc_makeVector((BgL_sc_statezd2num_53zd2+(6)), false))), (conf_set[(1)] = (-3)), (conf_set[(2)] = (-1)), (conf_set[(3)] = (-1)), (conf_set[(4)] = (-1)), (state[(sc_conf_54+(1))] = conf_set), conf_set)));
|
|
};
|
|
conf_set_merge_new_bang = function(conf_set) {
|
|
return ((conf_set[((conf_set[(1)])+(5))] = (conf_set[(4)])), (conf_set[(1)] = (conf_set[(3)])), (conf_set[(3)] = (-1)), (conf_set[(4)] = (-1)));
|
|
};
|
|
conf_set_adjoin = function(state, conf_set, sc_conf_56, i) {
|
|
var tail;
|
|
return ((tail = (conf_set[(3)])), (conf_set[(i+(5))] = (-1)), (conf_set[(tail+(5))] = i), (conf_set[(3)] = i), ((tail<(0))?((conf_set[(0)] = (state[(0)])), (state[(0)] = sc_conf_56)):undefined));
|
|
};
|
|
BgL_sc_confzd2setzd2adjoinza2_45za2 = function(sc_states_57, BgL_sc_statezd2num_58zd2, l, i) {
|
|
var conf_set;
|
|
var sc_conf_59;
|
|
var l1;
|
|
var state;
|
|
{
|
|
(state = (sc_states_57[BgL_sc_statezd2num_58zd2]));
|
|
(l1 = l);
|
|
while ((l1 instanceof sc_Pair)) {
|
|
{
|
|
(sc_conf_59 = (l1.car));
|
|
(conf_set = (BgL_sc_confzd2setzd2getza2_44za2(state, BgL_sc_statezd2num_58zd2, sc_conf_59)));
|
|
if (((conf_set[(i+(5))])=== false))
|
|
{
|
|
(conf_set_adjoin(state, conf_set, sc_conf_59, i));
|
|
(l1 = (l1.cdr));
|
|
}
|
|
else
|
|
(l1 = (l1.cdr));
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
};
|
|
BgL_sc_confzd2setzd2adjoinza2za2_46z00 = function(sc_states_60, BgL_sc_statesza2_61za2, BgL_sc_statezd2num_62zd2, sc_conf_63, i) {
|
|
var BgL_sc_confzd2setza2_64z70;
|
|
var BgL_sc_stateza2_65za2;
|
|
var conf_set;
|
|
var state;
|
|
return ((state = (sc_states_60[BgL_sc_statezd2num_62zd2])), ((((conf_set = (state[(sc_conf_63+(1))])), ((conf_set!== false)?(conf_set[(i+(5))]):false))!== false)?((BgL_sc_stateza2_65za2 = (BgL_sc_statesza2_61za2[BgL_sc_statezd2num_62zd2])), (BgL_sc_confzd2setza2_64z70 = (BgL_sc_confzd2setzd2getza2_44za2(BgL_sc_stateza2_65za2, BgL_sc_statezd2num_62zd2, sc_conf_63))), (((BgL_sc_confzd2setza2_64z70[(i+(5))])=== false)?(conf_set_adjoin(BgL_sc_stateza2_65za2, BgL_sc_confzd2setza2_64z70, sc_conf_63, i)):undefined), true):false));
|
|
};
|
|
conf_set_union = function(state, conf_set, sc_conf_66, other_set) {
|
|
var i;
|
|
{
|
|
(i = (other_set[(2)]));
|
|
while ((i>=(0))) {
|
|
if (((conf_set[(i+(5))])=== false))
|
|
{
|
|
(conf_set_adjoin(state, conf_set, sc_conf_66, i));
|
|
(i = (other_set[(i+(5))]));
|
|
}
|
|
else
|
|
(i = (other_set[(i+(5))]));
|
|
}
|
|
return undefined;
|
|
}
|
|
};
|
|
forw = function(sc_states_67, BgL_sc_statezd2num_68zd2, sc_starters_69, sc_enders_70, sc_predictors_71, sc_steps_72, sc_nts_73) {
|
|
var next_set;
|
|
var next;
|
|
var conf_set;
|
|
var ender;
|
|
var l;
|
|
var starter_set;
|
|
var starter;
|
|
var sc_l_74;
|
|
var sc_loop1_75;
|
|
var head;
|
|
var BgL_sc_confzd2set_76zd2;
|
|
var BgL_sc_statezd2num_77zd2;
|
|
var state;
|
|
var sc_states_78;
|
|
var preds;
|
|
var BgL_sc_confzd2set_79zd2;
|
|
var step;
|
|
var sc_conf_80;
|
|
var BgL_sc_nbzd2nts_81zd2;
|
|
var sc_state_82;
|
|
{
|
|
(sc_state_82 = (sc_states_67[BgL_sc_statezd2num_68zd2]));
|
|
(BgL_sc_nbzd2nts_81zd2 = (sc_nts_73.length));
|
|
while (true) {
|
|
{
|
|
(sc_conf_80 = (sc_state_82[(0)]));
|
|
if ((sc_conf_80>=(0)))
|
|
{
|
|
(step = (sc_steps_72[sc_conf_80]));
|
|
(BgL_sc_confzd2set_79zd2 = (sc_state_82[(sc_conf_80+(1))]));
|
|
(head = (BgL_sc_confzd2set_79zd2[(4)]));
|
|
(sc_state_82[(0)] = (BgL_sc_confzd2set_79zd2[(0)]));
|
|
(conf_set_merge_new_bang(BgL_sc_confzd2set_79zd2));
|
|
if ((step>=(0)))
|
|
{
|
|
(sc_l_74 = (sc_starters_69[step]));
|
|
while ((sc_l_74 instanceof sc_Pair)) {
|
|
{
|
|
(starter = (sc_l_74.car));
|
|
(starter_set = (BgL_sc_confzd2setzd2getza2_44za2(sc_state_82, BgL_sc_statezd2num_68zd2, starter)));
|
|
if (((starter_set[(BgL_sc_statezd2num_68zd2+(5))])=== false))
|
|
{
|
|
(conf_set_adjoin(sc_state_82, starter_set, starter, BgL_sc_statezd2num_68zd2));
|
|
(sc_l_74 = (sc_l_74.cdr));
|
|
}
|
|
else
|
|
(sc_l_74 = (sc_l_74.cdr));
|
|
}
|
|
}
|
|
(l = (sc_enders_70[step]));
|
|
while ((l instanceof sc_Pair)) {
|
|
{
|
|
(ender = (l.car));
|
|
if ((((conf_set = (sc_state_82[(ender+(1))])), ((conf_set!== false)?(conf_set[(BgL_sc_statezd2num_68zd2+(5))]):false))!== false))
|
|
{
|
|
(next = (sc_conf_80+(1)));
|
|
(next_set = (BgL_sc_confzd2setzd2getza2_44za2(sc_state_82, BgL_sc_statezd2num_68zd2, next)));
|
|
(conf_set_union(sc_state_82, next_set, next, BgL_sc_confzd2set_79zd2));
|
|
(l = (l.cdr));
|
|
}
|
|
else
|
|
(l = (l.cdr));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
(preds = (sc_predictors_71[(step+BgL_sc_nbzd2nts_81zd2)]));
|
|
(sc_states_78 = sc_states_67);
|
|
(state = sc_state_82);
|
|
(BgL_sc_statezd2num_77zd2 = BgL_sc_statezd2num_68zd2);
|
|
(BgL_sc_confzd2set_76zd2 = BgL_sc_confzd2set_79zd2);
|
|
sc_loop1_75 = function(l) {
|
|
var sc_state_83;
|
|
var BgL_sc_nextzd2set_84zd2;
|
|
var sc_next_85;
|
|
var pred_set;
|
|
var i;
|
|
var pred;
|
|
if ((l instanceof sc_Pair))
|
|
{
|
|
(pred = (l.car));
|
|
(i = head);
|
|
while ((i>=(0))) {
|
|
{
|
|
(pred_set = ((sc_state_83 = (sc_states_78[i])), (sc_state_83[(pred+(1))])));
|
|
if ((pred_set!== false))
|
|
{
|
|
(sc_next_85 = (pred+(1)));
|
|
(BgL_sc_nextzd2set_84zd2 = (BgL_sc_confzd2setzd2getza2_44za2(state, BgL_sc_statezd2num_77zd2, sc_next_85)));
|
|
(conf_set_union(state, BgL_sc_nextzd2set_84zd2, sc_next_85, pred_set));
|
|
}
|
|
(i = (BgL_sc_confzd2set_76zd2[(i+(5))]));
|
|
}
|
|
}
|
|
return (sc_loop1_75((l.cdr)));
|
|
}
|
|
else
|
|
return undefined;
|
|
};
|
|
(sc_loop1_75(preds));
|
|
}
|
|
}
|
|
else
|
|
return undefined;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
is_parsed = function(nt, i, j, sc_nts_86, sc_enders_87, sc_states_88) {
|
|
var conf_set;
|
|
var state;
|
|
var sc_conf_89;
|
|
var l;
|
|
var BgL_sc_ntza2_90za2;
|
|
{
|
|
(BgL_sc_ntza2_90za2 = (sc_ind_43(nt, sc_nts_86)));
|
|
if ((BgL_sc_ntza2_90za2!== false))
|
|
{
|
|
(sc_nts_86.length);
|
|
(l = (sc_enders_87[BgL_sc_ntza2_90za2]));
|
|
while (true) {
|
|
if ((l instanceof sc_Pair))
|
|
{
|
|
(sc_conf_89 = (l.car));
|
|
if ((((state = (sc_states_88[j])), (conf_set = (state[(sc_conf_89+(1))])), ((conf_set!== false)?(conf_set[(i+(5))]):false))!== false))
|
|
return true;
|
|
else
|
|
(l = (l.cdr));
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
};
|
|
deriv_trees = function(sc_conf_91, i, j, sc_enders_92, sc_steps_93, sc_names_94, sc_toks_95, sc_states_96, BgL_sc_nbzd2nts_97zd2) {
|
|
var sc_loop1_98;
|
|
var prev;
|
|
var name;
|
|
return ((name = (sc_names_94[sc_conf_91])), ((name!== false)?((sc_conf_91<BgL_sc_nbzd2nts_97zd2)?(sc_list((sc_list(name, ((sc_toks_95[i]).car))))):(sc_list((sc_list(name))))):((prev = (sc_conf_91-(1))), (sc_loop1_98 = function(l1, l2) {
|
|
var loop2;
|
|
var ender_set;
|
|
var state;
|
|
var ender;
|
|
var l1;
|
|
var l2;
|
|
while (true) {
|
|
if ((l1 instanceof sc_Pair))
|
|
{
|
|
(ender = (l1.car));
|
|
(ender_set = ((state = (sc_states_96[j])), (state[(ender+(1))])));
|
|
if ((ender_set!== false))
|
|
{
|
|
loop2 = function(k, l2) {
|
|
var loop3;
|
|
var ender_trees;
|
|
var prev_trees;
|
|
var conf_set;
|
|
var sc_state_99;
|
|
var k;
|
|
var l2;
|
|
while (true) {
|
|
if ((k>=(0)))
|
|
if (((k>=i)&&(((sc_state_99 = (sc_states_96[k])), (conf_set = (sc_state_99[(prev+(1))])), ((conf_set!== false)?(conf_set[(i+(5))]):false))!== false)))
|
|
{
|
|
(prev_trees = (deriv_trees(prev, i, k, sc_enders_92, sc_steps_93, sc_names_94, sc_toks_95, sc_states_96, BgL_sc_nbzd2nts_97zd2)));
|
|
(ender_trees = (deriv_trees(ender, k, j, sc_enders_92, sc_steps_93, sc_names_94, sc_toks_95, sc_states_96, BgL_sc_nbzd2nts_97zd2)));
|
|
loop3 = function(l3, l2) {
|
|
var l4;
|
|
var sc_l2_100;
|
|
var ender_tree;
|
|
if ((l3 instanceof sc_Pair))
|
|
{
|
|
(ender_tree = (sc_list((l3.car))));
|
|
(l4 = prev_trees);
|
|
(sc_l2_100 = l2);
|
|
while ((l4 instanceof sc_Pair)) {
|
|
{
|
|
(sc_l2_100 = (new sc_Pair((sc_append((l4.car), ender_tree)), sc_l2_100)));
|
|
(l4 = (l4.cdr));
|
|
}
|
|
}
|
|
return (loop3((l3.cdr), sc_l2_100));
|
|
}
|
|
else
|
|
return (loop2((ender_set[(k+(5))]), l2));
|
|
};
|
|
return (loop3(ender_trees, l2));
|
|
}
|
|
else
|
|
(k = (ender_set[(k+(5))]));
|
|
else
|
|
return (sc_loop1_98((l1.cdr), l2));
|
|
}
|
|
};
|
|
return (loop2((ender_set[(2)]), l2));
|
|
}
|
|
else
|
|
(l1 = (l1.cdr));
|
|
}
|
|
else
|
|
return l2;
|
|
}
|
|
}), (sc_loop1_98((sc_enders_92[(sc_steps_93[prev])]), null)))));
|
|
};
|
|
BgL_sc_derivzd2treesza2_47z70 = function(nt, i, j, sc_nts_101, sc_enders_102, sc_steps_103, sc_names_104, sc_toks_105, sc_states_106) {
|
|
var conf_set;
|
|
var state;
|
|
var sc_conf_107;
|
|
var l;
|
|
var trees;
|
|
var BgL_sc_nbzd2nts_108zd2;
|
|
var BgL_sc_ntza2_109za2;
|
|
{
|
|
(BgL_sc_ntza2_109za2 = (sc_ind_43(nt, sc_nts_101)));
|
|
if ((BgL_sc_ntza2_109za2!== false))
|
|
{
|
|
(BgL_sc_nbzd2nts_108zd2 = (sc_nts_101.length));
|
|
(l = (sc_enders_102[BgL_sc_ntza2_109za2]));
|
|
(trees = null);
|
|
while ((l instanceof sc_Pair)) {
|
|
{
|
|
(sc_conf_107 = (l.car));
|
|
if ((((state = (sc_states_106[j])), (conf_set = (state[(sc_conf_107+(1))])), ((conf_set!== false)?(conf_set[(i+(5))]):false))!== false))
|
|
{
|
|
(l = (l.cdr));
|
|
(trees = (sc_append((deriv_trees(sc_conf_107, i, j, sc_enders_102, sc_steps_103, sc_names_104, sc_toks_105, sc_states_106, BgL_sc_nbzd2nts_108zd2)), trees)));
|
|
}
|
|
else
|
|
(l = (l.cdr));
|
|
}
|
|
}
|
|
return trees;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
};
|
|
nb_deriv_trees = function(sc_conf_110, i, j, sc_enders_111, sc_steps_112, sc_toks_113, sc_states_114, BgL_sc_nbzd2nts_115zd2) {
|
|
var sc_loop1_116;
|
|
var tmp1124;
|
|
var prev;
|
|
return ((prev = (sc_conf_110-(1))), ((((tmp1124 = (sc_conf_110<BgL_sc_nbzd2nts_115zd2)), ((tmp1124!== false)?tmp1124:((sc_steps_112[prev])<(0))))!== false)?(1):((sc_loop1_116 = function(l, sc_n_118) {
|
|
var nb_ender_trees;
|
|
var nb_prev_trees;
|
|
var conf_set;
|
|
var state;
|
|
var k;
|
|
var n;
|
|
var ender_set;
|
|
var sc_state_117;
|
|
var ender;
|
|
var l;
|
|
var sc_n_118;
|
|
while (true) {
|
|
if ((l instanceof sc_Pair))
|
|
{
|
|
(ender = (l.car));
|
|
(ender_set = ((sc_state_117 = (sc_states_114[j])), (sc_state_117[(ender+(1))])));
|
|
if ((ender_set!== false))
|
|
{
|
|
(k = (ender_set[(2)]));
|
|
(n = sc_n_118);
|
|
while ((k>=(0))) {
|
|
if (((k>=i)&&(((state = (sc_states_114[k])), (conf_set = (state[(prev+(1))])), ((conf_set!== false)?(conf_set[(i+(5))]):false))!== false)))
|
|
{
|
|
(nb_prev_trees = (nb_deriv_trees(prev, i, k, sc_enders_111, sc_steps_112, sc_toks_113, sc_states_114, BgL_sc_nbzd2nts_115zd2)));
|
|
(nb_ender_trees = (nb_deriv_trees(ender, k, j, sc_enders_111, sc_steps_112, sc_toks_113, sc_states_114, BgL_sc_nbzd2nts_115zd2)));
|
|
(k = (ender_set[(k+(5))]));
|
|
(n +=(nb_prev_trees*nb_ender_trees));
|
|
}
|
|
else
|
|
(k = (ender_set[(k+(5))]));
|
|
}
|
|
return (sc_loop1_116((l.cdr), n));
|
|
}
|
|
else
|
|
(l = (l.cdr));
|
|
}
|
|
else
|
|
return sc_n_118;
|
|
}
|
|
}), (sc_loop1_116((sc_enders_111[(sc_steps_112[prev])]), (0))))));
|
|
};
|
|
BgL_sc_nbzd2derivzd2treesza2_48za2 = function(nt, i, j, sc_nts_119, sc_enders_120, sc_steps_121, sc_toks_122, sc_states_123) {
|
|
var conf_set;
|
|
var state;
|
|
var sc_conf_124;
|
|
var l;
|
|
var nb_trees;
|
|
var BgL_sc_nbzd2nts_125zd2;
|
|
var BgL_sc_ntza2_126za2;
|
|
{
|
|
(BgL_sc_ntza2_126za2 = (sc_ind_43(nt, sc_nts_119)));
|
|
if ((BgL_sc_ntza2_126za2!== false))
|
|
{
|
|
(BgL_sc_nbzd2nts_125zd2 = (sc_nts_119.length));
|
|
(l = (sc_enders_120[BgL_sc_ntza2_126za2]));
|
|
(nb_trees = (0));
|
|
while ((l instanceof sc_Pair)) {
|
|
{
|
|
(sc_conf_124 = (l.car));
|
|
if ((((state = (sc_states_123[j])), (conf_set = (state[(sc_conf_124+(1))])), ((conf_set!== false)?(conf_set[(i+(5))]):false))!== false))
|
|
{
|
|
(l = (l.cdr));
|
|
(nb_trees = ((nb_deriv_trees(sc_conf_124, i, j, sc_enders_120, sc_steps_121, sc_toks_122, sc_states_123, BgL_sc_nbzd2nts_125zd2))+nb_trees));
|
|
}
|
|
else
|
|
(l = (l.cdr));
|
|
}
|
|
}
|
|
return nb_trees;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
};
|
|
(lexer = (parser_descr[(0)]));
|
|
(sc_nts_42 = (parser_descr[(1)]));
|
|
(sc_starters_41 = (parser_descr[(2)]));
|
|
(sc_enders_40 = (parser_descr[(3)]));
|
|
(sc_predictors_39 = (parser_descr[(4)]));
|
|
(sc_steps_38 = (parser_descr[(5)]));
|
|
(sc_names_37 = (parser_descr[(6)]));
|
|
(falseHead1128 = (new sc_Pair(null, null)));
|
|
(L1125 = (lexer(input)));
|
|
(tail1129 = falseHead1128);
|
|
while (!(L1125 === null)) {
|
|
{
|
|
(tok = (L1125.car));
|
|
(l1 = (tok.cdr));
|
|
(l2 = null);
|
|
while ((l1 instanceof sc_Pair)) {
|
|
{
|
|
(sc_i_29 = (sc_ind_43((l1.car), sc_nts_42)));
|
|
if ((sc_i_29!== false))
|
|
{
|
|
(l1 = (l1.cdr));
|
|
(l2 = (new sc_Pair(sc_i_29, l2)));
|
|
}
|
|
else
|
|
(l1 = (l1.cdr));
|
|
}
|
|
}
|
|
(sc_optrOpnd_22 = (new sc_Pair((tok.car), (sc_reverse(l2)))));
|
|
(sc_optrOpnd_21 = (new sc_Pair(sc_optrOpnd_22, null)));
|
|
(tail1129.cdr = sc_optrOpnd_21);
|
|
(tail1129 = (tail1129.cdr));
|
|
(L1125 = (L1125.cdr));
|
|
}
|
|
}
|
|
(sc_optrOpnd_20 = (falseHead1128.cdr));
|
|
(sc_toks_36 = (sc_list2vector(sc_optrOpnd_20)));
|
|
(BgL_sc_nbzd2toks_35zd2 = (sc_toks_36.length));
|
|
(BgL_sc_nbzd2confs_34zd2 = (sc_steps_38.length));
|
|
(sc_states_33 = (make_states(BgL_sc_nbzd2toks_35zd2, BgL_sc_nbzd2confs_34zd2)));
|
|
(goal_starters = (sc_starters_41[(0)]));
|
|
(BgL_sc_confzd2setzd2adjoinza2_45za2(sc_states_33, (0), goal_starters, (0)));
|
|
(forw(sc_states_33, (0), sc_starters_41, sc_enders_40, sc_predictors_39, sc_steps_38, sc_nts_42));
|
|
(sc_i_28 = (0));
|
|
while ((sc_i_28<BgL_sc_nbzd2toks_35zd2)) {
|
|
{
|
|
(tok_nts = ((sc_toks_36[sc_i_28]).cdr));
|
|
(BgL_sc_confzd2setzd2adjoinza2_45za2(sc_states_33, (sc_i_28+(1)), tok_nts, sc_i_28));
|
|
(forw(sc_states_33, (sc_i_28+(1)), sc_starters_41, sc_enders_40, sc_predictors_39, sc_steps_38, sc_nts_42));
|
|
(++sc_i_28);
|
|
}
|
|
}
|
|
(nb_toks = (sc_toks_36.length));
|
|
(BgL_sc_nbzd2confs_32zd2 = (sc_steps_38.length));
|
|
(BgL_sc_nbzd2nts_31zd2 = (sc_nts_42.length));
|
|
(BgL_sc_statesza2_30za2 = (make_states(nb_toks, BgL_sc_nbzd2confs_32zd2)));
|
|
(goal_enders = (sc_enders_40[(0)]));
|
|
(l = goal_enders);
|
|
while ((l instanceof sc_Pair)) {
|
|
{
|
|
(conf = (l.car));
|
|
(BgL_sc_confzd2setzd2adjoinza2za2_46z00(sc_states_33, BgL_sc_statesza2_30za2, nb_toks, conf, (0)));
|
|
(l = (l.cdr));
|
|
}
|
|
}
|
|
(i = nb_toks);
|
|
while ((i>=(0))) {
|
|
{
|
|
(states = sc_states_33);
|
|
(BgL_sc_statesza2_27za2 = BgL_sc_statesza2_30za2);
|
|
(state_num = i);
|
|
(sc_enders_26 = sc_enders_40);
|
|
(sc_steps_25 = sc_steps_38);
|
|
(BgL_sc_nbzd2nts_24zd2 = BgL_sc_nbzd2nts_31zd2);
|
|
(toks = sc_toks_36);
|
|
(BgL_sc_stateza2_23za2 = (BgL_sc_statesza2_30za2[i]));
|
|
loop1 = function() {
|
|
var sc_loop1_127;
|
|
var prev;
|
|
var BgL_sc_statesza2_128za2;
|
|
var sc_states_129;
|
|
var j;
|
|
var i;
|
|
var sc_i_130;
|
|
var head;
|
|
var conf_set;
|
|
var sc_conf_131;
|
|
{
|
|
(sc_conf_131 = (BgL_sc_stateza2_23za2[(0)]));
|
|
if ((sc_conf_131>=(0)))
|
|
{
|
|
(conf_set = (BgL_sc_stateza2_23za2[(sc_conf_131+(1))]));
|
|
(head = (conf_set[(4)]));
|
|
(BgL_sc_stateza2_23za2[(0)] = (conf_set[(0)]));
|
|
(conf_set_merge_new_bang(conf_set));
|
|
(sc_i_130 = head);
|
|
while ((sc_i_130>=(0))) {
|
|
{
|
|
(i = sc_i_130);
|
|
(j = state_num);
|
|
(sc_states_129 = states);
|
|
(BgL_sc_statesza2_128za2 = BgL_sc_statesza2_27za2);
|
|
(prev = (sc_conf_131-(1)));
|
|
if (((sc_conf_131>=BgL_sc_nbzd2nts_24zd2)&&((sc_steps_25[prev])>=(0))))
|
|
{
|
|
sc_loop1_127 = function(l) {
|
|
var k;
|
|
var ender_set;
|
|
var state;
|
|
var ender;
|
|
var l;
|
|
while (true) {
|
|
if ((l instanceof sc_Pair))
|
|
{
|
|
(ender = (l.car));
|
|
(ender_set = ((state = (sc_states_129[j])), (state[(ender+(1))])));
|
|
if ((ender_set!== false))
|
|
{
|
|
(k = (ender_set[(2)]));
|
|
while ((k>=(0))) {
|
|
{
|
|
if ((k>=i))
|
|
if (((BgL_sc_confzd2setzd2adjoinza2za2_46z00(sc_states_129, BgL_sc_statesza2_128za2, k, prev, i))!== false))
|
|
(BgL_sc_confzd2setzd2adjoinza2za2_46z00(sc_states_129, BgL_sc_statesza2_128za2, j, ender, k));
|
|
(k = (ender_set[(k+(5))]));
|
|
}
|
|
}
|
|
return (sc_loop1_127((l.cdr)));
|
|
}
|
|
else
|
|
(l = (l.cdr));
|
|
}
|
|
else
|
|
return undefined;
|
|
}
|
|
};
|
|
(sc_loop1_127((sc_enders_26[(sc_steps_25[prev])])));
|
|
}
|
|
(sc_i_130 = (conf_set[(sc_i_130+(5))]));
|
|
}
|
|
}
|
|
return (loop1());
|
|
}
|
|
else
|
|
return undefined;
|
|
}
|
|
};
|
|
(loop1());
|
|
(--i);
|
|
}
|
|
}
|
|
(optrOpnd = BgL_sc_statesza2_30za2);
|
|
return [sc_nts_42, sc_starters_41, sc_enders_40, sc_predictors_39, sc_steps_38, sc_names_37, sc_toks_36, optrOpnd, is_parsed, BgL_sc_derivzd2treesza2_47z70, BgL_sc_nbzd2derivzd2treesza2_48za2];
|
|
}
|
|
};
|
|
}
|
|
};
|
|
BgL_parsezd2ze3parsedzf3zc2 = function(parse, nt, i, j) {
|
|
var is_parsed;
|
|
var states;
|
|
var enders;
|
|
var nts;
|
|
return ((nts = (parse[(0)])), (enders = (parse[(2)])), (states = (parse[(7)])), (is_parsed = (parse[(8)])), (is_parsed(nt, i, j, nts, enders, states)));
|
|
};
|
|
BgL_parsezd2ze3treesz31 = function(parse, nt, i, j) {
|
|
var BgL_sc_derivzd2treesza2_132z70;
|
|
var states;
|
|
var toks;
|
|
var names;
|
|
var steps;
|
|
var enders;
|
|
var nts;
|
|
return ((nts = (parse[(0)])), (enders = (parse[(2)])), (steps = (parse[(4)])), (names = (parse[(5)])), (toks = (parse[(6)])), (states = (parse[(7)])), (BgL_sc_derivzd2treesza2_132z70 = (parse[(9)])), (BgL_sc_derivzd2treesza2_132z70(nt, i, j, nts, enders, steps, names, toks, states)));
|
|
};
|
|
BgL_parsezd2ze3nbzd2treesze3 = function(parse, nt, i, j) {
|
|
var BgL_sc_nbzd2derivzd2treesza2_133za2;
|
|
var states;
|
|
var toks;
|
|
var steps;
|
|
var enders;
|
|
var nts;
|
|
return ((nts = (parse[(0)])), (enders = (parse[(2)])), (steps = (parse[(4)])), (toks = (parse[(6)])), (states = (parse[(7)])), (BgL_sc_nbzd2derivzd2treesza2_133za2 = (parse[(10)])), (BgL_sc_nbzd2derivzd2treesza2_133za2(nt, i, j, nts, enders, steps, toks, states)));
|
|
};
|
|
test = function(k) {
|
|
var x;
|
|
var p;
|
|
return ((p = (BgL_makezd2parserzd2(const_earley, function(l) {
|
|
var sc_x_134;
|
|
var tail1134;
|
|
var L1130;
|
|
var falseHead1133;
|
|
{
|
|
(falseHead1133 = (new sc_Pair(null, null)));
|
|
(tail1134 = falseHead1133);
|
|
(L1130 = l);
|
|
while (!(L1130 === null)) {
|
|
{
|
|
(tail1134.cdr = (new sc_Pair(((sc_x_134 = (L1130.car)), (sc_list(sc_x_134, sc_x_134))), null)));
|
|
(tail1134 = (tail1134.cdr));
|
|
(L1130 = (L1130.cdr));
|
|
}
|
|
}
|
|
return (falseHead1133.cdr);
|
|
}
|
|
}))), (x = (p((sc_vector2list((sc_makeVector(k, "\u1E9Ca"))))))), (sc_length((BgL_parsezd2ze3treesz31(x, "\u1E9Cs", (0), k)))));
|
|
};
|
|
BgL_earleyzd2benchmarkzd2 = function() {
|
|
var args = null;
|
|
for (var sc_tmp = arguments.length - 1; sc_tmp >= 0; sc_tmp--) {
|
|
args = sc_cons(arguments[sc_tmp], args);
|
|
}
|
|
var k;
|
|
return ((k = ((args === null)?(7):(args.car))), (BgL_runzd2benchmarkzd2("earley", (1), function() {
|
|
return (test(k));
|
|
}, function(result) {
|
|
return ((sc_display(result)), (sc_newline()), result == 132);
|
|
})));
|
|
};
|
|
}
|
|
|
|
|
|
/************* END OF GENERATED CODE *************/
|
|
// Invoke this function to run a benchmark.
|
|
// The first argument is a string identifying the benchmark.
|
|
// The second argument is the number of times to run the benchmark.
|
|
// The third argument is a function that runs the benchmark.
|
|
// The fourth argument is a unary function that warns if the result
|
|
// returned by the benchmark is incorrect.
|
|
//
|
|
// Example:
|
|
// RunBenchmark("new Array()",
|
|
// 1,
|
|
// function () { new Array(1000000); }
|
|
// function (v) {
|
|
// return (v instanceof Array) && (v.length == 1000000);
|
|
// });
|
|
|
|
SC_DEFAULT_OUT = new sc_GenericOutputPort(function(s) {});
|
|
SC_ERROR_OUT = SC_DEFAULT_OUT;
|
|
|
|
function RunBenchmark(name, count, run, warn) {
|
|
for (var n = 0; n < count; ++n) {
|
|
result = run();
|
|
if (!warn(result)) {
|
|
throw new Error("Earley or Boyer did incorrect number of rewrites");
|
|
}
|
|
}
|
|
}
|
|
|
|
var BgL_runzd2benchmarkzd2 = RunBenchmark;
|
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
// Automatically generated on 2009-01-30. Manually updated on 2010-09-17.
|
|
|
|
// This benchmark is generated by loading 50 of the most popular pages
|
|
// on the web and logging all regexp operations performed. Each
|
|
// operation is given a weight that is calculated from an estimate of
|
|
// the popularity of the pages where it occurs and the number of times
|
|
// it is executed while loading each page. Furthermore the literal
|
|
// letters in the data are encoded using ROT13 in a way that does not
|
|
// affect how the regexps match their input. Finally the strings are
|
|
// scrambled to exercise the regexp engine on different input strings.
|
|
|
|
|
|
var RegExp = new BenchmarkSuite('RegExp', 910985, [
|
|
new Benchmark("RegExp", RegExpRun, RegExpSetup, RegExpTearDown)
|
|
]);
|
|
|
|
var regExpBenchmark = null;
|
|
|
|
function RegExpSetup() {
|
|
regExpBenchmark = new RegExpBenchmark();
|
|
RegExpRun(); // run once to get system initialized
|
|
}
|
|
|
|
function RegExpRun() {
|
|
regExpBenchmark.run();
|
|
}
|
|
|
|
function RegExpTearDown() {
|
|
regExpBenchmark = null;
|
|
}
|
|
|
|
// Returns an array of n different variants of the input string str.
|
|
// The variants are computed by randomly rotating one random
|
|
// character.
|
|
function computeInputVariants(str, n) {
|
|
var variants = [ str ];
|
|
for (var i = 1; i < n; i++) {
|
|
var pos = Math.floor(Math.random() * str.length);
|
|
var chr = String.fromCharCode((str.charCodeAt(pos) + Math.floor(Math.random() * 128)) % 128);
|
|
variants[i] = str.substring(0, pos) + chr + str.substring(pos + 1, str.length);
|
|
}
|
|
return variants;
|
|
}
|
|
|
|
function RegExpBenchmark() {
|
|
var re0 = /^ba/;
|
|
var re1 = /(((\w+):\/\/)([^\/:]*)(:(\d+))?)?([^#?]*)(\?([^#]*))?(#(.*))?/;
|
|
var re2 = /^\s*|\s*$/g;
|
|
var re3 = /\bQBZPbageby_cynprubyqre\b/;
|
|
var re4 = /,/;
|
|
var re5 = /\bQBZPbageby_cynprubyqre\b/g;
|
|
var re6 = /^[\s\xa0]+|[\s\xa0]+$/g;
|
|
var re7 = /(\d*)(\D*)/g;
|
|
var re8 = /=/;
|
|
var re9 = /(^|\s)lhv\-h(\s|$)/;
|
|
var str0 = 'Zbmvyyn/5.0 (Jvaqbjf; H; Jvaqbjf AG 5.1; ra-HF) NccyrJroXvg/528.9 (XUGZY, yvxr Trpxb) Puebzr/2.0.157.0 Fnsnev/528.9';
|
|
var re10 = /\#/g;
|
|
var re11 = /\./g;
|
|
var re12 = /'/g;
|
|
var re13 = /\?[\w\W]*(sevraqvq|punaaryvq|tebhcvq)=([^\&\?#]*)/i;
|
|
var str1 = 'Fubpxjnir Synfu 9.0 e115';
|
|
var re14 = /\s+/g;
|
|
var re15 = /^\s*(\S*(\s+\S+)*)\s*$/;
|
|
var re16 = /(-[a-z])/i;
|
|
|
|
var s0 = computeInputVariants('pyvpx', 6511);
|
|
var s1 = computeInputVariants('uggc://jjj.snprobbx.pbz/ybtva.cuc', 1844);
|
|
var s2 = computeInputVariants('QBZPbageby_cynprubyqre', 739);
|
|
var s3 = computeInputVariants('uggc://jjj.snprobbx.pbz/', 598);
|
|
var s4 = computeInputVariants('uggc://jjj.snprobbx.pbz/fepu.cuc', 454);
|
|
var s5 = computeInputVariants('qqqq, ZZZ q, llll', 352);
|
|
var s6 = computeInputVariants('vachggrkg QBZPbageby_cynprubyqre', 312);
|
|
var s7 = computeInputVariants('/ZlFcnprUbzrcntr/Vaqrk-FvgrUbzr,10000000', 282);
|
|
var s8 = computeInputVariants('vachggrkg', 177);
|
|
var s9 = computeInputVariants('528.9', 170);
|
|
var s10 = computeInputVariants('528', 170);
|
|
var s11 = computeInputVariants('VCPhygher=ra-HF', 156);
|
|
var s12 = computeInputVariants('CersreerqPhygher=ra-HF', 156);
|
|
var s13 = computeInputVariants('xrlcerff', 144);
|
|
var s14 = computeInputVariants('521', 139);
|
|
var s15 = computeInputVariants(str0, 139);
|
|
var s16 = computeInputVariants('qvi .so_zrah', 137);
|
|
var s17 = computeInputVariants('qvi.so_zrah', 137);
|
|
var s18 = computeInputVariants('uvqqra_ryrz', 117);
|
|
var s19 = computeInputVariants('sevraqfgre_naba=nvq%3Qn6ss9p85n868ro9s059pn854735956o3%26ers%3Q%26df%3Q%26vpgl%3QHF', 95);
|
|
var s20 = computeInputVariants('uggc://ubzr.zlfcnpr.pbz/vaqrk.psz', 93);
|
|
var s21 = computeInputVariants(str1, 92);
|
|
var s22 = computeInputVariants('svefg', 85);
|
|
var s23 = computeInputVariants('uggc://cebsvyr.zlfcnpr.pbz/vaqrk.psz', 85);
|
|
var s24 = computeInputVariants('ynfg', 85);
|
|
var s25 = computeInputVariants('qvfcynl', 85);
|
|
|
|
function runBlock0() {
|
|
for (var i = 0; i < 6511; i++) {
|
|
re0.exec(s0[i]);
|
|
}
|
|
for (var i = 0; i < 1844; i++) {
|
|
re1.exec(s1[i]);
|
|
}
|
|
for (var i = 0; i < 739; i++) {
|
|
s2[i].replace(re2, '');
|
|
}
|
|
for (var i = 0; i < 598; i++) {
|
|
re1.exec(s3[i]);
|
|
}
|
|
for (var i = 0; i < 454; i++) {
|
|
re1.exec(s4[i]);
|
|
}
|
|
for (var i = 0; i < 352; i++) {
|
|
/qqqq|qqq|qq|q|ZZZZ|ZZZ|ZZ|Z|llll|ll|l|uu|u|UU|U|zz|z|ff|f|gg|g|sss|ss|s|mmm|mm|m/g.exec(s5[i]);
|
|
}
|
|
for (var i = 0; i < 312; i++) {
|
|
re3.exec(s6[i]);
|
|
}
|
|
for (var i = 0; i < 282; i++) {
|
|
re4.exec(s7[i]);
|
|
}
|
|
for (var i = 0; i < 177; i++) {
|
|
s8[i].replace(re5, '');
|
|
}
|
|
for (var i = 0; i < 170; i++) {
|
|
s9[i].replace(re6, '');
|
|
re7.exec(s10[i]);
|
|
}
|
|
for (var i = 0; i < 156; i++) {
|
|
re8.exec(s11[i]);
|
|
re8.exec(s12[i]);
|
|
}
|
|
for (var i = 0; i < 144; i++) {
|
|
re0.exec(s13[i]);
|
|
}
|
|
for (var i = 0; i < 139; i++) {
|
|
s14[i].replace(re6, '');
|
|
re7.exec(s14[i]);
|
|
re9.exec('');
|
|
/JroXvg\/(\S+)/.exec(s15[i]);
|
|
}
|
|
for (var i = 0; i < 137; i++) {
|
|
s16[i].replace(re10, '');
|
|
s16[i].replace(/\[/g, '');
|
|
s17[i].replace(re11, '');
|
|
}
|
|
for (var i = 0; i < 117; i++) {
|
|
s18[i].replace(re2, '');
|
|
}
|
|
for (var i = 0; i < 95; i++) {
|
|
/(?:^|;)\s*sevraqfgre_ynat=([^;]*)/.exec(s19[i]);
|
|
}
|
|
for (var i = 0; i < 93; i++) {
|
|
s20[i].replace(re12, '');
|
|
re13.exec(s20[i]);
|
|
}
|
|
for (var i = 0; i < 92; i++) {
|
|
s21[i].replace(/([a-zA-Z]|\s)+/, '');
|
|
}
|
|
for (var i = 0; i < 85; i++) {
|
|
s22[i].replace(re14, '');
|
|
s22[i].replace(re15, '');
|
|
s23[i].replace(re12, '');
|
|
s24[i].replace(re14, '');
|
|
s24[i].replace(re15, '');
|
|
re16.exec(s25[i]);
|
|
re13.exec(s23[i]);
|
|
}
|
|
}
|
|
var re17 = /(^|[^\\])\"\\\/Qngr\((-?[0-9]+)\)\\\/\"/g;
|
|
var str2 = '{"anzr":"","ahzoreSbezng":{"PheeraplQrpvznyQvtvgf":2,"PheeraplQrpvznyFrcnengbe":".","VfErnqBayl":gehr,"PheeraplTebhcFvmrf":[3],"AhzoreTebhcFvmrf":[3],"CrepragTebhcFvmrf":[3],"PheeraplTebhcFrcnengbe":",","PheeraplFlzoby":"\xa4","AnAFlzoby":"AnA","PheeraplArtngvirCnggrea":0,"AhzoreArtngvirCnggrea":1,"CrepragCbfvgvirCnggrea":0,"CrepragArtngvirCnggrea":0,"ArtngvirVasvavglFlzoby":"-Vasvavgl","ArtngvirFvta":"-","AhzoreQrpvznyQvtvgf":2,"AhzoreQrpvznyFrcnengbe":".","AhzoreTebhcFrcnengbe":",","PheeraplCbfvgvirCnggrea":0,"CbfvgvirVasvavglFlzoby":"Vasvavgl","CbfvgvirFvta":"+","CrepragQrpvznyQvtvgf":2,"CrepragQrpvznyFrcnengbe":".","CrepragTebhcFrcnengbe":",","CrepragFlzoby":"%","CreZvyyrFlzoby":"\u2030","AngvirQvtvgf":["0","1","2","3","4","5","6","7","8","9"],"QvtvgFhofgvghgvba":1},"qngrGvzrSbezng":{"NZQrfvtangbe":"NZ","Pnyraqne":{"ZvaFhccbegrqQngrGvzr":"@-62135568000000@","ZnkFhccbegrqQngrGvzr":"@253402300799999@","NytbevguzGlcr":1,"PnyraqneGlcr":1,"Renf":[1],"GjbQvtvgLrneZnk":2029,"VfErnqBayl":gehr},"QngrFrcnengbe":"/","SvefgQnlBsJrrx":0,"PnyraqneJrrxEhyr":0,"ShyyQngrGvzrCnggrea":"qqqq, qq ZZZZ llll UU:zz:ff","YbatQngrCnggrea":"qqqq, qq ZZZZ llll","YbatGvzrCnggrea":"UU:zz:ff","ZbaguQnlCnggrea":"ZZZZ qq","CZQrfvtangbe":"CZ","ESP1123Cnggrea":"qqq, qq ZZZ llll UU\':\'zz\':\'ff \'TZG\'","FubegQngrCnggrea":"ZZ/qq/llll","FubegGvzrCnggrea":"UU:zz","FbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq\'G\'UU\':\'zz\':\'ff","GvzrFrcnengbe":":","HavirefnyFbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq UU\':\'zz\':\'ff\'M\'","LrneZbaguCnggrea":"llll ZZZZ","NooerivngrqQnlAnzrf":["Fha","Zba","Ghr","Jrq","Guh","Sev","Fng"],"FubegrfgQnlAnzrf":["Fh","Zb","Gh","Jr","Gu","Se","Fn"],"QnlAnzrf":["Fhaqnl","Zbaqnl","Ghrfqnl","Jrqarfqnl","Guhefqnl","Sevqnl","Fngheqnl"],"NooerivngrqZbaguAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""],"VfErnqBayl":gehr,"AngvirPnyraqneAnzr":"Tertbevna Pnyraqne","NooerivngrqZbaguTravgvirAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguTravgvirAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""]}}';
|
|
var str3 = '{"anzr":"ra-HF","ahzoreSbezng":{"PheeraplQrpvznyQvtvgf":2,"PheeraplQrpvznyFrcnengbe":".","VfErnqBayl":snyfr,"PheeraplTebhcFvmrf":[3],"AhzoreTebhcFvmrf":[3],"CrepragTebhcFvmrf":[3],"PheeraplTebhcFrcnengbe":",","PheeraplFlzoby":"$","AnAFlzoby":"AnA","PheeraplArtngvirCnggrea":0,"AhzoreArtngvirCnggrea":1,"CrepragCbfvgvirCnggrea":0,"CrepragArtngvirCnggrea":0,"ArtngvirVasvavglFlzoby":"-Vasvavgl","ArtngvirFvta":"-","AhzoreQrpvznyQvtvgf":2,"AhzoreQrpvznyFrcnengbe":".","AhzoreTebhcFrcnengbe":",","PheeraplCbfvgvirCnggrea":0,"CbfvgvirVasvavglFlzoby":"Vasvavgl","CbfvgvirFvta":"+","CrepragQrpvznyQvtvgf":2,"CrepragQrpvznyFrcnengbe":".","CrepragTebhcFrcnengbe":",","CrepragFlzoby":"%","CreZvyyrFlzoby":"\u2030","AngvirQvtvgf":["0","1","2","3","4","5","6","7","8","9"],"QvtvgFhofgvghgvba":1},"qngrGvzrSbezng":{"NZQrfvtangbe":"NZ","Pnyraqne":{"ZvaFhccbegrqQngrGvzr":"@-62135568000000@","ZnkFhccbegrqQngrGvzr":"@253402300799999@","NytbevguzGlcr":1,"PnyraqneGlcr":1,"Renf":[1],"GjbQvtvgLrneZnk":2029,"VfErnqBayl":snyfr},"QngrFrcnengbe":"/","SvefgQnlBsJrrx":0,"PnyraqneJrrxEhyr":0,"ShyyQngrGvzrCnggrea":"qqqq, ZZZZ qq, llll u:zz:ff gg","YbatQngrCnggrea":"qqqq, ZZZZ qq, llll","YbatGvzrCnggrea":"u:zz:ff gg","ZbaguQnlCnggrea":"ZZZZ qq","CZQrfvtangbe":"CZ","ESP1123Cnggrea":"qqq, qq ZZZ llll UU\':\'zz\':\'ff \'TZG\'","FubegQngrCnggrea":"Z/q/llll","FubegGvzrCnggrea":"u:zz gg","FbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq\'G\'UU\':\'zz\':\'ff","GvzrFrcnengbe":":","HavirefnyFbegnoyrQngrGvzrCnggrea":"llll\'-\'ZZ\'-\'qq UU\':\'zz\':\'ff\'M\'","LrneZbaguCnggrea":"ZZZZ, llll","NooerivngrqQnlAnzrf":["Fha","Zba","Ghr","Jrq","Guh","Sev","Fng"],"FubegrfgQnlAnzrf":["Fh","Zb","Gh","Jr","Gu","Se","Fn"],"QnlAnzrf":["Fhaqnl","Zbaqnl","Ghrfqnl","Jrqarfqnl","Guhefqnl","Sevqnl","Fngheqnl"],"NooerivngrqZbaguAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""],"VfErnqBayl":snyfr,"AngvirPnyraqneAnzr":"Tertbevna Pnyraqne","NooerivngrqZbaguTravgvirAnzrf":["Wna","Sro","Zne","Nce","Znl","Wha","Why","Nht","Frc","Bpg","Abi","Qrp",""],"ZbaguTravgvirAnzrf":["Wnahnel","Sroehnel","Znepu","Ncevy","Znl","Whar","Whyl","Nhthfg","Frcgrzore","Bpgbore","Abirzore","Qrprzore",""]}}';
|
|
var str4 = 'HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str5 = 'HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var re18 = /^\s+|\s+$/g;
|
|
var str6 = 'uggc://jjj.snprobbx.pbz/vaqrk.cuc';
|
|
var re19 = /(?:^|\s+)ba(?:\s+|$)/;
|
|
var re20 = /[+, ]/;
|
|
var re21 = /ybnqrq|pbzcyrgr/;
|
|
var str7 = ';;jvaqbj.IjPurpxZbhfrCbfvgvbaNQ_VQ=shapgvba(r){vs(!r)ine r=jvaqbj.rirag;ine c=-1;vs(d1)c=d1.EbyybssCnary;ine bo=IjTrgBow("IjCnayNQ_VQ_"+c);vs(bo&&bo.fglyr.ivfvovyvgl=="ivfvoyr"){ine fns=IjFns?8:0;ine pheK=r.pyvragK+IjBOFpe("U")+fns,pheL=r.pyvragL+IjBOFpe("I")+fns;ine y=IjBOEC(NQ_VQ,bo,"Y"),g=IjBOEC(NQ_VQ,bo,"G");ine e=y+d1.Cnaryf[c].Jvqgu,o=g+d1.Cnaryf[c].Urvtug;vs((pheK<y)||(pheK>e)||(pheL<g)||(pheL>o)){vs(jvaqbj.IjBaEbyybssNQ_VQ)IjBaEbyybssNQ_VQ(c);ryfr IjPybfrNq(NQ_VQ,c,gehr,"");}ryfr erghea;}IjPnapryZbhfrYvfgrareNQ_VQ();};;jvaqbj.IjFrgEbyybssCnaryNQ_VQ=shapgvba(c){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;c=IjTc(NQ_VQ,c);vs(d1&&d1.EbyybssCnary>-1)IjPnapryZbhfrYvfgrareNQ_VQ();vs(d1)d1.EbyybssCnary=c;gel{vs(q.nqqRiragYvfgrare)q.nqqRiragYvfgrare(z,s,snyfr);ryfr vs(q.nggnpuRirag)q.nggnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjPnapryZbhfrYvfgrareNQ_VQ=shapgvba(){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;vs(d1)d1.EbyybssCnary=-1;gel{vs(q.erzbirRiragYvfgrare)q.erzbirRiragYvfgrare(z,s,snyfr);ryfr vs(q.qrgnpuRirag)q.qrgnpuRirag("ba"+z,s);}pngpu(r){}};;d1.IjTc=d2(n,c){ine nq=d1;vs(vfAnA(c)){sbe(ine v=0;v<nq.Cnaryf.yratgu;v++)vs(nq.Cnaryf[v].Anzr==c)erghea v;erghea 0;}erghea c;};;d1.IjTpy=d2(n,c,p){ine cn=d1.Cnaryf[IjTc(n,c)];vs(!cn)erghea 0;vs(vfAnA(p)){sbe(ine v=0;v<cn.Pyvpxguehf.yratgu;v++)vs(cn.Pyvpxguehf[v].Anzr==p)erghea v;erghea 0;}erghea p;};;d1.IjGenpr=d2(n,f){gel{vs(jvaqbj["Ij"+"QtQ"])jvaqbj["Ij"+"QtQ"](n,1,f);}pngpu(r){}};;d1.IjYvzvg1=d2(n,f){ine nq=d1,vh=f.fcyvg("/");sbe(ine v=0,p=0;v<vh.yratgu;v++){vs(vh[v].yratgu>0){vs(nq.FzV.yratgu>0)nq.FzV+="/";nq.FzV+=vh[v];nq.FtZ[nq.FtZ.yratgu]=snyfr;}}};;d1.IjYvzvg0=d2(n,f){ine nq=d1,vh=f.fcyvg("/");sbe(ine v=0;v<vh.yratgu;v++){vs(vh[v].yratgu>0){vs(nq.OvC.yratgu>0)nq.OvC+="/";nq.OvC+=vh[v];}}};;d1.IjRVST=d2(n,c){jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]=IjTrgBow("IjCnayNQ_VQ_"+c+"_Bow");vs(jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]==ahyy)frgGvzrbhg("IjRVST(NQ_VQ,"+c+")",d1.rvsg);};;d1.IjNavzSHC=d2(n,c){ine nq=d1;vs(c>nq.Cnaryf.yratgu)erghea;ine cna=nq.Cnaryf[c],nn=gehr,on=gehr,yn=gehr,en=gehr,cn=nq.Cnaryf[0],sf=nq.ShF,j=cn.Jvqgu,u=cn.Urvtug;vs(j=="100%"){j=sf;en=snyfr;yn=snyfr;}vs(u=="100%"){u=sf;nn=snyfr;on=snyfr;}vs(cn.YnY=="Y")yn=snyfr;vs(cn.YnY=="E")en=snyfr;vs(cn.GnY=="G")nn=snyfr;vs(cn.GnY=="O")on=snyfr;ine k=0,l=0;fjvgpu(nq.NshP%8){pnfr 0:oernx;pnfr 1:vs(nn)l=-sf;oernx;pnfr 2:k=j-sf;oernx;pnfr 3:vs(en)k=j;oernx;pnfr 4:k=j-sf;l=u-sf;oernx;pnfr 5:k=j-sf;vs(on)l=u;oernx;pnfr 6:l=u-sf;oernx;pnfr 7:vs(yn)k=-sf;l=u-sf;oernx;}vs(nq.NshP++ <nq.NshG)frgGvzrbhg(("IjNavzSHC(NQ_VQ,"+c+")"),nq.NshC);ryfr{k=-1000;l=k;}cna.YrsgBssfrg=k;cna.GbcBssfrg=l;IjNhErcb(n,c);};;d1.IjTrgErnyCbfvgvba=d2(n,b,j){erghea IjBOEC.nccyl(guvf,nethzragf);};;d1.IjPnapryGvzrbhg=d2(n,c){c=IjTc(n,c);ine cay=d1.Cnaryf[c];vs(cay&&cay.UgU!=""){pyrneGvzrbhg(cay.UgU);}};;d1.IjPnapryNyyGvzrbhgf=d2(n){vs(d1.YbpxGvzrbhgPunatrf)erghea;sbe(ine c=0;c<d1.bac;c++)IjPnapryGvzrbhg(n,c);};;d1.IjFgnegGvzrbhg=d2(n,c,bG){c=IjTc(n,c);ine cay=d1.Cnaryf[c];vs(cay&&((cay.UvqrGvzrbhgInyhr>0)||(nethzragf.yratgu==3&&bG>0))){pyrneGvzrbhg(cay.UgU);cay.UgU=frgGvzrbhg(cay.UvqrNpgvba,(nethzragf.yratgu==3?bG:cay.UvqrGvzrbhgInyhr));}};;d1.IjErfrgGvzrbhg=d2(n,c,bG){c=IjTc(n,c);IjPnapryGvzrbhg(n,c);riny("IjFgnegGvzrbhg(NQ_VQ,c"+(nethzragf.yratgu==3?",bG":"")+")");};;d1.IjErfrgNyyGvzrbhgf=d2(n){sbe(ine c=0;c<d1.bac;c++)IjErfrgGvzrbhg(n,c);};;d1.IjQrgnpure=d2(n,rig,sap){gel{vs(IjQVR5)riny("jvaqbj.qrgnpuRirag(\'ba"+rig+"\',"+sap+"NQ_VQ)");ryfr vs(!IjQVRZnp)riny("jvaqbj.erzbirRiragYvfgrare(\'"+rig+"\',"+sap+"NQ_VQ,snyfr)");}pngpu(r){}};;d1.IjPyrnaHc=d2(n){IjCvat(n,"G");ine nq=d1;sbe(ine v=0;v<nq.Cnaryf.yratgu;v++){IjUvqrCnary(n,v,gehr);}gel{IjTrgBow(nq.gya).vaareUGZY="";}pngpu(r){}vs(nq.gya!=nq.gya2)gel{IjTrgBow(nq.gya2).vaareUGZY="";}pngpu(r){}gel{d1=ahyy;}pngpu(r){}gel{IjQrgnpure(n,"haybnq","IjHayNQ_VQ");}pngpu(r){}gel{jvaqbj.IjHayNQ_VQ=ahyy;}pngpu(r){}gel{IjQrgnpure(n,"fpebyy","IjFeNQ_VQ");}pngpu(r){}gel{jvaqbj.IjFeNQ_VQ=ahyy;}pngpu(r){}gel{IjQrgnpure(n,"erfvmr","IjEmNQ_VQ");}pngpu(r){}gel{jvaqbj.IjEmNQ_VQ=ahyy;}pngpu(r){}gel{IjQrgnpure(n';
|
|
var str8 = ';;jvaqbj.IjPurpxZbhfrCbfvgvbaNQ_VQ=shapgvba(r){vs(!r)ine r=jvaqbj.rirag;ine c=-1;vs(jvaqbj.IjNqNQ_VQ)c=jvaqbj.IjNqNQ_VQ.EbyybssCnary;ine bo=IjTrgBow("IjCnayNQ_VQ_"+c);vs(bo&&bo.fglyr.ivfvovyvgl=="ivfvoyr"){ine fns=IjFns?8:0;ine pheK=r.pyvragK+IjBOFpe("U")+fns,pheL=r.pyvragL+IjBOFpe("I")+fns;ine y=IjBOEC(NQ_VQ,bo,"Y"),g=IjBOEC(NQ_VQ,bo,"G");ine e=y+jvaqbj.IjNqNQ_VQ.Cnaryf[c].Jvqgu,o=g+jvaqbj.IjNqNQ_VQ.Cnaryf[c].Urvtug;vs((pheK<y)||(pheK>e)||(pheL<g)||(pheL>o)){vs(jvaqbj.IjBaEbyybssNQ_VQ)IjBaEbyybssNQ_VQ(c);ryfr IjPybfrNq(NQ_VQ,c,gehr,"");}ryfr erghea;}IjPnapryZbhfrYvfgrareNQ_VQ();};;jvaqbj.IjFrgEbyybssCnaryNQ_VQ=shapgvba(c){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;c=IjTc(NQ_VQ,c);vs(jvaqbj.IjNqNQ_VQ&&jvaqbj.IjNqNQ_VQ.EbyybssCnary>-1)IjPnapryZbhfrYvfgrareNQ_VQ();vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=c;gel{vs(q.nqqRiragYvfgrare)q.nqqRiragYvfgrare(z,s,snyfr);ryfr vs(q.nggnpuRirag)q.nggnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjPnapryZbhfrYvfgrareNQ_VQ=shapgvba(){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=-1;gel{vs(q.erzbirRiragYvfgrare)q.erzbirRiragYvfgrare(z,s,snyfr);ryfr vs(q.qrgnpuRirag)q.qrgnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjNqNQ_VQ.IjTc=shapgvba(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(vfAnA(c)){sbe(ine v=0;v<nq.Cnaryf.yratgu;v++)vs(nq.Cnaryf[v].Anzr==c)erghea v;erghea 0;}erghea c;};;jvaqbj.IjNqNQ_VQ.IjTpy=shapgvba(n,c,p){ine cn=jvaqbj.IjNqNQ_VQ.Cnaryf[IjTc(n,c)];vs(!cn)erghea 0;vs(vfAnA(p)){sbe(ine v=0;v<cn.Pyvpxguehf.yratgu;v++)vs(cn.Pyvpxguehf[v].Anzr==p)erghea v;erghea 0;}erghea p;};;jvaqbj.IjNqNQ_VQ.IjGenpr=shapgvba(n,f){gel{vs(jvaqbj["Ij"+"QtQ"])jvaqbj["Ij"+"QtQ"](n,1,f);}pngpu(r){}};;jvaqbj.IjNqNQ_VQ.IjYvzvg1=shapgvba(n,f){ine nq=jvaqbj.IjNqNQ_VQ,vh=f.fcyvg("/");sbe(ine v=0,p=0;v<vh.yratgu;v++){vs(vh[v].yratgu>0){vs(nq.FzV.yratgu>0)nq.FzV+="/";nq.FzV+=vh[v];nq.FtZ[nq.FtZ.yratgu]=snyfr;}}};;jvaqbj.IjNqNQ_VQ.IjYvzvg0=shapgvba(n,f){ine nq=jvaqbj.IjNqNQ_VQ,vh=f.fcyvg("/");sbe(ine v=0;v<vh.yratgu;v++){vs(vh[v].yratgu>0){vs(nq.OvC.yratgu>0)nq.OvC+="/";nq.OvC+=vh[v];}}};;jvaqbj.IjNqNQ_VQ.IjRVST=shapgvba(n,c){jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]=IjTrgBow("IjCnayNQ_VQ_"+c+"_Bow");vs(jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]==ahyy)frgGvzrbhg("IjRVST(NQ_VQ,"+c+")",jvaqbj.IjNqNQ_VQ.rvsg);};;jvaqbj.IjNqNQ_VQ.IjNavzSHC=shapgvba(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(c>nq.Cnaryf.yratgu)erghea;ine cna=nq.Cnaryf[c],nn=gehr,on=gehr,yn=gehr,en=gehr,cn=nq.Cnaryf[0],sf=nq.ShF,j=cn.Jvqgu,u=cn.Urvtug;vs(j=="100%"){j=sf;en=snyfr;yn=snyfr;}vs(u=="100%"){u=sf;nn=snyfr;on=snyfr;}vs(cn.YnY=="Y")yn=snyfr;vs(cn.YnY=="E")en=snyfr;vs(cn.GnY=="G")nn=snyfr;vs(cn.GnY=="O")on=snyfr;ine k=0,l=0;fjvgpu(nq.NshP%8){pnfr 0:oernx;pnfr 1:vs(nn)l=-sf;oernx;pnfr 2:k=j-sf;oernx;pnfr 3:vs(en)k=j;oernx;pnfr 4:k=j-sf;l=u-sf;oernx;pnfr 5:k=j-sf;vs(on)l=u;oernx;pnfr 6:l=u-sf;oernx;pnfr 7:vs(yn)k=-sf;l=u-sf;oernx;}vs(nq.NshP++ <nq.NshG)frgGvzrbhg(("IjNavzSHC(NQ_VQ,"+c+")"),nq.NshC);ryfr{k=-1000;l=k;}cna.YrsgBssfrg=k;cna.GbcBssfrg=l;IjNhErcb(n,c);};;jvaqbj.IjNqNQ_VQ.IjTrgErnyCbfvgvba=shapgvba(n,b,j){erghea IjBOEC.nccyl(guvf,nethzragf);};;jvaqbj.IjNqNQ_VQ.IjPnapryGvzrbhg=shapgvba(n,c){c=IjTc(n,c);ine cay=jvaqbj.IjNqNQ_VQ.Cnaryf[c];vs(cay&&cay.UgU!=""){pyrneGvzrbhg(cay.UgU);}};;jvaqbj.IjNqNQ_VQ.IjPnapryNyyGvzrbhgf=shapgvba(n){vs(jvaqbj.IjNqNQ_VQ.YbpxGvzrbhgPunatrf)erghea;sbe(ine c=0;c<jvaqbj.IjNqNQ_VQ.bac;c++)IjPnapryGvzrbhg(n,c);};;jvaqbj.IjNqNQ_VQ.IjFgnegGvzrbhg=shapgvba(n,c,bG){c=IjTc(n,c);ine cay=jvaqbj.IjNqNQ_VQ.Cnaryf[c];vs(cay&&((cay.UvqrGvzrbhgInyhr>0)||(nethzragf.yratgu==3&&bG>0))){pyrneGvzrbhg(cay.UgU);cay.UgU=frgGvzrbhg(cay.UvqrNpgvba,(nethzragf.yratgu==3?bG:cay.UvqrGvzrbhgInyhr));}};;jvaqbj.IjNqNQ_VQ.IjErfrgGvzrbhg=shapgvba(n,c,bG){c=IjTc(n,c);IjPnapryGvzrbhg(n,c);riny("IjFgnegGvzrbhg(NQ_VQ,c"+(nethzragf.yratgu==3?",bG":"")+")");};;jvaqbj.IjNqNQ_VQ.IjErfrgNyyGvzrbhgf=shapgvba(n){sbe(ine c=0;c<jvaqbj.IjNqNQ_VQ.bac;c++)IjErfrgGvzrbhg(n,c);};;jvaqbj.IjNqNQ_VQ.IjQrgnpure=shapgvba(n,rig,sap){gel{vs(IjQVR5)riny("jvaqbj.qrgnpuRirag(\'ba"+rig+"\',"+sap+"NQ_VQ)");ryfr vs(!IjQVRZnp)riny("jvaqbj.erzbir';
|
|
var str9 = ';;jvaqbj.IjPurpxZbhfrCbfvgvbaNQ_VQ=shapgvba(r){vs(!r)ine r=jvaqbj.rirag;ine c=-1;vs(jvaqbj.IjNqNQ_VQ)c=jvaqbj.IjNqNQ_VQ.EbyybssCnary;ine bo=IjTrgBow("IjCnayNQ_VQ_"+c);vs(bo&&bo.fglyr.ivfvovyvgl=="ivfvoyr"){ine fns=IjFns?8:0;ine pheK=r.pyvragK+IjBOFpe("U")+fns,pheL=r.pyvragL+IjBOFpe("I")+fns;ine y=IjBOEC(NQ_VQ,bo,"Y"),g=IjBOEC(NQ_VQ,bo,"G");ine e=y+jvaqbj.IjNqNQ_VQ.Cnaryf[c].Jvqgu,o=g+jvaqbj.IjNqNQ_VQ.Cnaryf[c].Urvtug;vs((pheK<y)||(pheK>e)||(pheL<g)||(pheL>o)){vs(jvaqbj.IjBaEbyybssNQ_VQ)IjBaEbyybssNQ_VQ(c);ryfr IjPybfrNq(NQ_VQ,c,gehr,"");}ryfr erghea;}IjPnapryZbhfrYvfgrareNQ_VQ();};;jvaqbj.IjFrgEbyybssCnaryNQ_VQ=shapgvba(c){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;c=IjTc(NQ_VQ,c);vs(jvaqbj.IjNqNQ_VQ&&jvaqbj.IjNqNQ_VQ.EbyybssCnary>-1)IjPnapryZbhfrYvfgrareNQ_VQ();vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=c;gel{vs(q.nqqRiragYvfgrare)q.nqqRiragYvfgrare(z,s,snyfr);ryfr vs(q.nggnpuRirag)q.nggnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjPnapryZbhfrYvfgrareNQ_VQ=shapgvba(){ine z="zbhfrzbir",q=qbphzrag,s=IjPurpxZbhfrCbfvgvbaNQ_VQ;vs(jvaqbj.IjNqNQ_VQ)jvaqbj.IjNqNQ_VQ.EbyybssCnary=-1;gel{vs(q.erzbirRiragYvfgrare)q.erzbirRiragYvfgrare(z,s,snyfr);ryfr vs(q.qrgnpuRirag)q.qrgnpuRirag("ba"+z,s);}pngpu(r){}};;jvaqbj.IjNqNQ_VQ.IjTc=d2(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(vfAnA(c)){sbe(ine v=0;v<nq.Cnaryf.yratgu;v++)vs(nq.Cnaryf[v].Anzr==c)erghea v;erghea 0;}erghea c;};;jvaqbj.IjNqNQ_VQ.IjTpy=d2(n,c,p){ine cn=jvaqbj.IjNqNQ_VQ.Cnaryf[IjTc(n,c)];vs(!cn)erghea 0;vs(vfAnA(p)){sbe(ine v=0;v<cn.Pyvpxguehf.yratgu;v++)vs(cn.Pyvpxguehf[v].Anzr==p)erghea v;erghea 0;}erghea p;};;jvaqbj.IjNqNQ_VQ.IjGenpr=d2(n,f){gel{vs(jvaqbj["Ij"+"QtQ"])jvaqbj["Ij"+"QtQ"](n,1,f);}pngpu(r){}};;jvaqbj.IjNqNQ_VQ.IjYvzvg1=d2(n,f){ine nq=jvaqbj.IjNqNQ_VQ,vh=f.fcyvg("/");sbe(ine v=0,p=0;v<vh.yratgu;v++){vs(vh[v].yratgu>0){vs(nq.FzV.yratgu>0)nq.FzV+="/";nq.FzV+=vh[v];nq.FtZ[nq.FtZ.yratgu]=snyfr;}}};;jvaqbj.IjNqNQ_VQ.IjYvzvg0=d2(n,f){ine nq=jvaqbj.IjNqNQ_VQ,vh=f.fcyvg("/");sbe(ine v=0;v<vh.yratgu;v++){vs(vh[v].yratgu>0){vs(nq.OvC.yratgu>0)nq.OvC+="/";nq.OvC+=vh[v];}}};;jvaqbj.IjNqNQ_VQ.IjRVST=d2(n,c){jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]=IjTrgBow("IjCnayNQ_VQ_"+c+"_Bow");vs(jvaqbj["IjCnayNQ_VQ_"+c+"_Bow"]==ahyy)frgGvzrbhg("IjRVST(NQ_VQ,"+c+")",jvaqbj.IjNqNQ_VQ.rvsg);};;jvaqbj.IjNqNQ_VQ.IjNavzSHC=d2(n,c){ine nq=jvaqbj.IjNqNQ_VQ;vs(c>nq.Cnaryf.yratgu)erghea;ine cna=nq.Cnaryf[c],nn=gehr,on=gehr,yn=gehr,en=gehr,cn=nq.Cnaryf[0],sf=nq.ShF,j=cn.Jvqgu,u=cn.Urvtug;vs(j=="100%"){j=sf;en=snyfr;yn=snyfr;}vs(u=="100%"){u=sf;nn=snyfr;on=snyfr;}vs(cn.YnY=="Y")yn=snyfr;vs(cn.YnY=="E")en=snyfr;vs(cn.GnY=="G")nn=snyfr;vs(cn.GnY=="O")on=snyfr;ine k=0,l=0;fjvgpu(nq.NshP%8){pnfr 0:oernx;pnfr 1:vs(nn)l=-sf;oernx;pnfr 2:k=j-sf;oernx;pnfr 3:vs(en)k=j;oernx;pnfr 4:k=j-sf;l=u-sf;oernx;pnfr 5:k=j-sf;vs(on)l=u;oernx;pnfr 6:l=u-sf;oernx;pnfr 7:vs(yn)k=-sf;l=u-sf;oernx;}vs(nq.NshP++ <nq.NshG)frgGvzrbhg(("IjNavzSHC(NQ_VQ,"+c+")"),nq.NshC);ryfr{k=-1000;l=k;}cna.YrsgBssfrg=k;cna.GbcBssfrg=l;IjNhErcb(n,c);};;jvaqbj.IjNqNQ_VQ.IjTrgErnyCbfvgvba=d2(n,b,j){erghea IjBOEC.nccyl(guvf,nethzragf);};;jvaqbj.IjNqNQ_VQ.IjPnapryGvzrbhg=d2(n,c){c=IjTc(n,c);ine cay=jvaqbj.IjNqNQ_VQ.Cnaryf[c];vs(cay&&cay.UgU!=""){pyrneGvzrbhg(cay.UgU);}};;jvaqbj.IjNqNQ_VQ.IjPnapryNyyGvzrbhgf=d2(n){vs(jvaqbj.IjNqNQ_VQ.YbpxGvzrbhgPunatrf)erghea;sbe(ine c=0;c<jvaqbj.IjNqNQ_VQ.bac;c++)IjPnapryGvzrbhg(n,c);};;jvaqbj.IjNqNQ_VQ.IjFgnegGvzrbhg=d2(n,c,bG){c=IjTc(n,c);ine cay=jvaqbj.IjNqNQ_VQ.Cnaryf[c];vs(cay&&((cay.UvqrGvzrbhgInyhr>0)||(nethzragf.yratgu==3&&bG>0))){pyrneGvzrbhg(cay.UgU);cay.UgU=frgGvzrbhg(cay.UvqrNpgvba,(nethzragf.yratgu==3?bG:cay.UvqrGvzrbhgInyhr));}};;jvaqbj.IjNqNQ_VQ.IjErfrgGvzrbhg=d2(n,c,bG){c=IjTc(n,c);IjPnapryGvzrbhg(n,c);riny("IjFgnegGvzrbhg(NQ_VQ,c"+(nethzragf.yratgu==3?",bG":"")+")");};;jvaqbj.IjNqNQ_VQ.IjErfrgNyyGvzrbhgf=d2(n){sbe(ine c=0;c<jvaqbj.IjNqNQ_VQ.bac;c++)IjErfrgGvzrbhg(n,c);};;jvaqbj.IjNqNQ_VQ.IjQrgnpure=d2(n,rig,sap){gel{vs(IjQVR5)riny("jvaqbj.qrgnpuRirag(\'ba"+rig+"\',"+sap+"NQ_VQ)");ryfr vs(!IjQVRZnp)riny("jvaqbj.erzbirRiragYvfgrare(\'"+rig+"\',"+sap+"NQ_VQ,snyfr)");}pngpu(r){}};;jvaqbj.IjNqNQ_VQ.IjPyrna';
|
|
|
|
var s26 = computeInputVariants('VC=74.125.75.1', 81);
|
|
var s27 = computeInputVariants('9.0 e115', 78);
|
|
var s28 = computeInputVariants('k',78);
|
|
var s29 = computeInputVariants(str2, 81);
|
|
var s30 = computeInputVariants(str3, 81);
|
|
var s31 = computeInputVariants('144631658', 78);
|
|
var s32 = computeInputVariants('Pbhagel=IIZ%3Q', 78);
|
|
var s33 = computeInputVariants('Pbhagel=IIZ=', 78);
|
|
var s34 = computeInputVariants('CersreerqPhygherCraqvat=', 78);
|
|
var s35 = computeInputVariants(str4, 78);
|
|
var s36 = computeInputVariants(str5, 78);
|
|
var s37 = computeInputVariants('__hgzp=144631658', 78);
|
|
var s38 = computeInputVariants('gvzrMbar=-8', 78);
|
|
var s39 = computeInputVariants('gvzrMbar=0', 78);
|
|
// var s40 = computeInputVariants(s15[i], 78);
|
|
var s41 = computeInputVariants('vachggrkg QBZPbageby_cynprubyqre', 78);
|
|
var s42 = computeInputVariants('xrlqbja', 78);
|
|
var s43 = computeInputVariants('xrlhc', 78);
|
|
var s44 = computeInputVariants('uggc://zrffntvat.zlfcnpr.pbz/vaqrk.psz', 77);
|
|
var s45 = computeInputVariants('FrffvbaFgbentr=%7O%22GnoThvq%22%3N%7O%22thvq%22%3N1231367125017%7Q%7Q', 73);
|
|
var s46 = computeInputVariants(str6, 72);
|
|
var s47 = computeInputVariants('3.5.0.0', 70);
|
|
var s48 = computeInputVariants(str7, 70);
|
|
var s49 = computeInputVariants(str8, 70);
|
|
var s50 = computeInputVariants(str9, 70);
|
|
var s51 = computeInputVariants('NI%3Q1_CI%3Q1_PI%3Q1_EI%3Q1_HI%3Q1_HP%3Q1_IC%3Q0.0.0.0_IH%3Q0', 70);
|
|
var s52 = computeInputVariants('svz_zlfcnpr_ubzrcntr_abgybttrqva,svz_zlfcnpr_aba_HTP,svz_zlfcnpr_havgrq-fgngrf', 70);
|
|
var s53 = computeInputVariants('ybnqvat', 70);
|
|
var s54 = computeInputVariants('#', 68);
|
|
var s55 = computeInputVariants('ybnqrq', 68);
|
|
var s56 = computeInputVariants('pbybe', 49);
|
|
var s57 = computeInputVariants('uggc://sevraqf.zlfcnpr.pbz/vaqrk.psz', 44);
|
|
|
|
function runBlock1() {
|
|
for (var i = 0; i < 81; i++) {
|
|
re8.exec(s26[i]);
|
|
}
|
|
for (var i = 0; i < 78; i++) {
|
|
s27[i].replace(/(\s)+e/, '');
|
|
s28[i].replace(/./, '');
|
|
s29[i].replace(re17, '');
|
|
s30[i].replace(re17, '');
|
|
re8.exec(s31[i]);
|
|
re8.exec(s32[i]);
|
|
re8.exec(s33[i]);
|
|
re8.exec(s34[i]);
|
|
re8.exec(s35[i]);
|
|
re8.exec(s36[i]);
|
|
re8.exec(s37[i]);
|
|
re8.exec(s38[i]);
|
|
re8.exec(s39[i]);
|
|
/Fnsnev\/(\d+\.\d+)/.exec(s15[i]);
|
|
re3.exec(s41[i]);
|
|
re0.exec(s42[i]);
|
|
re0.exec(s43[i]);
|
|
}
|
|
for (var i = 0; i < 77; i++) {
|
|
s44[i].replace(re12, '');
|
|
re13.exec(s44[i]);
|
|
}
|
|
for (var i = 0; i < 73; i++) {
|
|
s45[i].replace(re18, '');
|
|
}
|
|
for (var i = 0; i < 72; i++) {
|
|
re1.exec(s46[i]);
|
|
}
|
|
for (var i = 0; i < 71; i++) {
|
|
re19.exec('');
|
|
}
|
|
for (var i = 0; i < 70; i++) {
|
|
s47[i].replace(re11, '');
|
|
s48[i].replace(/d1/g, '');
|
|
s49[i].replace(/NQ_VQ/g, '');
|
|
s50[i].replace(/d2/g, '');
|
|
s51[i].replace(/_/g, '');
|
|
s52[i].split(re20);
|
|
re21.exec(s53[i]);
|
|
}
|
|
for (var i = 0; i < 68; i++) {
|
|
re1.exec(s54[i]);
|
|
/(?:ZFVR.(\d+\.\d+))|(?:(?:Sversbk|TenaCnenqvfb|Vprjrnfry).(\d+\.\d+))|(?:Bcren.(\d+\.\d+))|(?:NccyrJroXvg.(\d+(?:\.\d+)?))/.exec(s15[i]);
|
|
/(Znp BF K)|(Jvaqbjf;)/.exec(s15[i]);
|
|
/Trpxb\/([0-9]+)/.exec(s15[i]);
|
|
re21.exec(s55[i]);
|
|
}
|
|
for (var i = 0; i < 49; i++) {
|
|
re16.exec(s56[i]);
|
|
}
|
|
for (var i = 0; i < 44; i++) {
|
|
s57[i].replace(re12, '');
|
|
re13.exec(s57[i]);
|
|
}
|
|
}
|
|
var re22 = /\bso_zrah\b/;
|
|
var re23 = /^(?:(?:[^:\/?#]+):)?(?:\/\/(?:[^\/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/;
|
|
var re24 = /uggcf?:\/\/([^\/]+\.)?snprobbx\.pbz\//;
|
|
var re25 = /"/g;
|
|
var re26 = /^([^?#]+)(?:\?([^#]*))?(#.*)?/;
|
|
var s57a = computeInputVariants('fryrpgrq', 40);
|
|
var s58 = computeInputVariants('vachggrkg uvqqra_ryrz', 40);
|
|
var s59 = computeInputVariants('vachggrkg ', 40);
|
|
var s60 = computeInputVariants('vachggrkg', 40);
|
|
var s61 = computeInputVariants('uggc://jjj.snprobbx.pbz/', 40);
|
|
var s62 = computeInputVariants('uggc://jjj.snprobbx.pbz/ybtva.cuc', 40);
|
|
var s63 = computeInputVariants('Funer guvf tnqtrg', 40);
|
|
var s64 = computeInputVariants('uggc://jjj.tbbtyr.pbz/vt/qverpgbel', 40);
|
|
var s65 = computeInputVariants('419', 40);
|
|
var s66 = computeInputVariants('gvzrfgnzc', 40);
|
|
|
|
function runBlock2() {
|
|
for (var i = 0; i < 40; i++) {
|
|
s57a[i].replace(re14, '');
|
|
s57a[i].replace(re15, '');
|
|
}
|
|
for (var i = 0; i < 39; i++) {
|
|
s58[i].replace(/\buvqqra_ryrz\b/g, '');
|
|
re3.exec(s59[i]);
|
|
re3.exec(s60[i]);
|
|
re22.exec('HVYvaxOhggba');
|
|
re22.exec('HVYvaxOhggba_E');
|
|
re22.exec('HVYvaxOhggba_EJ');
|
|
re22.exec('zrah_ybtva_pbagnvare');
|
|
/\buvqqra_ryrz\b/.exec('vachgcnffjbeq');
|
|
}
|
|
for (var i = 0; i < 37; i++) {
|
|
re8.exec('111soqs57qo8o8480qo18sor2011r3n591q7s6s37r120904');
|
|
re8.exec('SbeprqRkcvengvba=633669315660164980');
|
|
re8.exec('FrffvbaQQS2=111soqs57qo8o8480qo18sor2011r3n591q7s6s37r120904');
|
|
}
|
|
for (var i = 0; i < 35; i++) {
|
|
'puvyq p1 svefg'.replace(re14, '');
|
|
'puvyq p1 svefg'.replace(re15, '');
|
|
'sylbhg pybfrq'.replace(re14, '');
|
|
'sylbhg pybfrq'.replace(re15, '');
|
|
}
|
|
for (var i = 0; i < 34; i++) {
|
|
re19.exec('gno2');
|
|
re19.exec('gno3');
|
|
re8.exec('44132r503660');
|
|
re8.exec('SbeprqRkcvengvba=633669316860113296');
|
|
re8.exec('AFP_zp_dfctwzs-aowb_80=44132r503660');
|
|
re8.exec('FrffvbaQQS2=s6r4579npn4rn2135s904r0s75pp1o5334p6s6pospo12696');
|
|
re8.exec('s6r4579npn4rn2135s904r0s75pp1o5334p6s6pospo12696');
|
|
}
|
|
for (var i = 0; i < 32; i++) {
|
|
/puebzr/i.exec(s15[i]);
|
|
}
|
|
for (var i = 0; i < 31; i++) {
|
|
s61[i].replace(re23, '');
|
|
re8.exec('SbeprqRkcvengvba=633669358527244818');
|
|
re8.exec('VC=66.249.85.130');
|
|
re8.exec('FrffvbaQQS2=s15q53p9n372sn76npr13o271n4s3p5r29p235746p908p58');
|
|
re8.exec('s15q53p9n372sn76npr13o271n4s3p5r29p235746p908p58');
|
|
re24.exec(s61[i]);
|
|
}
|
|
for (var i = 0; i < 30; i++) {
|
|
s65[i].replace(re6, '');
|
|
/(?:^|\s+)gvzrfgnzc(?:\s+|$)/.exec(s66[i]);
|
|
re7.exec(s65[i]);
|
|
}
|
|
for (var i = 0; i < 29; i++) {
|
|
s62[i].replace(re23, '');
|
|
}
|
|
for (var i = 0; i < 28; i++) {
|
|
s63[i].replace(re25, '');
|
|
s63[i].replace(re12, '');
|
|
re26.exec(s64[i]);
|
|
}
|
|
}
|
|
var re27 = /-\D/g;
|
|
var re28 = /\bnpgvingr\b/;
|
|
var re29 = /%2R/gi;
|
|
var re30 = /%2S/gi;
|
|
var re31 = /^(mu-(PA|GJ)|wn|xb)$/;
|
|
var re32 = /\s?;\s?/;
|
|
var re33 = /%\w?$/;
|
|
var re34 = /TNQP=([^;]*)/i;
|
|
var str10 = 'FrffvbaQQS2=111soqs57qo8o8480qo18sor2011r3n591q7s6s37r120904; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669315660164980&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str11 = 'FrffvbaQQS2=111soqs57qo8o8480qo18sor2011r3n591q7s6s37r120904; __hgzm=144631658.1231363570.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.3426875219718084000.1231363570.1231363570.1231363570.1; __hgzo=144631658.0.10.1231363570; __hgzp=144631658; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669315660164980&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str12 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231363514065&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231363514065&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Subzr.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1326469221.1231363557&tn_fvq=1231363557&tn_uvq=1114636509&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str13 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669315660164980&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str14 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669315660164980&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var re35 = /[<>]/g;
|
|
var str15 = 'FrffvbaQQS2=s6r4579npn4rn2135s904r0s75pp1o5334p6s6pospo12696; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669316860113296&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_dfctwzs-aowb_80=44132r503660';
|
|
var str16 = 'FrffvbaQQS2=s6r4579npn4rn2135s904r0s75pp1o5334p6s6pospo12696; AFP_zp_dfctwzs-aowb_80=44132r503660; __hgzm=144631658.1231363638.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.965867047679498800.1231363638.1231363638.1231363638.1; __hgzo=144631658.0.10.1231363638; __hgzp=144631658; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669316860113296&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str17 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231363621014&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231363621014&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Scebsvyr.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=348699119.1231363624&tn_fvq=1231363624&tn_uvq=895511034&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str18 = 'uggc://jjj.yrobapbva.se/yv';
|
|
var str19 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669316860113296&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str20 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669316860113296&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
|
|
var s67 = computeInputVariants('e115', 27);
|
|
var s68 = computeInputVariants('qvfcynl', 27);
|
|
var s69 = computeInputVariants('cbfvgvba', 27);
|
|
var s70 = computeInputVariants('uggc://jjj.zlfcnpr.pbz/', 27);
|
|
var s71 = computeInputVariants('cntrivrj', 27);
|
|
var s72 = computeInputVariants('VC=74.125.75.3', 27);
|
|
var s73 = computeInputVariants('ra', 27);
|
|
var s74 = computeInputVariants(str10, 27);
|
|
var s75 = computeInputVariants(str11, 27);
|
|
var s76 = computeInputVariants(str12, 27);
|
|
var s77 = computeInputVariants(str17, 27);
|
|
var s78 = computeInputVariants(str18, 27);
|
|
|
|
function runBlock3() {
|
|
for (var i = 0; i < 27; i++) {
|
|
s67[i].replace(/[A-Za-z]/g, '');
|
|
}
|
|
for (var i = 0; i < 23; i++) {
|
|
s68[i].replace(re27, '');
|
|
s69[i].replace(re27, '');
|
|
}
|
|
for (var i = 0; i < 22; i++) {
|
|
'unaqyr'.replace(re14, '');
|
|
'unaqyr'.replace(re15, '');
|
|
'yvar'.replace(re14, '');
|
|
'yvar'.replace(re15, '');
|
|
'cnerag puebzr6 fvatyr1 gno'.replace(re14, '');
|
|
'cnerag puebzr6 fvatyr1 gno'.replace(re15, '');
|
|
'fyvqre'.replace(re14, '');
|
|
'fyvqre'.replace(re15, '');
|
|
re28.exec('');
|
|
}
|
|
for (var i = 0; i < 21; i++) {
|
|
s70[i].replace(re12, '');
|
|
re13.exec(s70[i]);
|
|
}
|
|
for (var i = 0; i < 20; i++) {
|
|
s71[i].replace(re29, '');
|
|
s71[i].replace(re30, '');
|
|
re19.exec('ynfg');
|
|
re19.exec('ba svefg');
|
|
re8.exec(s72[i]);
|
|
}
|
|
for (var i = 0; i < 19; i++) {
|
|
re31.exec(s73[i]);
|
|
}
|
|
for (var i = 0; i < 18; i++) {
|
|
s74[i].split(re32);
|
|
s75[i].split(re32);
|
|
s76[i].replace(re33, '');
|
|
re8.exec('144631658.0.10.1231363570');
|
|
re8.exec('144631658.1231363570.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.3426875219718084000.1231363570.1231363570.1231363570.1');
|
|
re8.exec(str13);
|
|
re8.exec(str14);
|
|
re8.exec('__hgzn=144631658.3426875219718084000.1231363570.1231363570.1231363570.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231363570');
|
|
re8.exec('__hgzm=144631658.1231363570.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re34.exec(s74[i]);
|
|
re34.exec(s75[i]);
|
|
}
|
|
for (var i = 0; i < 17; i++) {
|
|
s15[i].match(/zfvr/gi);
|
|
s15[i].match(/bcren/gi);
|
|
str15.split(re32);
|
|
str16.split(re32);
|
|
'ohggba'.replace(re14, '');
|
|
'ohggba'.replace(re15, '');
|
|
'puvyq p1 svefg sylbhg pybfrq'.replace(re14, '');
|
|
'puvyq p1 svefg sylbhg pybfrq'.replace(re15, '');
|
|
'pvgvrf'.replace(re14, '');
|
|
'pvgvrf'.replace(re15, '');
|
|
'pybfrq'.replace(re14, '');
|
|
'pybfrq'.replace(re15, '');
|
|
'qry'.replace(re14, '');
|
|
'qry'.replace(re15, '');
|
|
'uqy_zba'.replace(re14, '');
|
|
'uqy_zba'.replace(re15, '');
|
|
s77[i].replace(re33, '');
|
|
s78[i].replace(/%3P/g, '');
|
|
s78[i].replace(/%3R/g, '');
|
|
s78[i].replace(/%3q/g, '');
|
|
s78[i].replace(re35, '');
|
|
'yvaxyvfg16'.replace(re14, '');
|
|
'yvaxyvfg16'.replace(re15, '');
|
|
'zvahf'.replace(re14, '');
|
|
'zvahf'.replace(re15, '');
|
|
'bcra'.replace(re14, '');
|
|
'bcra'.replace(re15, '');
|
|
'cnerag puebzr5 fvatyr1 ps NU'.replace(re14, '');
|
|
'cnerag puebzr5 fvatyr1 ps NU'.replace(re15, '');
|
|
'cynlre'.replace(re14, '');
|
|
'cynlre'.replace(re15, '');
|
|
'cyhf'.replace(re14, '');
|
|
'cyhf'.replace(re15, '');
|
|
'cb_uqy'.replace(re14, '');
|
|
'cb_uqy'.replace(re15, '');
|
|
'hyJVzt'.replace(re14, '');
|
|
'hyJVzt'.replace(re15, '');
|
|
re8.exec('144631658.0.10.1231363638');
|
|
re8.exec('144631658.1231363638.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.965867047679498800.1231363638.1231363638.1231363638.1');
|
|
re8.exec('4413268q3660');
|
|
re8.exec('4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n');
|
|
re8.exec('SbeprqRkcvengvba=633669321699093060');
|
|
re8.exec('VC=74.125.75.20');
|
|
re8.exec(str19);
|
|
re8.exec(str20);
|
|
re8.exec('AFP_zp_tfwsbrg-aowb_80=4413268q3660');
|
|
re8.exec('FrffvbaQQS2=4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n');
|
|
re8.exec('__hgzn=144631658.965867047679498800.1231363638.1231363638.1231363638.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231363638');
|
|
re8.exec('__hgzm=144631658.1231363638.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re34.exec(str15);
|
|
re34.exec(str16);
|
|
}
|
|
}
|
|
var re36 = /uers|fep|fryrpgrq/;
|
|
var re37 = /\s*([+>~\s])\s*([a-zA-Z#.*:\[])/g;
|
|
var re38 = /^(\w+|\*)$/;
|
|
var str21 = 'FrffvbaQQS2=s15q53p9n372sn76npr13o271n4s3p5r29p235746p908p58; ZFPhygher=VC=66.249.85.130&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669358527244818&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str22 = 'FrffvbaQQS2=s15q53p9n372sn76npr13o271n4s3p5r29p235746p908p58; __hgzm=144631658.1231367822.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.4127520630321984500.1231367822.1231367822.1231367822.1; __hgzo=144631658.0.10.1231367822; __hgzp=144631658; ZFPhygher=VC=66.249.85.130&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669358527244818&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str23 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231367803797&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231367803797&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Szrffntvat.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1192552091.1231367807&tn_fvq=1231367807&tn_uvq=1155446857&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str24 = 'ZFPhygher=VC=66.249.85.130&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669358527244818&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str25 = 'ZFPhygher=VC=66.249.85.130&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669358527244818&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str26 = 'hy.ynat-fryrpgbe';
|
|
var re39 = /\\/g;
|
|
var re40 = / /g;
|
|
var re41 = /\/\xc4\/t/;
|
|
var re42 = /\/\xd6\/t/;
|
|
var re43 = /\/\xdc\/t/;
|
|
var re44 = /\/\xdf\/t/;
|
|
var re45 = /\/\xe4\/t/;
|
|
var re46 = /\/\xf6\/t/;
|
|
var re47 = /\/\xfc\/t/;
|
|
var re48 = /\W/g;
|
|
var re49 = /uers|fep|fglyr/;
|
|
var s79 = computeInputVariants(str21, 16);
|
|
var s80 = computeInputVariants(str22, 16);
|
|
var s81 = computeInputVariants(str23, 16);
|
|
var s82 = computeInputVariants(str26, 16);
|
|
|
|
function runBlock4() {
|
|
for (var i = 0; i < 16; i++) {
|
|
''.replace(/\*/g, '');
|
|
/\bnpgvir\b/.exec('npgvir');
|
|
/sversbk/i.exec(s15[i]);
|
|
re36.exec('glcr');
|
|
/zfvr/i.exec(s15[i]);
|
|
/bcren/i.exec(s15[i]);
|
|
}
|
|
for (var i = 0; i < 15; i++) {
|
|
s79[i].split(re32);
|
|
s80[i].split(re32);
|
|
'uggc://ohyyrgvaf.zlfcnpr.pbz/vaqrk.psz'.replace(re12, '');
|
|
s81[i].replace(re33, '');
|
|
'yv'.replace(re37, '');
|
|
'yv'.replace(re18, '');
|
|
re8.exec('144631658.0.10.1231367822');
|
|
re8.exec('144631658.1231367822.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.4127520630321984500.1231367822.1231367822.1231367822.1');
|
|
re8.exec(str24);
|
|
re8.exec(str25);
|
|
re8.exec('__hgzn=144631658.4127520630321984500.1231367822.1231367822.1231367822.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231367822');
|
|
re8.exec('__hgzm=144631658.1231367822.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re34.exec(s79[i]);
|
|
re34.exec(s80[i]);
|
|
/\.([\w-]+)|\[(\w+)(?:([!*^$~|]?=)["']?(.*?)["']?)?\]|:([\w-]+)(?:\(["']?(.*?)?["']?\)|$)/g.exec(s82[i]);
|
|
re13.exec('uggc://ohyyrgvaf.zlfcnpr.pbz/vaqrk.psz');
|
|
re38.exec('yv');
|
|
}
|
|
for (var i = 0; i < 14; i++) {
|
|
''.replace(re18, '');
|
|
'9.0 e115'.replace(/(\s+e|\s+o[0-9]+)/, '');
|
|
'Funer guvf tnqtrg'.replace(/</g, '');
|
|
'Funer guvf tnqtrg'.replace(/>/g, '');
|
|
'Funer guvf tnqtrg'.replace(re39, '');
|
|
'uggc://cebsvyrrqvg.zlfcnpr.pbz/vaqrk.psz'.replace(re12, '');
|
|
'grnfre'.replace(re40, '');
|
|
'grnfre'.replace(re41, '');
|
|
'grnfre'.replace(re42, '');
|
|
'grnfre'.replace(re43, '');
|
|
'grnfre'.replace(re44, '');
|
|
'grnfre'.replace(re45, '');
|
|
'grnfre'.replace(re46, '');
|
|
'grnfre'.replace(re47, '');
|
|
'grnfre'.replace(re48, '');
|
|
re16.exec('znetva-gbc');
|
|
re16.exec('cbfvgvba');
|
|
re19.exec('gno1');
|
|
re9.exec('qz');
|
|
re9.exec('qg');
|
|
re9.exec('zbqobk');
|
|
re9.exec('zbqobkva');
|
|
re9.exec('zbqgvgyr');
|
|
re13.exec('uggc://cebsvyrrqvg.zlfcnpr.pbz/vaqrk.psz');
|
|
re26.exec('/vt/znvytnqtrg');
|
|
re49.exec('glcr');
|
|
}
|
|
}
|
|
var re50 = /(?:^|\s+)fryrpgrq(?:\s+|$)/;
|
|
var re51 = /\&/g;
|
|
var re52 = /\+/g;
|
|
var re53 = /\?/g;
|
|
var re54 = /\t/g;
|
|
var re55 = /(\$\{nqiHey\})|(\$nqiHey\b)/g;
|
|
var re56 = /(\$\{cngu\})|(\$cngu\b)/g;
|
|
function runBlock5() {
|
|
for (var i = 0; i < 13; i++) {
|
|
'purpx'.replace(re14, '');
|
|
'purpx'.replace(re15, '');
|
|
'pvgl'.replace(re14, '');
|
|
'pvgl'.replace(re15, '');
|
|
'qrpe fyvqrgrkg'.replace(re14, '');
|
|
'qrpe fyvqrgrkg'.replace(re15, '');
|
|
'svefg fryrpgrq'.replace(re14, '');
|
|
'svefg fryrpgrq'.replace(re15, '');
|
|
'uqy_rag'.replace(re14, '');
|
|
'uqy_rag'.replace(re15, '');
|
|
'vape fyvqrgrkg'.replace(re14, '');
|
|
'vape fyvqrgrkg'.replace(re15, '');
|
|
'vachggrkg QBZPbageby_cynprubyqre'.replace(re5, '');
|
|
'cnerag puebzr6 fvatyr1 gno fryrpgrq'.replace(re14, '');
|
|
'cnerag puebzr6 fvatyr1 gno fryrpgrq'.replace(re15, '');
|
|
'cb_guz'.replace(re14, '');
|
|
'cb_guz'.replace(re15, '');
|
|
'fhozvg'.replace(re14, '');
|
|
'fhozvg'.replace(re15, '');
|
|
re50.exec('');
|
|
/NccyrJroXvg\/([^\s]*)/.exec(s15[i]);
|
|
/XUGZY/.exec(s15[i]);
|
|
}
|
|
for (var i = 0; i < 12; i++) {
|
|
'${cebg}://${ubfg}${cngu}/${dz}'.replace(/(\$\{cebg\})|(\$cebg\b)/g, '');
|
|
'1'.replace(re40, '');
|
|
'1'.replace(re10, '');
|
|
'1'.replace(re51, '');
|
|
'1'.replace(re52, '');
|
|
'1'.replace(re53, '');
|
|
'1'.replace(re39, '');
|
|
'1'.replace(re54, '');
|
|
'9.0 e115'.replace(/^(.*)\..*$/, '');
|
|
'9.0 e115'.replace(/^.*e(.*)$/, '');
|
|
'<!-- ${nqiHey} -->'.replace(re55, '');
|
|
'<fpevcg glcr="grkg/wninfpevcg" fep="${nqiHey}"></fpevcg>'.replace(re55, '');
|
|
s21[i].replace(/^.*\s+(\S+\s+\S+$)/, '');
|
|
'tzk%2Subzrcntr%2Sfgneg%2Sqr%2S'.replace(re30, '');
|
|
'tzk'.replace(re30, '');
|
|
'uggc://${ubfg}${cngu}/${dz}'.replace(/(\$\{ubfg\})|(\$ubfg\b)/g, '');
|
|
'uggc://nqpyvrag.hvzfrei.arg${cngu}/${dz}'.replace(re56, '');
|
|
'uggc://nqpyvrag.hvzfrei.arg/wf.at/${dz}'.replace(/(\$\{dz\})|(\$dz\b)/g, '');
|
|
'frpgvba'.replace(re29, '');
|
|
'frpgvba'.replace(re30, '');
|
|
'fvgr'.replace(re29, '');
|
|
'fvgr'.replace(re30, '');
|
|
'fcrpvny'.replace(re29, '');
|
|
'fcrpvny'.replace(re30, '');
|
|
re36.exec('anzr');
|
|
/e/.exec('9.0 e115');
|
|
}
|
|
}
|
|
var re57 = /##yv4##/gi;
|
|
var re58 = /##yv16##/gi;
|
|
var re59 = /##yv19##/gi;
|
|
var str27 = '<hy pynff="nqi">##yv4##Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.##yv19##Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.##yv16##Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##</hy>';
|
|
var str28 = '<hy pynff="nqi"><yv vq="YvOYG4" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg4.cat)">Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.##yv19##Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.##yv16##Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##</hy>';
|
|
var str29 = '<hy pynff="nqi"><yv vq="YvOYG4" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg4.cat)">Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.##yv19##Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.<yv vq="YvOYG16" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg16.cat)">Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##</hy>';
|
|
var str30 = '<hy pynff="nqi"><yv vq="YvOYG4" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg4.cat)">Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.<yv vq="YvOYG19" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg19.cat)">Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.<yv vq="YvOYG16" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg16.cat)">Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.##OE## ##OE## ##N##Yrnea zber##/N##</hy>';
|
|
var str31 = '<hy pynff="nqi"><yv vq="YvOYG4" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg4.cat)">Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.<yv vq="YvOYG19" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg19.cat)">Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.<yv vq="YvOYG16" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg16.cat)">Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.<oe> <oe> ##N##Yrnea zber##/N##</hy>';
|
|
var str32 = '<hy pynff="nqi"><yv vq="YvOYG4" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg4.cat)">Cbjreshy Zvpebfbsg grpuabybtl urycf svtug fcnz naq vzcebir frphevgl.<yv vq="YvOYG19" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg19.cat)">Trg zber qbar gunaxf gb terngre rnfr naq fcrrq.<yv vq="YvOYG16" fglyr="onpxtebhaq-vzntr:hey(uggc://vzt.jykef.pbz/~Yvir.FvgrPbagrag.VQ/~14.2.1230/~/~/~/oyg16.cat)">Ybgf bs fgbentr (5 TO) - zber pbby fghss ba gur jnl.<oe> <oe> <n uers="uggc://znvy.yvir.pbz/znvy/nobhg.nfck" gnetrg="_oynax">Yrnea zber##/N##</hy>';
|
|
var str33 = 'Bar Jvaqbjf Yvir VQ trgf lbh vagb <o>Ubgznvy</o>, <o>Zrffratre</o>, <o>Kobk YVIR</o> \u2014 naq bgure cynprf lbh frr #~#argjbexybtb#~#';
|
|
var re60 = /(?:^|\s+)bss(?:\s+|$)/;
|
|
var re61 = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/;
|
|
var re62 = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/;
|
|
var str34 = '${1}://${2}${3}${4}${5}';
|
|
var str35 = ' O=6gnyg0g4znrrn&o=3&f=gc; Q=_lyu=K3bQZGSxnT4lZzD3OS9GNmV3ZGLkAQxRpTyxNmRlZmRmAmNkAQLRqTImqNZjOUEgpTjQnJ5xMKtgoN--; SCF=qy';
|
|
var s83 = computeInputVariants(str27, 11);
|
|
var s84 = computeInputVariants(str28, 11);
|
|
var s85 = computeInputVariants(str29, 11);
|
|
var s86 = computeInputVariants(str30, 11);
|
|
var s87 = computeInputVariants(str31, 11);
|
|
var s88 = computeInputVariants(str32, 11);
|
|
var s89 = computeInputVariants(str33, 11);
|
|
var s90 = computeInputVariants(str34, 11);
|
|
|
|
function runBlock6() {
|
|
for (var i = 0; i < 11; i++) {
|
|
s83[i].replace(/##yv0##/gi, '');
|
|
s83[i].replace(re57, '');
|
|
s84[i].replace(re58, '');
|
|
s85[i].replace(re59, '');
|
|
s86[i].replace(/##\/o##/gi, '');
|
|
s86[i].replace(/##\/v##/gi, '');
|
|
s86[i].replace(/##\/h##/gi, '');
|
|
s86[i].replace(/##o##/gi, '');
|
|
s86[i].replace(/##oe##/gi, '');
|
|
s86[i].replace(/##v##/gi, '');
|
|
s86[i].replace(/##h##/gi, '');
|
|
s87[i].replace(/##n##/gi, '');
|
|
s88[i].replace(/##\/n##/gi, '');
|
|
s89[i].replace(/#~#argjbexybtb#~#/g, '');
|
|
/ Zbovyr\//.exec(s15[i]);
|
|
/##yv1##/gi.exec(s83[i]);
|
|
/##yv10##/gi.exec(s84[i]);
|
|
/##yv11##/gi.exec(s84[i]);
|
|
/##yv12##/gi.exec(s84[i]);
|
|
/##yv13##/gi.exec(s84[i]);
|
|
/##yv14##/gi.exec(s84[i]);
|
|
/##yv15##/gi.exec(s84[i]);
|
|
re58.exec(s84[i]);
|
|
/##yv17##/gi.exec(s85[i]);
|
|
/##yv18##/gi.exec(s85[i]);
|
|
re59.exec(s85[i]);
|
|
/##yv2##/gi.exec(s83[i]);
|
|
/##yv20##/gi.exec(s86[i]);
|
|
/##yv21##/gi.exec(s86[i]);
|
|
/##yv22##/gi.exec(s86[i]);
|
|
/##yv23##/gi.exec(s86[i]);
|
|
/##yv3##/gi.exec(s83[i]);
|
|
re57.exec(s83[i]);
|
|
/##yv5##/gi.exec(s84[i]);
|
|
/##yv6##/gi.exec(s84[i]);
|
|
/##yv7##/gi.exec(s84[i]);
|
|
/##yv8##/gi.exec(s84[i]);
|
|
/##yv9##/gi.exec(s84[i]);
|
|
re8.exec('473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29');
|
|
re8.exec('SbeprqRkcvengvba=633669325184628362');
|
|
re8.exec('FrffvbaQQS2=473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29');
|
|
/AbxvnA[^\/]*/.exec(s15[i]);
|
|
}
|
|
for (var i = 0; i < 10; i++) {
|
|
' bss'.replace(/(?:^|\s+)bss(?:\s+|$)/g, '');
|
|
s90[i].replace(/(\$\{0\})|(\$0\b)/g, '');
|
|
s90[i].replace(/(\$\{1\})|(\$1\b)/g, '');
|
|
s90[i].replace(/(\$\{pbzcyrgr\})|(\$pbzcyrgr\b)/g, '');
|
|
s90[i].replace(/(\$\{sentzrag\})|(\$sentzrag\b)/g, '');
|
|
s90[i].replace(/(\$\{ubfgcbeg\})|(\$ubfgcbeg\b)/g, '');
|
|
s90[i].replace(re56, '');
|
|
s90[i].replace(/(\$\{cebgbpby\})|(\$cebgbpby\b)/g, '');
|
|
s90[i].replace(/(\$\{dhrel\})|(\$dhrel\b)/g, '');
|
|
'nqfvmr'.replace(re29, '');
|
|
'nqfvmr'.replace(re30, '');
|
|
'uggc://${2}${3}${4}${5}'.replace(/(\$\{2\})|(\$2\b)/g, '');
|
|
'uggc://wf.hv-cbegny.qr${3}${4}${5}'.replace(/(\$\{3\})|(\$3\b)/g, '');
|
|
'arjf'.replace(re40, '');
|
|
'arjf'.replace(re41, '');
|
|
'arjf'.replace(re42, '');
|
|
'arjf'.replace(re43, '');
|
|
'arjf'.replace(re44, '');
|
|
'arjf'.replace(re45, '');
|
|
'arjf'.replace(re46, '');
|
|
'arjf'.replace(re47, '');
|
|
'arjf'.replace(re48, '');
|
|
/ PC=i=(\d+)&oe=(.)/.exec(str35);
|
|
re60.exec(' ');
|
|
re60.exec(' bss');
|
|
re60.exec('');
|
|
re19.exec(' ');
|
|
re19.exec('svefg ba');
|
|
re19.exec('ynfg vtaber');
|
|
re19.exec('ba');
|
|
re9.exec('scnq so ');
|
|
re9.exec('zrqvgobk');
|
|
re9.exec('hsgy');
|
|
re9.exec('lhv-h');
|
|
/Fnsnev|Xbadhrebe|XUGZY/gi.exec(s15[i]);
|
|
re61.exec('uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf');
|
|
re62.exec('#Ybtva_rznvy');
|
|
}
|
|
}
|
|
var re63 = /\{0\}/g;
|
|
var str36 = 'FrffvbaQQS2=4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n; ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669321699093060&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_tfwsbrg-aowb_80=4413268q3660';
|
|
var str37 = 'FrffvbaQQS2=4ss747o77904333q374or84qrr1s9r0nprp8r5q81534o94n; AFP_zp_tfwsbrg-aowb_80=4413268q3660; __hgzm=144631658.1231364074.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.2294274870215848400.1231364074.1231364074.1231364074.1; __hgzo=144631658.0.10.1231364074; __hgzp=144631658; ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669321699093060&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str38 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231364057761&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231364057761&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Ssevraqf.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1667363813.1231364061&tn_fvq=1231364061&tn_uvq=1917563877&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str39 = 'ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669321699093060&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str40 = 'ZFPhygher=VC=74.125.75.20&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669321699093060&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var s91 = computeInputVariants(str36, 9);
|
|
var s92 = computeInputVariants(str37, 9);
|
|
var s93 = computeInputVariants(str38, 9);
|
|
function runBlock7() {
|
|
for (var i = 0; i < 9; i++) {
|
|
'0'.replace(re40, '');
|
|
'0'.replace(re10, '');
|
|
'0'.replace(re51, '');
|
|
'0'.replace(re52, '');
|
|
'0'.replace(re53, '');
|
|
'0'.replace(re39, '');
|
|
'0'.replace(re54, '');
|
|
'Lrf'.replace(re40, '');
|
|
'Lrf'.replace(re10, '');
|
|
'Lrf'.replace(re51, '');
|
|
'Lrf'.replace(re52, '');
|
|
'Lrf'.replace(re53, '');
|
|
'Lrf'.replace(re39, '');
|
|
'Lrf'.replace(re54, '');
|
|
}
|
|
for (var i = 0; i < 8; i++) {
|
|
'Pybfr {0}'.replace(re63, '');
|
|
'Bcra {0}'.replace(re63, '');
|
|
s91[i].split(re32);
|
|
s92[i].split(re32);
|
|
'puvyq p1 svefg gnournqref'.replace(re14, '');
|
|
'puvyq p1 svefg gnournqref'.replace(re15, '');
|
|
'uqy_fcb'.replace(re14, '');
|
|
'uqy_fcb'.replace(re15, '');
|
|
'uvag'.replace(re14, '');
|
|
'uvag'.replace(re15, '');
|
|
s93[i].replace(re33, '');
|
|
'yvfg'.replace(re14, '');
|
|
'yvfg'.replace(re15, '');
|
|
'at_bhgre'.replace(re30, '');
|
|
'cnerag puebzr5 qbhoyr2 NU'.replace(re14, '');
|
|
'cnerag puebzr5 qbhoyr2 NU'.replace(re15, '');
|
|
'cnerag puebzr5 dhnq5 ps NU osyvax zbarl'.replace(re14, '');
|
|
'cnerag puebzr5 dhnq5 ps NU osyvax zbarl'.replace(re15, '');
|
|
'cnerag puebzr6 fvatyr1'.replace(re14, '');
|
|
'cnerag puebzr6 fvatyr1'.replace(re15, '');
|
|
'cb_qrs'.replace(re14, '');
|
|
'cb_qrs'.replace(re15, '');
|
|
'gnopbagrag'.replace(re14, '');
|
|
'gnopbagrag'.replace(re15, '');
|
|
'iv_svefg_gvzr'.replace(re30, '');
|
|
/(^|.)(ronl|qri-ehf3.wbg)(|fgberf|zbgbef|yvirnhpgvbaf|jvxv|rkcerff|punggre).(pbz(|.nh|.pa|.ux|.zl|.ft|.oe|.zk)|pb(.hx|.xe|.am)|pn|qr|se|vg|ay|or|ng|pu|vr|va|rf|cy|cu|fr)$/i.exec('cntrf.ronl.pbz');
|
|
re8.exec('144631658.0.10.1231364074');
|
|
re8.exec('144631658.1231364074.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.2294274870215848400.1231364074.1231364074.1231364074.1');
|
|
re8.exec('4413241q3660');
|
|
re8.exec('SbeprqRkcvengvba=633669357391353591');
|
|
re8.exec(str39);
|
|
re8.exec(str40);
|
|
re8.exec('AFP_zp_kkk-gdzogv_80=4413241q3660');
|
|
re8.exec('FrffvbaQQS2=p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7');
|
|
re8.exec('__hgzn=144631658.2294274870215848400.1231364074.1231364074.1231364074.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231364074');
|
|
re8.exec('__hgzm=144631658.1231364074.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7');
|
|
re34.exec(s91[i]);
|
|
re34.exec(s92[i]);
|
|
}
|
|
}
|
|
var re64 = /\b[a-z]/g;
|
|
var re65 = /^uggc:\/\//;
|
|
var re66 = /(?:^|\s+)qvfnoyrq(?:\s+|$)/;
|
|
var str41 = 'uggc://cebsvyr.zlfcnpr.pbz/Zbqhyrf/Nccyvpngvbaf/Cntrf/Pnainf.nfck';
|
|
function runBlock8() {
|
|
for (var i = 0; i < 7; i++) {
|
|
s21[i].match(/\d+/g);
|
|
'nsgre'.replace(re64, '');
|
|
'orsber'.replace(re64, '');
|
|
'obggbz'.replace(re64, '');
|
|
'ohvygva_jrngure.kzy'.replace(re65, '');
|
|
'ohggba'.replace(re37, '');
|
|
'ohggba'.replace(re18, '');
|
|
'qngrgvzr.kzy'.replace(re65, '');
|
|
'uggc://eff.paa.pbz/eff/paa_gbcfgbevrf.eff'.replace(re65, '');
|
|
'vachg'.replace(re37, '');
|
|
'vachg'.replace(re18, '');
|
|
'vafvqr'.replace(re64, '');
|
|
'cbvagre'.replace(re27, '');
|
|
'cbfvgvba'.replace(/[A-Z]/g, '');
|
|
'gbc'.replace(re27, '');
|
|
'gbc'.replace(re64, '');
|
|
'hy'.replace(re37, '');
|
|
'hy'.replace(re18, '');
|
|
str26.replace(re37, '');
|
|
str26.replace(re18, '');
|
|
'lbhghor_vtbbtyr/i2/lbhghor.kzy'.replace(re65, '');
|
|
'm-vaqrk'.replace(re27, '');
|
|
/#([\w-]+)/.exec(str26);
|
|
re16.exec('urvtug');
|
|
re16.exec('znetvaGbc');
|
|
re16.exec('jvqgu');
|
|
re19.exec('gno0 svefg ba');
|
|
re19.exec('gno0 ba');
|
|
re19.exec('gno4 ynfg');
|
|
re19.exec('gno4');
|
|
re19.exec('gno5');
|
|
re19.exec('gno6');
|
|
re19.exec('gno7');
|
|
re19.exec('gno8');
|
|
/NqborNVE\/([^\s]*)/.exec(s15[i]);
|
|
/NccyrJroXvg\/([^ ]*)/.exec(s15[i]);
|
|
/XUGZY/gi.exec(s15[i]);
|
|
/^(?:obql|ugzy)$/i.exec('YV');
|
|
re38.exec('ohggba');
|
|
re38.exec('vachg');
|
|
re38.exec('hy');
|
|
re38.exec(str26);
|
|
/^(\w+|\*)/.exec(str26);
|
|
/znp|jva|yvahk/i.exec('Jva32');
|
|
/eton?\([\d\s,]+\)/.exec('fgngvp');
|
|
}
|
|
for (var i = 0; i < 6; i++) {
|
|
''.replace(/\r/g, '');
|
|
'/'.replace(re40, '');
|
|
'/'.replace(re10, '');
|
|
'/'.replace(re51, '');
|
|
'/'.replace(re52, '');
|
|
'/'.replace(re53, '');
|
|
'/'.replace(re39, '');
|
|
'/'.replace(re54, '');
|
|
'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/{0}?[NDO]&{1}&{2}&[NDR]'.replace(re63, '');
|
|
str41.replace(re12, '');
|
|
'uggc://jjj.snprobbx.pbz/fepu.cuc'.replace(re23, '');
|
|
'freivpr'.replace(re40, '');
|
|
'freivpr'.replace(re41, '');
|
|
'freivpr'.replace(re42, '');
|
|
'freivpr'.replace(re43, '');
|
|
'freivpr'.replace(re44, '');
|
|
'freivpr'.replace(re45, '');
|
|
'freivpr'.replace(re46, '');
|
|
'freivpr'.replace(re47, '');
|
|
'freivpr'.replace(re48, '');
|
|
/((ZFVR\s+([6-9]|\d\d)\.))/.exec(s15[i]);
|
|
re66.exec('');
|
|
re50.exec('fryrpgrq');
|
|
re8.exec('8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn');
|
|
re8.exec('SbeprqRkcvengvba=633669340386893867');
|
|
re8.exec('VC=74.125.75.17');
|
|
re8.exec('FrffvbaQQS2=8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn');
|
|
/Xbadhrebe|Fnsnev|XUGZY/.exec(s15[i]);
|
|
re13.exec(str41);
|
|
re49.exec('unfsbphf');
|
|
}
|
|
}
|
|
var re67 = /zrah_byq/g;
|
|
var str42 = 'FrffvbaQQS2=473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669325184628362&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str43 = 'FrffvbaQQS2=473qq1rs0n2r70q9qo1pq48n021s9468ron90nps048p4p29; __hgzm=144631658.1231364380.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.3931862196947939300.1231364380.1231364380.1231364380.1; __hgzo=144631658.0.10.1231364380; __hgzp=144631658; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669325184628362&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str44 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_vzntrf_wf&qg=1231364373088&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231364373088&punaary=svz_zlfcnpr_hfre-ivrj-pbzzragf%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Spbzzrag.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1158737789.1231364375&tn_fvq=1231364375&tn_uvq=415520832&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str45 = 'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669325184628362&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str46 = 'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669325184628362&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var re68 = /^([#.]?)((?:[\w\u0128-\uffff*_-]|\\.)*)/;
|
|
var re69 = /\{1\}/g;
|
|
var re70 = /\s+/;
|
|
var re71 = /(\$\{4\})|(\$4\b)/g;
|
|
var re72 = /(\$\{5\})|(\$5\b)/g;
|
|
var re73 = /\{2\}/g;
|
|
var re74 = /[^+>] [^+>]/;
|
|
var re75 = /\bucpyv\s*=\s*([^;]*)/i;
|
|
var re76 = /\bucuvqr\s*=\s*([^;]*)/i;
|
|
var re77 = /\bucfie\s*=\s*([^;]*)/i;
|
|
var re78 = /\bhfucjrn\s*=\s*([^;]*)/i;
|
|
var re79 = /\bmvc\s*=\s*([^;]*)/i;
|
|
var re80 = /^((?:[\w\u0128-\uffff*_-]|\\.)+)(#)((?:[\w\u0128-\uffff*_-]|\\.)+)/;
|
|
var re81 = /^([>+~])\s*(\w*)/i;
|
|
var re82 = /^>\s*((?:[\w\u0128-\uffff*_-]|\\.)+)/;
|
|
var re83 = /^[\s[]?shapgvba/;
|
|
var re84 = /v\/g.tvs#(.*)/i;
|
|
var str47 = '#Zbq-Vasb-Vasb-WninFpevcgUvag';
|
|
var str48 = ',n.svryqOgaPnapry';
|
|
var str49 = 'FrffvbaQQS2=p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669357391353591&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_kkk-gdzogv_80=4413241q3660';
|
|
var str50 = 'FrffvbaQQS2=p98s8o9q42nr21or1r61pqorn1n002nsss569635984s6qp7; AFP_zp_kkk-gdzogv_80=4413241q3660; AFP_zp_kkk-aowb_80=4413235p3660; __hgzm=144631658.1231367708.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.2770915348920628700.1231367708.1231367708.1231367708.1; __hgzo=144631658.0.10.1231367708; __hgzp=144631658; ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669357391353591&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str51 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231367691141&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231367691141&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Sjjj.zlfcnpr.pbz%2S&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=320757904.1231367694&tn_fvq=1231367694&tn_uvq=1758792003&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str52 = 'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55332979829981?[NDO]&aqu=1&g=7%2S0%2S2009%2014%3N38%3N42%203%20480&af=zfacbegny&cntrAnzr=HF%20UCZFSGJ&t=uggc%3N%2S%2Sjjj.zfa.pbz%2S&f=1024k768&p=24&x=L&oj=994&ou=634&uc=A&{2}&[NDR]';
|
|
var str53 = 'cnerag puebzr6 fvatyr1 gno fryrpgrq ovaq qbhoyr2 ps';
|
|
var str54 = 'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669357391353591&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str55 = 'ZFPhygher=VC=74.125.75.3&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669357391353591&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str56 = 'ne;ng;nh;or;oe;pn;pu;py;pa;qr;qx;rf;sv;se;to;ux;vq;vr;va;vg;wc;xe;zk;zl;ay;ab;am;cu;cy;cg;eh;fr;ft;gu;ge;gj;mn;';
|
|
var str57 = 'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886&GHVQ=1';
|
|
var str58 = 'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886';
|
|
var str59 = 'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886; mvc=m:94043|yn:37.4154|yb:-122.0585|p:HF|ue:1';
|
|
var str60 = 'ZP1=I=3&THVQ=6nnpr9q661804s33nnop45nosqp17q85; zu=ZFSG; PHYGHER=RA-HF; SyvtugTebhcVq=97; SyvtugVq=OnfrCntr; ucfie=Z:5|S:5|G:5|R:5|Q:oyh|J:S; ucpyv=J.U|Y.|F.|E.|H.Y|P.|U.; hfucjrn=jp:HFPN0746; ZHVQ=Q783SN9O14054831N4869R51P0SO8886; mvc=m:94043|yn:37.4154|yb:-122.0585|p:HF';
|
|
var str61 = 'uggc://gx2.fgp.f-zfa.pbz/oe/uc/11/ra-hf/pff/v/g.tvs#uggc://gx2.fgo.f-zfa.pbz/v/29/4RQP4969777N048NPS4RRR3PO2S7S.wct';
|
|
var str62 = 'uggc://gx2.fgp.f-zfa.pbz/oe/uc/11/ra-hf/pff/v/g.tvs#uggc://gx2.fgo.f-zfa.pbz/v/OQ/63NP9O94NS5OQP1249Q9S1ROP7NS3.wct';
|
|
var str63 = 'zbmvyyn/5.0 (jvaqbjf; h; jvaqbjf ag 5.1; ra-hf) nccyrjroxvg/528.9 (xugzy, yvxr trpxb) puebzr/2.0.157.0 fnsnev/528.9';
|
|
var s94 = computeInputVariants(str42, 5);
|
|
var s95 = computeInputVariants(str43, 5);
|
|
var s96 = computeInputVariants(str44, 5);
|
|
var s97 = computeInputVariants(str47, 5);
|
|
var s98 = computeInputVariants(str48, 5);
|
|
var s99 = computeInputVariants(str49, 5);
|
|
var s100 = computeInputVariants(str50, 5);
|
|
var s101 = computeInputVariants(str51, 5);
|
|
var s102 = computeInputVariants(str52, 5);
|
|
var s103 = computeInputVariants(str53, 5);
|
|
|
|
function runBlock9() {
|
|
for (var i = 0; i < 5; i++) {
|
|
s94[i].split(re32);
|
|
s95[i].split(re32);
|
|
'svz_zlfcnpr_hfre-ivrj-pbzzragf,svz_zlfcnpr_havgrq-fgngrf'.split(re20);
|
|
s96[i].replace(re33, '');
|
|
'zrah_arj zrah_arj_gbttyr zrah_gbttyr'.replace(re67, '');
|
|
'zrah_byq zrah_byq_gbttyr zrah_gbttyr'.replace(re67, '');
|
|
re8.exec('102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98');
|
|
re8.exec('144631658.0.10.1231364380');
|
|
re8.exec('144631658.1231364380.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.3931862196947939300.1231364380.1231364380.1231364380.1');
|
|
re8.exec('441326q33660');
|
|
re8.exec('SbeprqRkcvengvba=633669341278771470');
|
|
re8.exec(str45);
|
|
re8.exec(str46);
|
|
re8.exec('AFP_zp_dfctwzssrwh-aowb_80=441326q33660');
|
|
re8.exec('FrffvbaQQS2=102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98');
|
|
re8.exec('__hgzn=144631658.3931862196947939300.1231364380.1231364380.1231364380.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231364380');
|
|
re8.exec('__hgzm=144631658.1231364380.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
}
|
|
for (var i = 0; i < 4; i++) {
|
|
' yvfg1'.replace(re14, '');
|
|
' yvfg1'.replace(re15, '');
|
|
' yvfg2'.replace(re14, '');
|
|
' yvfg2'.replace(re15, '');
|
|
' frneputebhc1'.replace(re14, '');
|
|
' frneputebhc1'.replace(re15, '');
|
|
s97[i].replace(re68, '');
|
|
s97[i].replace(re18, '');
|
|
''.replace(/&/g, '');
|
|
''.replace(re35, '');
|
|
'(..-{0})(\|(\d+)|)'.replace(re63, '');
|
|
s98[i].replace(re18, '');
|
|
'//vzt.jro.qr/vij/FC/${cngu}/${anzr}/${inyhr}?gf=${abj}'.replace(re56, '');
|
|
'//vzt.jro.qr/vij/FC/tzk_uc/${anzr}/${inyhr}?gf=${abj}'.replace(/(\$\{anzr\})|(\$anzr\b)/g, '');
|
|
'<fcna pynff="urnq"><o>Jvaqbjf Yvir Ubgznvy</o></fcna><fcna pynff="zft">{1}</fcna>'.replace(re69, '');
|
|
'<fcna pynff="urnq"><o>{0}</o></fcna><fcna pynff="zft">{1}</fcna>'.replace(re63, '');
|
|
'<fcna pynff="fvtahc"><n uers=uggc://jjj.ubgznvy.pbz><o>{1}</o></n></fcna>'.replace(re69, '');
|
|
'<fcna pynff="fvtahc"><n uers={0}><o>{1}</o></n></fcna>'.replace(re63, '');
|
|
'Vzntrf'.replace(re15, '');
|
|
'ZFA'.replace(re15, '');
|
|
'Zncf'.replace(re15, '');
|
|
'Zbq-Vasb-Vasb-WninFpevcgUvag'.replace(re39, '');
|
|
'Arjf'.replace(re15, '');
|
|
s99[i].split(re32);
|
|
s100[i].split(re32);
|
|
'Ivqrb'.replace(re15, '');
|
|
'Jro'.replace(re15, '');
|
|
'n'.replace(re39, '');
|
|
'nwnkFgneg'.split(re70);
|
|
'nwnkFgbc'.split(re70);
|
|
'ovaq'.replace(re14, '');
|
|
'ovaq'.replace(re15, '');
|
|
'oevatf lbh zber. Zber fcnpr (5TO), zber frphevgl, fgvyy serr.'.replace(re63, '');
|
|
'puvyq p1 svefg qrpx'.replace(re14, '');
|
|
'puvyq p1 svefg qrpx'.replace(re15, '');
|
|
'puvyq p1 svefg qbhoyr2'.replace(re14, '');
|
|
'puvyq p1 svefg qbhoyr2'.replace(re15, '');
|
|
'puvyq p2 ynfg'.replace(re14, '');
|
|
'puvyq p2 ynfg'.replace(re15, '');
|
|
'puvyq p2'.replace(re14, '');
|
|
'puvyq p2'.replace(re15, '');
|
|
'puvyq p3'.replace(re14, '');
|
|
'puvyq p3'.replace(re15, '');
|
|
'puvyq p4 ynfg'.replace(re14, '');
|
|
'puvyq p4 ynfg'.replace(re15, '');
|
|
'pbclevtug'.replace(re14, '');
|
|
'pbclevtug'.replace(re15, '');
|
|
'qZFAZR_1'.replace(re14, '');
|
|
'qZFAZR_1'.replace(re15, '');
|
|
'qbhoyr2 ps'.replace(re14, '');
|
|
'qbhoyr2 ps'.replace(re15, '');
|
|
'qbhoyr2'.replace(re14, '');
|
|
'qbhoyr2'.replace(re15, '');
|
|
'uqy_arj'.replace(re14, '');
|
|
'uqy_arj'.replace(re15, '');
|
|
'uc_fubccvatobk'.replace(re30, '');
|
|
'ugzy%2Rvq'.replace(re29, '');
|
|
'ugzy%2Rvq'.replace(re30, '');
|
|
s101[i].replace(re33, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/cebgbglcr.wf${4}${5}'.replace(re71, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/cebgbglcr.wf${5}'.replace(re72, '');
|
|
s102[i].replace(re73, '');
|
|
'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55332979829981?[NDO]&{1}&{2}&[NDR]'.replace(re69, '');
|
|
'vztZFSG'.replace(re14, '');
|
|
'vztZFSG'.replace(re15, '');
|
|
'zfasbbg1 ps'.replace(re14, '');
|
|
'zfasbbg1 ps'.replace(re15, '');
|
|
s103[i].replace(re14, '');
|
|
s103[i].replace(re15, '');
|
|
'cnerag puebzr6 fvatyr1 gno fryrpgrq ovaq'.replace(re14, '');
|
|
'cnerag puebzr6 fvatyr1 gno fryrpgrq ovaq'.replace(re15, '');
|
|
'cevznel'.replace(re14, '');
|
|
'cevznel'.replace(re15, '');
|
|
'erpgnatyr'.replace(re30, '');
|
|
'frpbaqnel'.replace(re14, '');
|
|
'frpbaqnel'.replace(re15, '');
|
|
'haybnq'.split(re70);
|
|
'{0}{1}1'.replace(re63, '');
|
|
'|{1}1'.replace(re69, '');
|
|
/(..-HF)(\|(\d+)|)/i.exec('xb-xe,ra-va,gu-gu');
|
|
re4.exec('/ZlFcnprNccf/NccPnainf,45000012');
|
|
re8.exec('144631658.0.10.1231367708');
|
|
re8.exec('144631658.1231367708.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.2770915348920628700.1231367708.1231367708.1231367708.1');
|
|
re8.exec('4413235p3660');
|
|
re8.exec('441327q73660');
|
|
re8.exec('9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473');
|
|
re8.exec('SbeprqRkcvengvba=633669350559478880');
|
|
re8.exec(str54);
|
|
re8.exec(str55);
|
|
re8.exec('AFP_zp_dfctwzs-aowb_80=441327q73660');
|
|
re8.exec('AFP_zp_kkk-aowb_80=4413235p3660');
|
|
re8.exec('FrffvbaQQS2=9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473');
|
|
re8.exec('__hgzn=144631658.2770915348920628700.1231367708.1231367708.1231367708.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231367708');
|
|
re8.exec('__hgzm=144631658.1231367708.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re34.exec(s99[i]);
|
|
re34.exec(s100[i]);
|
|
/ZFVR\s+5[.]01/.exec(s15[i]);
|
|
/HF(?=;)/i.exec(str56);
|
|
re74.exec(s97[i]);
|
|
re28.exec('svefg npgvir svefgNpgvir');
|
|
re28.exec('ynfg');
|
|
/\bp:(..)/i.exec('m:94043|yn:37.4154|yb:-122.0585|p:HF');
|
|
re75.exec(str57);
|
|
re75.exec(str58);
|
|
re76.exec(str57);
|
|
re76.exec(str58);
|
|
re77.exec(str57);
|
|
re77.exec(str58);
|
|
/\bhfucce\s*=\s*([^;]*)/i.exec(str59);
|
|
re78.exec(str57);
|
|
re78.exec(str58);
|
|
/\bjci\s*=\s*([^;]*)/i.exec(str59);
|
|
re79.exec(str58);
|
|
re79.exec(str60);
|
|
re79.exec(str59);
|
|
/\|p:([a-z]{2})/i.exec('m:94043|yn:37.4154|yb:-122.0585|p:HF|ue:1');
|
|
re80.exec(s97[i]);
|
|
re61.exec('cebgbglcr.wf');
|
|
re68.exec(s97[i]);
|
|
re81.exec(s97[i]);
|
|
re82.exec(s97[i]);
|
|
/^Fubpxjnir Synfu (\d)/.exec(s21[i]);
|
|
/^Fubpxjnir Synfu (\d+)/.exec(s21[i]);
|
|
re83.exec('[bowrpg tybony]');
|
|
re62.exec(s97[i]);
|
|
re84.exec(str61);
|
|
re84.exec(str62);
|
|
/jroxvg/.exec(str63);
|
|
}
|
|
}
|
|
var re85 = /eaq_zbqobkva/;
|
|
var str64 = '1231365729213';
|
|
var str65 = '74.125.75.3-1057165600.29978900';
|
|
var str66 = '74.125.75.3-1057165600.29978900.1231365730214';
|
|
var str67 = 'Frnepu%20Zvpebfbsg.pbz';
|
|
var str68 = 'FrffvbaQQS2=8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn; ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669340386893867&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str69 = 'FrffvbaQQS2=8sqq78r9n442851q565599o401385sp3s04r92rnn7o19ssn; __hgzm=144631658.1231365779.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.1877536177953918500.1231365779.1231365779.1231365779.1; __hgzo=144631658.0.10.1231365779; __hgzp=144631658; ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669340386893867&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str70 = 'I=3%26THVQ=757q3ss871q44o7o805n8113n5p72q52';
|
|
var str71 = 'I=3&THVQ=757q3ss871q44o7o805n8113n5p72q52';
|
|
var str72 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231365765292&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231365765292&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Sohyyrgvaf.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1579793869.1231365768&tn_fvq=1231365768&tn_uvq=2056210897&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str73 = 'frnepu.zvpebfbsg.pbz';
|
|
var str74 = 'frnepu.zvpebfbsg.pbz/';
|
|
var str75 = 'ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669340386893867&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str76 = 'ZFPhygher=VC=74.125.75.17&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669340386893867&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
function runBlock10() {
|
|
for (var i = 0; i < 3; i++) {
|
|
'%3Szxg=ra-HF'.replace(re39, '');
|
|
'-8'.replace(re40, '');
|
|
'-8'.replace(re10, '');
|
|
'-8'.replace(re51, '');
|
|
'-8'.replace(re52, '');
|
|
'-8'.replace(re53, '');
|
|
'-8'.replace(re39, '');
|
|
'-8'.replace(re54, '');
|
|
'1.5'.replace(re40, '');
|
|
'1.5'.replace(re10, '');
|
|
'1.5'.replace(re51, '');
|
|
'1.5'.replace(re52, '');
|
|
'1.5'.replace(re53, '');
|
|
'1.5'.replace(re39, '');
|
|
'1.5'.replace(re54, '');
|
|
'1024k768'.replace(re40, '');
|
|
'1024k768'.replace(re10, '');
|
|
'1024k768'.replace(re51, '');
|
|
'1024k768'.replace(re52, '');
|
|
'1024k768'.replace(re53, '');
|
|
'1024k768'.replace(re39, '');
|
|
'1024k768'.replace(re54, '');
|
|
str64.replace(re40, '');
|
|
str64.replace(re10, '');
|
|
str64.replace(re51, '');
|
|
str64.replace(re52, '');
|
|
str64.replace(re53, '');
|
|
str64.replace(re39, '');
|
|
str64.replace(re54, '');
|
|
'14'.replace(re40, '');
|
|
'14'.replace(re10, '');
|
|
'14'.replace(re51, '');
|
|
'14'.replace(re52, '');
|
|
'14'.replace(re53, '');
|
|
'14'.replace(re39, '');
|
|
'14'.replace(re54, '');
|
|
'24'.replace(re40, '');
|
|
'24'.replace(re10, '');
|
|
'24'.replace(re51, '');
|
|
'24'.replace(re52, '');
|
|
'24'.replace(re53, '');
|
|
'24'.replace(re39, '');
|
|
'24'.replace(re54, '');
|
|
str65.replace(re40, '');
|
|
str65.replace(re10, '');
|
|
str65.replace(re51, '');
|
|
str65.replace(re52, '');
|
|
str65.replace(re53, '');
|
|
str65.replace(re39, '');
|
|
str65.replace(re54, '');
|
|
str66.replace(re40, '');
|
|
str66.replace(re10, '');
|
|
str66.replace(re51, '');
|
|
str66.replace(re52, '');
|
|
str66.replace(re53, '');
|
|
str66.replace(re39, '');
|
|
str66.replace(re54, '');
|
|
'9.0'.replace(re40, '');
|
|
'9.0'.replace(re10, '');
|
|
'9.0'.replace(re51, '');
|
|
'9.0'.replace(re52, '');
|
|
'9.0'.replace(re53, '');
|
|
'9.0'.replace(re39, '');
|
|
'9.0'.replace(re54, '');
|
|
'994k634'.replace(re40, '');
|
|
'994k634'.replace(re10, '');
|
|
'994k634'.replace(re51, '');
|
|
'994k634'.replace(re52, '');
|
|
'994k634'.replace(re53, '');
|
|
'994k634'.replace(re39, '');
|
|
'994k634'.replace(re54, '');
|
|
'?zxg=ra-HF'.replace(re40, '');
|
|
'?zxg=ra-HF'.replace(re10, '');
|
|
'?zxg=ra-HF'.replace(re51, '');
|
|
'?zxg=ra-HF'.replace(re52, '');
|
|
'?zxg=ra-HF'.replace(re53, '');
|
|
'?zxg=ra-HF'.replace(re54, '');
|
|
'PAA.pbz'.replace(re25, '');
|
|
'PAA.pbz'.replace(re12, '');
|
|
'PAA.pbz'.replace(re39, '');
|
|
'Qngr & Gvzr'.replace(re25, '');
|
|
'Qngr & Gvzr'.replace(re12, '');
|
|
'Qngr & Gvzr'.replace(re39, '');
|
|
'Frnepu Zvpebfbsg.pbz'.replace(re40, '');
|
|
'Frnepu Zvpebfbsg.pbz'.replace(re54, '');
|
|
str67.replace(re10, '');
|
|
str67.replace(re51, '');
|
|
str67.replace(re52, '');
|
|
str67.replace(re53, '');
|
|
str67.replace(re39, '');
|
|
str68.split(re32);
|
|
str69.split(re32);
|
|
str70.replace(re52, '');
|
|
str70.replace(re53, '');
|
|
str70.replace(re39, '');
|
|
str71.replace(re40, '');
|
|
str71.replace(re10, '');
|
|
str71.replace(re51, '');
|
|
str71.replace(re54, '');
|
|
'Jrngure'.replace(re25, '');
|
|
'Jrngure'.replace(re12, '');
|
|
'Jrngure'.replace(re39, '');
|
|
'LbhGhor'.replace(re25, '');
|
|
'LbhGhor'.replace(re12, '');
|
|
'LbhGhor'.replace(re39, '');
|
|
str72.replace(re33, '');
|
|
'erzbgr_vsenzr_1'.replace(/^erzbgr_vsenzr_/, '');
|
|
str73.replace(re40, '');
|
|
str73.replace(re10, '');
|
|
str73.replace(re51, '');
|
|
str73.replace(re52, '');
|
|
str73.replace(re53, '');
|
|
str73.replace(re39, '');
|
|
str73.replace(re54, '');
|
|
str74.replace(re40, '');
|
|
str74.replace(re10, '');
|
|
str74.replace(re51, '');
|
|
str74.replace(re52, '');
|
|
str74.replace(re53, '');
|
|
str74.replace(re39, '');
|
|
str74.replace(re54, '');
|
|
'lhv-h'.replace(/\-/g, '');
|
|
re9.exec('p');
|
|
re9.exec('qz p');
|
|
re9.exec('zbqynory');
|
|
re9.exec('lhv-h svefg');
|
|
re8.exec('144631658.0.10.1231365779');
|
|
re8.exec('144631658.1231365779.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.1877536177953918500.1231365779.1231365779.1231365779.1');
|
|
re8.exec(str75);
|
|
re8.exec(str76);
|
|
re8.exec('__hgzn=144631658.1877536177953918500.1231365779.1231365779.1231365779.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231365779');
|
|
re8.exec('__hgzm=144631658.1231365779.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re34.exec(str68);
|
|
re34.exec(str69);
|
|
/^$/.exec('');
|
|
re31.exec('qr');
|
|
/^znk\d+$/.exec('');
|
|
/^zva\d+$/.exec('');
|
|
/^erfgber$/.exec('');
|
|
re85.exec('zbqobkva zbqobk_abcnqqvat ');
|
|
re85.exec('zbqgvgyr');
|
|
re85.exec('eaq_zbqobkva ');
|
|
re85.exec('eaq_zbqgvgyr ');
|
|
/frpgvba\d+_pbagragf/.exec('obggbz_ani');
|
|
}
|
|
}
|
|
var re86 = /;\s*/;
|
|
var re87 = /(\$\{inyhr\})|(\$inyhr\b)/g;
|
|
var re88 = /(\$\{abj\})|(\$abj\b)/g;
|
|
var re89 = /\s+$/;
|
|
var re90 = /^\s+/;
|
|
var re91 = /(\\\"|\x00-|\x1f|\x7f-|\x9f|\u00ad|\u0600-|\u0604|\u070f|\u17b4|\u17b5|\u200c-|\u200f|\u2028-|\u202f|\u2060-|\u206f|\ufeff|\ufff0-|\uffff)/g;
|
|
var re92 = /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/;
|
|
var re93 = /^([:.#]*)((?:[\w\u0128-\uffff*_-]|\\.)+)/;
|
|
var re94 = /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/;
|
|
var str77 = '#fubhgobk .pybfr';
|
|
var str78 = 'FrffvbaQQS2=102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669341278771470&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_dfctwzssrwh-aowb_80=441326q33660';
|
|
var str79 = 'FrffvbaQQS2=102n9o0o9pq60132qn0337rr867p75953502q2s27s2s5r98; AFP_zp_dfctwzssrwh-aowb_80=441326q33660; __hgzm=144631658.1231365869.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.1670816052019209000.1231365869.1231365869.1231365869.1; __hgzo=144631658.0.10.1231365869; __hgzp=144631658; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669341278771470&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str80 = 'FrffvbaQQS2=9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669350559478880&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=; AFP_zp_dfctwzs-aowb_80=441327q73660';
|
|
var str81 = 'FrffvbaQQS2=9995p6rp12rrnr893334ro7nq70o7p64p69rqn844prs1473; AFP_zp_dfctwzs-aowb_80=441327q73660; __hgzm=144631658.1231367054.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar); __hgzn=144631658.1796080716621419500.1231367054.1231367054.1231367054.1; __hgzo=144631658.0.10.1231367054; __hgzp=144631658; ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669350559478880&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str82 = '[glcr=fhozvg]';
|
|
var str83 = 'n.svryqOga,n.svryqOgaPnapry';
|
|
var str84 = 'n.svryqOgaPnapry';
|
|
var str85 = 'oyvpxchaxg';
|
|
var str86 = 'qvi.bow-nppbeqvba qg';
|
|
var str87 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_nccf_wf&qg=1231367052227&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231367052227&punaary=svz_zlfcnpr_nccf-pnainf%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Scebsvyr.zlfcnpr.pbz%2SZbqhyrf%2SNccyvpngvbaf%2SCntrf%2SPnainf.nfck&nq_glcr=grkg&rvq=6083027&rn=0&sez=1&tn_ivq=716357910.1231367056&tn_fvq=1231367056&tn_uvq=1387206491&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str88 = 'uggc://tbbtyrnqf.t.qbhoyrpyvpx.arg/cntrnq/nqf?pyvrag=pn-svz_zlfcnpr_zlfcnpr-ubzrcntr_wf&qg=1231365851658&uy=ra&nqfnsr=uvtu&br=hgs8&ahz_nqf=4&bhgchg=wf&nqgrfg=bss&pbeeryngbe=1231365851658&punaary=svz_zlfcnpr_ubzrcntr_abgybttrqva%2Psvz_zlfcnpr_aba_HTP%2Psvz_zlfcnpr_havgrq-fgngrf&hey=uggc%3N%2S%2Scebsvyrrqvg.zlfcnpr.pbz%2Svaqrk.psz&nq_glcr=grkg&rvq=6083027&rn=0&sez=0&tn_ivq=1979828129.1231365855&tn_fvq=1231365855&tn_uvq=2085229649&synfu=9.0.115&h_u=768&h_j=1024&h_nu=738&h_nj=1024&h_pq=24&h_gm=-480&h_uvf=2&h_wnin=gehr&h_acyht=7&h_azvzr=22';
|
|
var str89 = 'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55023338617756?[NDO]&aqu=1&g=7%2S0%2S2009%2014%3N12%3N47%203%20480&af=zfacbegny&cntrAnzr=HF%20UCZFSGJ&t=uggc%3N%2S%2Sjjj.zfa.pbz%2S&f=0k0&p=43835816&x=A&oj=994&ou=634&uc=A&{2}&[NDR]';
|
|
var str90 = 'zrgn[anzr=nwnkHey]';
|
|
var str91 = 'anpuevpugra';
|
|
var str92 = 'b oS={\'oT\':1.1};x $8n(B){z(B!=o9)};x $S(B){O(!$8n(B))z A;O(B.4L)z\'T\';b S=7t B;O(S==\'2P\'&&B.p4){23(B.7f){12 1:z\'T\';12 3:z/\S/.2g(B.8M)?\'ox\':\'oh\'}}O(S==\'2P\'||S==\'x\'){23(B.nE){12 2V:z\'1O\';12 7I:z\'5a\';12 18:z\'4B\'}O(7t B.I==\'4F\'){O(B.3u)z\'pG\';O(B.8e)z\'1p\'}}z S};x $2p(){b 4E={};Z(b v=0;v<1p.I;v++){Z(b X 1o 1p[v]){b nc=1p[v][X];b 6E=4E[X];O(6E&&$S(nc)==\'2P\'&&$S(6E)==\'2P\')4E[X]=$2p(6E,nc);17 4E[X]=nc}}z 4E};b $E=7p.E=x(){b 1d=1p;O(!1d[1])1d=[p,1d[0]];Z(b X 1o 1d[1])1d[0][X]=1d[1][X];z 1d[0]};b $4D=7p.pJ=x(){Z(b v=0,y=1p.I;v<y;v++){1p[v].E=x(1J){Z(b 1I 1o 1J){O(!p.1Y[1I])p.1Y[1I]=1J[1I];O(!p[1I])p[1I]=$4D.6C(1I)}}}};$4D.6C=x(1I){z x(L){z p.1Y[1I].3H(L,2V.1Y.nV.1F(1p,1))}};$4D(7F,2V,6J,nb);b 3l=x(B){B=B||{};B.E=$E;z B};b pK=Y 3l(H);b pZ=Y 3l(C);C.6f=C.35(\'6f\')[0];x $2O(B){z!!(B||B===0)};x $5S(B,n8){z $8n(B)?B:n8};x $7K(3c,1m){z 1q.na(1q.7K()*(1m-3c+1)+3c)};x $3N(){z Y 97().os()};x $4M(1U){pv(1U);pa(1U);z 1S};H.43=!!(C.5Z);O(H.nB)H.31=H[H.7q?\'py\':\'nL\']=1r;17 O(C.9N&&!C.om&&!oy.oZ)H.pF=H.4Z=H[H.43?\'pt\':\'65\']=1r;17 O(C.po!=1S)H.7J=1r;O(7t 5B==\'o9\'){b 5B=x(){};O(H.4Z)C.nd("pW");5B.1Y=(H.4Z)?H["[[oN.1Y]]"]:{}}5B.1Y.4L=1r;O(H.nL)5s{C.oX("pp",A,1r)}4K(r){};b 18=x(1X){b 63=x(){z(1p[0]!==1S&&p.1w&&$S(p.1w)==\'x\')?p.1w.3H(p,1p):p};$E(63,p);63.1Y=1X;63.nE=18;z 63};18.1z=x(){};18.1Y={E:x(1X){b 7x=Y p(1S);Z(b X 1o 1X){b nC=7x[X];7x[X]=18.nY(nC,1X[X])}z Y 18(7x)},3d:x(){Z(b v=0,y=1p.I;v<y;v++)$E(p.1Y,1p[v])}};18.nY=x(2b,2n){O(2b&&2b!=2n){b S=$S(2n);O(S!=$S(2b))z 2n;23(S){12\'x\':b 7R=x(){p.1e=1p.8e.1e;z 2n.3H(p,1p)};7R.1e=2b;z 7R;12\'2P\':z $2p(2b,2n)}}z 2n};b 8o=Y 18({oQ:x(J){p.4w=p.4w||[];p.4w.1x(J);z p},7g:x(){O(p.4w&&p.4w.I)p.4w.9J().2x(10,p)},oP:x(){p.4w=[]}});b 2d=Y 18({1V:x(S,J){O(J!=18.1z){p.$19=p.$19||{};p.$19[S]=p.$19[S]||[];p.$19[S].5j(J)}z p},1v:x(S,1d,2x){O(p.$19&&p.$19[S]){p.$19[S].1b(x(J){J.3n({\'L\':p,\'2x\':2x,\'1p\':1d})()},p)}z p},3M:x(S,J){O(p.$19&&p.$19[S])p.$19[S].2U(J);z p}});b 4v=Y 18({2H:x(){p.P=$2p.3H(1S,[p.P].E(1p));O(!p.1V)z p;Z(b 3O 1o p.P){O($S(p.P[3O]==\'x\')&&3O.2g(/^5P[N-M]/))p.1V(3O,p.P[3O])}z p}});2V.E({7y:x(J,L){Z(b v=0,w=p.I;v<w;v++)J.1F(L,p[v],v,p)},3s:x(J,L){b 54=[];Z(b v=0,w=p.I;v<w;v++){O(J.1F(L,p[v],v,p))54.1x(p[v])}z 54},2X:x(J,L){b 54=[];Z(b v=0,w=p.I;v<w;v++)54[v]=J.1F(L,p[v],v,p);z 54},4i:x(J,L){Z(b v=0,w=p.I;v<w;v++){O(!J.1F(L,p[v],v,p))z A}z 1r},ob:x(J,L){Z(b v=0,w=p.I;v<w;v++){O(J.1F(L,p[v],v,p))z 1r}z A},3F:x(3u,15){b 3A=p.I;Z(b v=(15<0)?1q.1m(0,3A+15):15||0;v<3A;v++){O(p[v]===3u)z v}z-1},8z:x(1u,I){1u=1u||0;O(1u<0)1u=p.I+1u;I=I||(p.I-1u);b 89=[];Z(b v=0;v<I;v++)89[v]=p[1u++];z 89},2U:x(3u){b v=0;b 3A=p.I;6L(v<3A){O(p[v]===3u){p.6l(v,1);3A--}17{v++}}z p},1y:x(3u,15){z p.3F(3u,15)!=-1},oz:x(1C){b B={},I=1q.3c(p.I,1C.I);Z(b v=0;v<I;v++)B[1C[v]]=p[v];z B},E:x(1O){Z(b v=0,w=1O.I;v<w;v++)p.1x(1O[v]);z p},2p:x(1O){Z(b v=0,y=1O.I;v<y;v++)p.5j(1O[v]);z p},5j:x(3u){O(!p.1y(3u))p.1x(3u);z p},oc:x(){z p[$7K(0,p.I-1)]||A},7L:x(){z p[p.I-1]||A}});2V.1Y.1b=2V.1Y.7y;2V.1Y.2g=2V.1Y.1y;x $N(1O){z 2V.8z(1O)};x $1b(3J,J,L){O(3J&&7t 3J.I==\'4F\'&&$S(3J)!=\'2P\')2V.7y(3J,J,L);17 Z(b 1j 1o 3J)J.1F(L||3J,3J[1j],1j)};6J.E({2g:x(6b,2F){z(($S(6b)==\'2R\')?Y 7I(6b,2F):6b).2g(p)},3p:x(){z 5K(p,10)},o4:x(){z 69(p)},7A:x(){z p.3y(/-\D/t,x(2G){z 2G.7G(1).nW()})},9b:x(){z p.3y(/\w[N-M]/t,x(2G){z(2G.7G(0)+\'-\'+2G.7G(1).5O())})},8V:x(){z p.3y(/\b[n-m]/t,x(2G){z 2G.nW()})},5L:x(){z p.3y(/^\s+|\s+$/t,\'\')},7j:x(){z p.3y(/\s{2,}/t,\' \').5L()},5V:x(1O){b 1i=p.2G(/\d{1,3}/t);z(1i)?1i.5V(1O):A},5U:x(1O){b 3P=p.2G(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);z(3P)?3P.nV(1).5U(1O):A},1y:x(2R,f){z(f)?(f+p+f).3F(f+2R+f)>-1:p.3F(2R)>-1},nX:x(){z p.3y(/([.*+?^${}()|[\]\/\\])/t,\'\\$1\')}});2V.E({5V:x(1O){O(p.I<3)z A;O(p.I==4&&p[3]==0&&!1O)z\'p5\';b 3P=[];Z(b v=0;v<3;v++){b 52=(p[v]-0).4h(16);3P.1x((52.I==1)?\'0\'+52:52)}z 1O?3P:\'#\'+3P.2u(\'\')},5U:x(1O){O(p.I!=3)z A;b 1i=[];Z(b v=0;v<3;v++){1i.1x(5K((p[v].I==1)?p[v]+p[v]:p[v],16))}z 1O?1i:\'1i(\'+1i.2u(\',\')+\')\'}});7F.E({3n:x(P){b J=p;P=$2p({\'L\':J,\'V\':A,\'1p\':1S,\'2x\':A,\'4s\':A,\'6W\':A},P);O($2O(P.1p)&&$S(P.1p)!=\'1O\')P.1p=[P.1p];z x(V){b 1d;O(P.V){V=V||H.V;1d=[(P.V===1r)?V:Y P.V(V)];O(P.1p)1d.E(P.1p)}17 1d=P.1p||1p;b 3C=x(){z J.3H($5S(P';
|
|
var str93 = 'hagreunyghat';
|
|
var str94 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669341278771470&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str95 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&Pbhagel=IIZ%3Q&SbeprqRkcvengvba=633669350559478880&gvzrMbar=-8&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R%3Q';
|
|
var str96 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669341278771470&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str97 = 'ZFPhygher=VC=74.125.75.1&VCPhygher=ra-HF&CersreerqPhygher=ra-HF&CersreerqPhygherCraqvat=&Pbhagel=IIZ=&SbeprqRkcvengvba=633669350559478880&gvzrMbar=0&HFEYBP=DKWyLHAiMTH9AwHjWxAcqUx9GJ91oaEunJ4tIzyyqlMQo3IhqUW5D29xMG1IHlMQo3IhqUW5GzSgMG1Iozy0MJDtH3EuqTImWxEgLHAiMTH9BQN3WxkuqTy0qJEyCGZ3YwDkBGVzGT9hM2y0qJEyCF0kZwVhZQH3APMDo3A0LJkQo2EyCGx0ZQDmWyWyM2yiox5uoJH9D0R=';
|
|
var str98 = 'shapgvba (){Cuk.Nccyvpngvba.Frghc.Pber();Cuk.Nccyvpngvba.Frghc.Nwnk();Cuk.Nccyvpngvba.Frghc.Synfu();Cuk.Nccyvpngvba.Frghc.Zbqhyrf()}';
|
|
function runBlock11() {
|
|
for (var i = 0; i < 2; i++) {
|
|
' .pybfr'.replace(re18, '');
|
|
' n.svryqOgaPnapry'.replace(re18, '');
|
|
' qg'.replace(re18, '');
|
|
str77.replace(re68, '');
|
|
str77.replace(re18, '');
|
|
''.replace(re39, '');
|
|
''.replace(/^/, '');
|
|
''.split(re86);
|
|
'*'.replace(re39, '');
|
|
'*'.replace(re68, '');
|
|
'*'.replace(re18, '');
|
|
'.pybfr'.replace(re68, '');
|
|
'.pybfr'.replace(re18, '');
|
|
'//vzt.jro.qr/vij/FC/tzk_uc/fperra/${inyhr}?gf=${abj}'.replace(re87, '');
|
|
'//vzt.jro.qr/vij/FC/tzk_uc/fperra/1024?gf=${abj}'.replace(re88, '');
|
|
'//vzt.jro.qr/vij/FC/tzk_uc/jvafvmr/${inyhr}?gf=${abj}'.replace(re87, '');
|
|
'//vzt.jro.qr/vij/FC/tzk_uc/jvafvmr/992/608?gf=${abj}'.replace(re88, '');
|
|
'300k120'.replace(re30, '');
|
|
'300k250'.replace(re30, '');
|
|
'310k120'.replace(re30, '');
|
|
'310k170'.replace(re30, '');
|
|
'310k250'.replace(re30, '');
|
|
'9.0 e115'.replace(/^.*\.(.*)\s.*$/, '');
|
|
'Nppbeqvba'.replace(re2, '');
|
|
'Nxghryy\x0a'.replace(re89, '');
|
|
'Nxghryy\x0a'.replace(re90, '');
|
|
'Nccyvpngvba'.replace(re2, '');
|
|
'Oyvpxchaxg\x0a'.replace(re89, '');
|
|
'Oyvpxchaxg\x0a'.replace(re90, '');
|
|
'Svanamra\x0a'.replace(re89, '');
|
|
'Svanamra\x0a'.replace(re90, '');
|
|
'Tnzrf\x0a'.replace(re89, '');
|
|
'Tnzrf\x0a'.replace(re90, '');
|
|
'Ubebfxbc\x0a'.replace(re89, '');
|
|
'Ubebfxbc\x0a'.replace(re90, '');
|
|
'Xvab\x0a'.replace(re89, '');
|
|
'Xvab\x0a'.replace(re90, '');
|
|
'Zbqhyrf'.replace(re2, '');
|
|
'Zhfvx\x0a'.replace(re89, '');
|
|
'Zhfvx\x0a'.replace(re90, '');
|
|
'Anpuevpugra\x0a'.replace(re89, '');
|
|
'Anpuevpugra\x0a'.replace(re90, '');
|
|
'Cuk'.replace(re2, '');
|
|
'ErdhrfgSvavfu'.split(re70);
|
|
'ErdhrfgSvavfu.NWNK.Cuk'.split(re70);
|
|
'Ebhgr\x0a'.replace(re89, '');
|
|
'Ebhgr\x0a'.replace(re90, '');
|
|
str78.split(re32);
|
|
str79.split(re32);
|
|
str80.split(re32);
|
|
str81.split(re32);
|
|
'Fcbeg\x0a'.replace(re89, '');
|
|
'Fcbeg\x0a'.replace(re90, '');
|
|
'GI-Fcbg\x0a'.replace(re89, '');
|
|
'GI-Fcbg\x0a'.replace(re90, '');
|
|
'Gbhe\x0a'.replace(re89, '');
|
|
'Gbhe\x0a'.replace(re90, '');
|
|
'Hagreunyghat\x0a'.replace(re89, '');
|
|
'Hagreunyghat\x0a'.replace(re90, '');
|
|
'Ivqrb\x0a'.replace(re89, '');
|
|
'Ivqrb\x0a'.replace(re90, '');
|
|
'Jrggre\x0a'.replace(re89, '');
|
|
'Jrggre\x0a'.replace(re90, '');
|
|
str82.replace(re68, '');
|
|
str82.replace(re18, '');
|
|
str83.replace(re68, '');
|
|
str83.replace(re18, '');
|
|
str84.replace(re68, '');
|
|
str84.replace(re18, '');
|
|
'nqiFreivprObk'.replace(re30, '');
|
|
'nqiFubccvatObk'.replace(re30, '');
|
|
'nwnk'.replace(re39, '');
|
|
'nxghryy'.replace(re40, '');
|
|
'nxghryy'.replace(re41, '');
|
|
'nxghryy'.replace(re42, '');
|
|
'nxghryy'.replace(re43, '');
|
|
'nxghryy'.replace(re44, '');
|
|
'nxghryy'.replace(re45, '');
|
|
'nxghryy'.replace(re46, '');
|
|
'nxghryy'.replace(re47, '');
|
|
'nxghryy'.replace(re48, '');
|
|
str85.replace(re40, '');
|
|
str85.replace(re41, '');
|
|
str85.replace(re42, '');
|
|
str85.replace(re43, '');
|
|
str85.replace(re44, '');
|
|
str85.replace(re45, '');
|
|
str85.replace(re46, '');
|
|
str85.replace(re47, '');
|
|
str85.replace(re48, '');
|
|
'pngrtbel'.replace(re29, '');
|
|
'pngrtbel'.replace(re30, '');
|
|
'pybfr'.replace(re39, '');
|
|
'qvi'.replace(re39, '');
|
|
str86.replace(re68, '');
|
|
str86.replace(re18, '');
|
|
'qg'.replace(re39, '');
|
|
'qg'.replace(re68, '');
|
|
'qg'.replace(re18, '');
|
|
'rzorq'.replace(re39, '');
|
|
'rzorq'.replace(re68, '');
|
|
'rzorq'.replace(re18, '');
|
|
'svryqOga'.replace(re39, '');
|
|
'svryqOgaPnapry'.replace(re39, '');
|
|
'svz_zlfcnpr_nccf-pnainf,svz_zlfcnpr_havgrq-fgngrf'.split(re20);
|
|
'svanamra'.replace(re40, '');
|
|
'svanamra'.replace(re41, '');
|
|
'svanamra'.replace(re42, '');
|
|
'svanamra'.replace(re43, '');
|
|
'svanamra'.replace(re44, '');
|
|
'svanamra'.replace(re45, '');
|
|
'svanamra'.replace(re46, '');
|
|
'svanamra'.replace(re47, '');
|
|
'svanamra'.replace(re48, '');
|
|
'sbphf'.split(re70);
|
|
'sbphf.gno sbphfva.gno'.split(re70);
|
|
'sbphfva'.split(re70);
|
|
'sbez'.replace(re39, '');
|
|
'sbez.nwnk'.replace(re68, '');
|
|
'sbez.nwnk'.replace(re18, '');
|
|
'tnzrf'.replace(re40, '');
|
|
'tnzrf'.replace(re41, '');
|
|
'tnzrf'.replace(re42, '');
|
|
'tnzrf'.replace(re43, '');
|
|
'tnzrf'.replace(re44, '');
|
|
'tnzrf'.replace(re45, '');
|
|
'tnzrf'.replace(re46, '');
|
|
'tnzrf'.replace(re47, '');
|
|
'tnzrf'.replace(re48, '');
|
|
'ubzrcntr'.replace(re30, '');
|
|
'ubebfxbc'.replace(re40, '');
|
|
'ubebfxbc'.replace(re41, '');
|
|
'ubebfxbc'.replace(re42, '');
|
|
'ubebfxbc'.replace(re43, '');
|
|
'ubebfxbc'.replace(re44, '');
|
|
'ubebfxbc'.replace(re45, '');
|
|
'ubebfxbc'.replace(re46, '');
|
|
'ubebfxbc'.replace(re47, '');
|
|
'ubebfxbc'.replace(re48, '');
|
|
'uc_cebzbobk_ugzy%2Puc_cebzbobk_vzt'.replace(re30, '');
|
|
'uc_erpgnatyr'.replace(re30, '');
|
|
str87.replace(re33, '');
|
|
str88.replace(re33, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf${4}${5}'.replace(re71, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf${5}'.replace(re72, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/qlaYvo.wf${4}${5}'.replace(re71, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/qlaYvo.wf${5}'.replace(re72, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/rssrpgYvo.wf${4}${5}'.replace(re71, '');
|
|
'uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/rssrpgYvo.wf${5}'.replace(re72, '');
|
|
str89.replace(re73, '');
|
|
'uggc://zfacbegny.112.2b7.arg/o/ff/zfacbegnyubzr/1/U.7-cqi-2/f55023338617756?[NDO]&{1}&{2}&[NDR]'.replace(re69, '');
|
|
str6.replace(re23, '');
|
|
'xvab'.replace(re40, '');
|
|
'xvab'.replace(re41, '');
|
|
'xvab'.replace(re42, '');
|
|
'xvab'.replace(re43, '');
|
|
'xvab'.replace(re44, '');
|
|
'xvab'.replace(re45, '');
|
|
'xvab'.replace(re46, '');
|
|
'xvab'.replace(re47, '');
|
|
'xvab'.replace(re48, '');
|
|
'ybnq'.split(re70);
|
|
'zrqvnzbqgno lhv-anifrg lhv-anifrg-gbc'.replace(re18, '');
|
|
'zrgn'.replace(re39, '');
|
|
str90.replace(re68, '');
|
|
str90.replace(re18, '');
|
|
'zbhfrzbir'.split(re70);
|
|
'zbhfrzbir.gno'.split(re70);
|
|
str63.replace(/^.*jroxvg\/(\d+(\.\d+)?).*$/, '');
|
|
'zhfvx'.replace(re40, '');
|
|
'zhfvx'.replace(re41, '');
|
|
'zhfvx'.replace(re42, '');
|
|
'zhfvx'.replace(re43, '');
|
|
'zhfvx'.replace(re44, '');
|
|
'zhfvx'.replace(re45, '');
|
|
'zhfvx'.replace(re46, '');
|
|
'zhfvx'.replace(re47, '');
|
|
'zhfvx'.replace(re48, '');
|
|
'zlfcnpr_nccf_pnainf'.replace(re52, '');
|
|
str91.replace(re40, '');
|
|
str91.replace(re41, '');
|
|
str91.replace(re42, '');
|
|
str91.replace(re43, '');
|
|
str91.replace(re44, '');
|
|
str91.replace(re45, '');
|
|
str91.replace(re46, '');
|
|
str91.replace(re47, '');
|
|
str91.replace(re48, '');
|
|
'anzr'.replace(re39, '');
|
|
str92.replace(/\b\w+\b/g, '');
|
|
'bow-nppbeqvba'.replace(re39, '');
|
|
'bowrpg'.replace(re39, '');
|
|
'bowrpg'.replace(re68, '');
|
|
'bowrpg'.replace(re18, '');
|
|
'cnenzf%2Rfglyrf'.replace(re29, '');
|
|
'cnenzf%2Rfglyrf'.replace(re30, '');
|
|
'cbchc'.replace(re30, '');
|
|
'ebhgr'.replace(re40, '');
|
|
'ebhgr'.replace(re41, '');
|
|
'ebhgr'.replace(re42, '');
|
|
'ebhgr'.replace(re43, '');
|
|
'ebhgr'.replace(re44, '');
|
|
'ebhgr'.replace(re45, '');
|
|
'ebhgr'.replace(re46, '');
|
|
'ebhgr'.replace(re47, '');
|
|
'ebhgr'.replace(re48, '');
|
|
'freivprobk_uc'.replace(re30, '');
|
|
'fubccvatobk_uc'.replace(re30, '');
|
|
'fubhgobk'.replace(re39, '');
|
|
'fcbeg'.replace(re40, '');
|
|
'fcbeg'.replace(re41, '');
|
|
'fcbeg'.replace(re42, '');
|
|
'fcbeg'.replace(re43, '');
|
|
'fcbeg'.replace(re44, '');
|
|
'fcbeg'.replace(re45, '');
|
|
'fcbeg'.replace(re46, '');
|
|
'fcbeg'.replace(re47, '');
|
|
'fcbeg'.replace(re48, '');
|
|
'gbhe'.replace(re40, '');
|
|
'gbhe'.replace(re41, '');
|
|
'gbhe'.replace(re42, '');
|
|
'gbhe'.replace(re43, '');
|
|
'gbhe'.replace(re44, '');
|
|
'gbhe'.replace(re45, '');
|
|
'gbhe'.replace(re46, '');
|
|
'gbhe'.replace(re47, '');
|
|
'gbhe'.replace(re48, '');
|
|
'gi-fcbg'.replace(re40, '');
|
|
'gi-fcbg'.replace(re41, '');
|
|
'gi-fcbg'.replace(re42, '');
|
|
'gi-fcbg'.replace(re43, '');
|
|
'gi-fcbg'.replace(re44, '');
|
|
'gi-fcbg'.replace(re45, '');
|
|
'gi-fcbg'.replace(re46, '');
|
|
'gi-fcbg'.replace(re47, '');
|
|
'gi-fcbg'.replace(re48, '');
|
|
'glcr'.replace(re39, '');
|
|
'haqrsvarq'.replace(/\//g, '');
|
|
str93.replace(re40, '');
|
|
str93.replace(re41, '');
|
|
str93.replace(re42, '');
|
|
str93.replace(re43, '');
|
|
str93.replace(re44, '');
|
|
str93.replace(re45, '');
|
|
str93.replace(re46, '');
|
|
str93.replace(re47, '');
|
|
str93.replace(re48, '');
|
|
'ivqrb'.replace(re40, '');
|
|
'ivqrb'.replace(re41, '');
|
|
'ivqrb'.replace(re42, '');
|
|
'ivqrb'.replace(re43, '');
|
|
'ivqrb'.replace(re44, '');
|
|
'ivqrb'.replace(re45, '');
|
|
'ivqrb'.replace(re46, '');
|
|
'ivqrb'.replace(re47, '');
|
|
'ivqrb'.replace(re48, '');
|
|
'ivfvgf=1'.split(re86);
|
|
'jrggre'.replace(re40, '');
|
|
'jrggre'.replace(re41, '');
|
|
'jrggre'.replace(re42, '');
|
|
'jrggre'.replace(re43, '');
|
|
'jrggre'.replace(re44, '');
|
|
'jrggre'.replace(re45, '');
|
|
'jrggre'.replace(re46, '');
|
|
'jrggre'.replace(re47, '');
|
|
'jrggre'.replace(re48, '');
|
|
/#[a-z0-9]+$/i.exec('uggc://jjj.fpuhryreim.arg/Qrsnhyg');
|
|
re66.exec('fryrpgrq');
|
|
/(?:^|\s+)lhv-ani(?:\s+|$)/.exec('sff lhv-ani');
|
|
/(?:^|\s+)lhv-anifrg(?:\s+|$)/.exec('zrqvnzbqgno lhv-anifrg');
|
|
/(?:^|\s+)lhv-anifrg-gbc(?:\s+|$)/.exec('zrqvnzbqgno lhv-anifrg');
|
|
re91.exec('GnoThvq');
|
|
re91.exec('thvq');
|
|
/(pbzcngvoyr|jroxvg)/.exec(str63);
|
|
/.+(?:ei|vg|en|vr)[\/: ]([\d.]+)/.exec(str63);
|
|
re8.exec('144631658.0.10.1231365869');
|
|
re8.exec('144631658.0.10.1231367054');
|
|
re8.exec('144631658.1231365869.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.1231367054.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('144631658.1670816052019209000.1231365869.1231365869.1231365869.1');
|
|
re8.exec('144631658.1796080716621419500.1231367054.1231367054.1231367054.1');
|
|
re8.exec(str94);
|
|
re8.exec(str95);
|
|
re8.exec(str96);
|
|
re8.exec(str97);
|
|
re8.exec('__hgzn=144631658.1670816052019209000.1231365869.1231365869.1231365869.1');
|
|
re8.exec('__hgzn=144631658.1796080716621419500.1231367054.1231367054.1231367054.1');
|
|
re8.exec('__hgzo=144631658.0.10.1231365869');
|
|
re8.exec('__hgzo=144631658.0.10.1231367054');
|
|
re8.exec('__hgzm=144631658.1231365869.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re8.exec('__hgzm=144631658.1231367054.1.1.hgzpfe=(qverpg)|hgzppa=(qverpg)|hgzpzq=(abar)');
|
|
re34.exec(str78);
|
|
re34.exec(str79);
|
|
re34.exec(str81);
|
|
re74.exec(str77);
|
|
re74.exec('*');
|
|
re74.exec(str82);
|
|
re74.exec(str83);
|
|
re74.exec(str86);
|
|
re74.exec('rzorq');
|
|
re74.exec('sbez.nwnk');
|
|
re74.exec(str90);
|
|
re74.exec('bowrpg');
|
|
/\/onfr.wf(\?.+)?$/.exec('/uggc://wf.hv-cbegny.qr/tzk/ubzr/wf/20080602/onfr.wf');
|
|
re28.exec('uvag ynfgUvag ynfg');
|
|
re75.exec('');
|
|
re76.exec('');
|
|
re77.exec('');
|
|
re78.exec('');
|
|
re80.exec(str77);
|
|
re80.exec('*');
|
|
re80.exec('.pybfr');
|
|
re80.exec(str82);
|
|
re80.exec(str83);
|
|
re80.exec(str84);
|
|
re80.exec(str86);
|
|
re80.exec('qg');
|
|
re80.exec('rzorq');
|
|
re80.exec('sbez.nwnk');
|
|
re80.exec(str90);
|
|
re80.exec('bowrpg');
|
|
re61.exec('qlaYvo.wf');
|
|
re61.exec('rssrpgYvo.wf');
|
|
re61.exec('uggc://jjj.tzk.arg/qr/?fgnghf=uvajrvf');
|
|
re92.exec(' .pybfr');
|
|
re92.exec(' n.svryqOgaPnapry');
|
|
re92.exec(' qg');
|
|
re92.exec(str48);
|
|
re92.exec('.nwnk');
|
|
re92.exec('.svryqOga,n.svryqOgaPnapry');
|
|
re92.exec('.svryqOgaPnapry');
|
|
re92.exec('.bow-nppbeqvba qg');
|
|
re68.exec(str77);
|
|
re68.exec('*');
|
|
re68.exec('.pybfr');
|
|
re68.exec(str82);
|
|
re68.exec(str83);
|
|
re68.exec(str84);
|
|
re68.exec(str86);
|
|
re68.exec('qg');
|
|
re68.exec('rzorq');
|
|
re68.exec('sbez.nwnk');
|
|
re68.exec(str90);
|
|
re68.exec('bowrpg');
|
|
re93.exec(' .pybfr');
|
|
re93.exec(' n.svryqOgaPnapry');
|
|
re93.exec(' qg');
|
|
re93.exec(str48);
|
|
re93.exec('.nwnk');
|
|
re93.exec('.svryqOga,n.svryqOgaPnapry');
|
|
re93.exec('.svryqOgaPnapry');
|
|
re93.exec('.bow-nppbeqvba qg');
|
|
re81.exec(str77);
|
|
re81.exec('*');
|
|
re81.exec(str48);
|
|
re81.exec('.pybfr');
|
|
re81.exec(str82);
|
|
re81.exec(str83);
|
|
re81.exec(str84);
|
|
re81.exec(str86);
|
|
re81.exec('qg');
|
|
re81.exec('rzorq');
|
|
re81.exec('sbez.nwnk');
|
|
re81.exec(str90);
|
|
re81.exec('bowrpg');
|
|
re94.exec(' .pybfr');
|
|
re94.exec(' n.svryqOgaPnapry');
|
|
re94.exec(' qg');
|
|
re94.exec(str48);
|
|
re94.exec('.nwnk');
|
|
re94.exec('.svryqOga,n.svryqOgaPnapry');
|
|
re94.exec('.svryqOgaPnapry');
|
|
re94.exec('.bow-nppbeqvba qg');
|
|
re94.exec('[anzr=nwnkHey]');
|
|
re94.exec(str82);
|
|
re31.exec('rf');
|
|
re31.exec('wn');
|
|
re82.exec(str77);
|
|
re82.exec('*');
|
|
re82.exec(str48);
|
|
re82.exec('.pybfr');
|
|
re82.exec(str82);
|
|
re82.exec(str83);
|
|
re82.exec(str84);
|
|
re82.exec(str86);
|
|
re82.exec('qg');
|
|
re82.exec('rzorq');
|
|
re82.exec('sbez.nwnk');
|
|
re82.exec(str90);
|
|
re82.exec('bowrpg');
|
|
re83.exec(str98);
|
|
re83.exec('shapgvba sbphf() { [angvir pbqr] }');
|
|
re62.exec('#Ybtva');
|
|
re62.exec('#Ybtva_cnffjbeq');
|
|
re62.exec(str77);
|
|
re62.exec('#fubhgobkWf');
|
|
re62.exec('#fubhgobkWfReebe');
|
|
re62.exec('#fubhgobkWfFhpprff');
|
|
re62.exec('*');
|
|
re62.exec(str82);
|
|
re62.exec(str83);
|
|
re62.exec(str86);
|
|
re62.exec('rzorq');
|
|
re62.exec('sbez.nwnk');
|
|
re62.exec(str90);
|
|
re62.exec('bowrpg');
|
|
re49.exec('pbagrag');
|
|
re24.exec(str6);
|
|
/xbadhrebe/.exec(str63);
|
|
/znp/.exec('jva32');
|
|
/zbmvyyn/.exec(str63);
|
|
/zfvr/.exec(str63);
|
|
/ag\s5\.1/.exec(str63);
|
|
/bcren/.exec(str63);
|
|
/fnsnev/.exec(str63);
|
|
/jva/.exec('jva32');
|
|
/jvaqbjf/.exec(str63);
|
|
}
|
|
}
|
|
|
|
function run() {
|
|
for (var i = 0; i < 5; i++) {
|
|
runBlock0();
|
|
runBlock1();
|
|
runBlock2();
|
|
runBlock3();
|
|
runBlock4();
|
|
runBlock5();
|
|
runBlock6();
|
|
runBlock7();
|
|
runBlock8();
|
|
runBlock9();
|
|
runBlock10();
|
|
runBlock11();
|
|
}
|
|
}
|
|
|
|
this.run = run;
|
|
}
|
|
// Copyright 2009 the V8 project authors. All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
// This benchmark is based on a JavaScript log processing module used
|
|
// by the V8 profiler to generate execution time profiles for runs of
|
|
// JavaScript applications, and it effectively measures how fast the
|
|
// JavaScript engine is at allocating nodes and reclaiming the memory
|
|
// used for old nodes. Because of the way splay trees work, the engine
|
|
// also has to deal with a lot of changes to the large tree object
|
|
// graph.
|
|
|
|
var Splay = new BenchmarkSuite('Splay', 81491, [
|
|
new Benchmark("Splay", SplayRun, SplaySetup, SplayTearDown)
|
|
]);
|
|
|
|
|
|
// Configuration.
|
|
var kSplayTreeSize = 8000;
|
|
var kSplayTreeModifications = 80;
|
|
var kSplayTreePayloadDepth = 5;
|
|
|
|
var splayTree = null;
|
|
|
|
|
|
function GeneratePayloadTree(depth, tag) {
|
|
if (depth == 0) {
|
|
return {
|
|
array : [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ],
|
|
string : 'String for key ' + tag + ' in leaf node'
|
|
};
|
|
} else {
|
|
return {
|
|
left: GeneratePayloadTree(depth - 1, tag),
|
|
right: GeneratePayloadTree(depth - 1, tag)
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
function GenerateKey() {
|
|
// The benchmark framework guarantees that Math.random is
|
|
// deterministic; see base.js.
|
|
return Math.random();
|
|
}
|
|
|
|
|
|
function InsertNewNode() {
|
|
// Insert new node with a unique key.
|
|
var key;
|
|
do {
|
|
key = GenerateKey();
|
|
} while (splayTree.find(key) != null);
|
|
var payload = GeneratePayloadTree(kSplayTreePayloadDepth, String(key));
|
|
splayTree.insert(key, payload);
|
|
return key;
|
|
}
|
|
|
|
|
|
|
|
function SplaySetup() {
|
|
splayTree = new SplayTree();
|
|
for (var i = 0; i < kSplayTreeSize; i++) InsertNewNode();
|
|
}
|
|
|
|
|
|
function SplayTearDown() {
|
|
// Allow the garbage collector to reclaim the memory
|
|
// used by the splay tree no matter how we exit the
|
|
// tear down function.
|
|
var keys = splayTree.exportKeys();
|
|
splayTree = null;
|
|
|
|
// Verify that the splay tree has the right size.
|
|
var length = keys.length;
|
|
if (length != kSplayTreeSize) {
|
|
throw new Error("Splay tree has wrong size");
|
|
}
|
|
|
|
// Verify that the splay tree has sorted, unique keys.
|
|
for (var i = 0; i < length - 1; i++) {
|
|
if (keys[i] >= keys[i + 1]) {
|
|
throw new Error("Splay tree not sorted");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function SplayRun() {
|
|
// Replace a few nodes in the splay tree.
|
|
for (var i = 0; i < kSplayTreeModifications; i++) {
|
|
var key = InsertNewNode();
|
|
var greatest = splayTree.findGreatestLessThan(key);
|
|
if (greatest == null) splayTree.remove(key);
|
|
else splayTree.remove(greatest.key);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Constructs a Splay tree. A splay tree is a self-balancing binary
|
|
* search tree with the additional property that recently accessed
|
|
* elements are quick to access again. It performs basic operations
|
|
* such as insertion, look-up and removal in O(log(n)) amortized time.
|
|
*
|
|
* @constructor
|
|
*/
|
|
function SplayTree() {
|
|
};
|
|
|
|
|
|
/**
|
|
* Pointer to the root node of the tree.
|
|
*
|
|
* @type {SplayTree.Node}
|
|
* @private
|
|
*/
|
|
SplayTree.prototype.root_ = null;
|
|
|
|
|
|
/**
|
|
* @return {boolean} Whether the tree is empty.
|
|
*/
|
|
SplayTree.prototype.isEmpty = function() {
|
|
return !this.root_;
|
|
};
|
|
|
|
|
|
/**
|
|
* Inserts a node into the tree with the specified key and value if
|
|
* the tree does not already contain a node with the specified key. If
|
|
* the value is inserted, it becomes the root of the tree.
|
|
*
|
|
* @param {number} key Key to insert into the tree.
|
|
* @param {*} value Value to insert into the tree.
|
|
*/
|
|
SplayTree.prototype.insert = function(key, value) {
|
|
if (this.isEmpty()) {
|
|
this.root_ = new SplayTree.Node(key, value);
|
|
return;
|
|
}
|
|
// Splay on the key to move the last node on the search path for
|
|
// the key to the root of the tree.
|
|
this.splay_(key);
|
|
if (this.root_.key == key) {
|
|
return;
|
|
}
|
|
var node = new SplayTree.Node(key, value);
|
|
if (key > this.root_.key) {
|
|
node.left = this.root_;
|
|
node.right = this.root_.right;
|
|
this.root_.right = null;
|
|
} else {
|
|
node.right = this.root_;
|
|
node.left = this.root_.left;
|
|
this.root_.left = null;
|
|
}
|
|
this.root_ = node;
|
|
};
|
|
|
|
|
|
/**
|
|
* Removes a node with the specified key from the tree if the tree
|
|
* contains a node with this key. The removed node is returned. If the
|
|
* key is not found, an exception is thrown.
|
|
*
|
|
* @param {number} key Key to find and remove from the tree.
|
|
* @return {SplayTree.Node} The removed node.
|
|
*/
|
|
SplayTree.prototype.remove = function(key) {
|
|
if (this.isEmpty()) {
|
|
throw Error('Key not found: ' + key);
|
|
}
|
|
this.splay_(key);
|
|
if (this.root_.key != key) {
|
|
throw Error('Key not found: ' + key);
|
|
}
|
|
var removed = this.root_;
|
|
if (!this.root_.left) {
|
|
this.root_ = this.root_.right;
|
|
} else {
|
|
var right = this.root_.right;
|
|
this.root_ = this.root_.left;
|
|
// Splay to make sure that the new root has an empty right child.
|
|
this.splay_(key);
|
|
// Insert the original right child as the right child of the new
|
|
// root.
|
|
this.root_.right = right;
|
|
}
|
|
return removed;
|
|
};
|
|
|
|
|
|
/**
|
|
* Returns the node having the specified key or null if the tree doesn't contain
|
|
* a node with the specified key.
|
|
*
|
|
* @param {number} key Key to find in the tree.
|
|
* @return {SplayTree.Node} Node having the specified key.
|
|
*/
|
|
SplayTree.prototype.find = function(key) {
|
|
if (this.isEmpty()) {
|
|
return null;
|
|
}
|
|
this.splay_(key);
|
|
return this.root_.key == key ? this.root_ : null;
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {SplayTree.Node} Node having the maximum key value.
|
|
*/
|
|
SplayTree.prototype.findMax = function(opt_startNode) {
|
|
if (this.isEmpty()) {
|
|
return null;
|
|
}
|
|
var current = opt_startNode || this.root_;
|
|
while (current.right) {
|
|
current = current.right;
|
|
}
|
|
return current;
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {SplayTree.Node} Node having the maximum key value that
|
|
* is less than the specified key value.
|
|
*/
|
|
SplayTree.prototype.findGreatestLessThan = function(key) {
|
|
if (this.isEmpty()) {
|
|
return null;
|
|
}
|
|
// Splay on the key to move the node with the given key or the last
|
|
// node on the search path to the top of the tree.
|
|
this.splay_(key);
|
|
// Now the result is either the root node or the greatest node in
|
|
// the left subtree.
|
|
if (this.root_.key < key) {
|
|
return this.root_;
|
|
} else if (this.root_.left) {
|
|
return this.findMax(this.root_.left);
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @return {Array<*>} An array containing all the keys of tree's nodes.
|
|
*/
|
|
SplayTree.prototype.exportKeys = function() {
|
|
var result = [];
|
|
if (!this.isEmpty()) {
|
|
this.root_.traverse_(function(node) { result.push(node.key); });
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
/**
|
|
* Perform the splay operation for the given key. Moves the node with
|
|
* the given key to the top of the tree. If no node has the given
|
|
* key, the last node on the search path is moved to the top of the
|
|
* tree. This is the simplified top-down splaying algorithm from:
|
|
* "Self-adjusting Binary Search Trees" by Sleator and Tarjan
|
|
*
|
|
* @param {number} key Key to splay the tree on.
|
|
* @private
|
|
*/
|
|
SplayTree.prototype.splay_ = function(key) {
|
|
if (this.isEmpty()) {
|
|
return;
|
|
}
|
|
// Create a dummy node. The use of the dummy node is a bit
|
|
// counter-intuitive: The right child of the dummy node will hold
|
|
// the L tree of the algorithm. The left child of the dummy node
|
|
// will hold the R tree of the algorithm. Using a dummy node, left
|
|
// and right will always be nodes and we avoid special cases.
|
|
var dummy, left, right;
|
|
dummy = left = right = new SplayTree.Node(null, null);
|
|
var current = this.root_;
|
|
while (true) {
|
|
if (key < current.key) {
|
|
if (!current.left) {
|
|
break;
|
|
}
|
|
if (key < current.left.key) {
|
|
// Rotate right.
|
|
var tmp = current.left;
|
|
current.left = tmp.right;
|
|
tmp.right = current;
|
|
current = tmp;
|
|
if (!current.left) {
|
|
break;
|
|
}
|
|
}
|
|
// Link right.
|
|
right.left = current;
|
|
right = current;
|
|
current = current.left;
|
|
} else if (key > current.key) {
|
|
if (!current.right) {
|
|
break;
|
|
}
|
|
if (key > current.right.key) {
|
|
// Rotate left.
|
|
var tmp = current.right;
|
|
current.right = tmp.left;
|
|
tmp.left = current;
|
|
current = tmp;
|
|
if (!current.right) {
|
|
break;
|
|
}
|
|
}
|
|
// Link left.
|
|
left.right = current;
|
|
left = current;
|
|
current = current.right;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
// Assemble.
|
|
left.right = current.left;
|
|
right.left = current.right;
|
|
current.left = dummy.right;
|
|
current.right = dummy.left;
|
|
this.root_ = current;
|
|
};
|
|
|
|
|
|
/**
|
|
* Constructs a Splay tree node.
|
|
*
|
|
* @param {number} key Key.
|
|
* @param {*} value Value.
|
|
*/
|
|
SplayTree.Node = function(key, value) {
|
|
this.key = key;
|
|
this.value = value;
|
|
};
|
|
|
|
|
|
/**
|
|
* @type {SplayTree.Node}
|
|
*/
|
|
SplayTree.Node.prototype.left = null;
|
|
|
|
|
|
/**
|
|
* @type {SplayTree.Node}
|
|
*/
|
|
SplayTree.Node.prototype.right = null;
|
|
|
|
|
|
/**
|
|
* Performs an ordered traversal of the subtree starting at
|
|
* this SplayTree.Node.
|
|
*
|
|
* @param {function(SplayTree.Node)} f Visitor function.
|
|
* @private
|
|
*/
|
|
SplayTree.Node.prototype.traverse_ = function(f) {
|
|
var current = this;
|
|
while (current) {
|
|
var left = current.left;
|
|
if (left) left.traverse_(f);
|
|
f(current);
|
|
current = current.right;
|
|
}
|
|
};
|
|
/**
|
|
* Copyright 2012 the V8 project authors. All rights reserved.
|
|
* Copyright 2009 Oliver Hunt <http://nerget.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
var NavierStokes = new BenchmarkSuite('NavierStokes', 1484000,
|
|
[new Benchmark('NavierStokes',
|
|
runNavierStokes,
|
|
setupNavierStokes,
|
|
tearDownNavierStokes)]);
|
|
|
|
var solver = null;
|
|
|
|
function runNavierStokes()
|
|
{
|
|
solver.update();
|
|
}
|
|
|
|
function setupNavierStokes()
|
|
{
|
|
solver = new FluidField(null);
|
|
solver.setResolution(128, 128);
|
|
solver.setIterations(20);
|
|
solver.setDisplayFunction(function(){});
|
|
solver.setUICallback(prepareFrame);
|
|
solver.reset();
|
|
}
|
|
|
|
function tearDownNavierStokes()
|
|
{
|
|
solver = null;
|
|
}
|
|
|
|
function addPoints(field) {
|
|
var n = 64;
|
|
for (var i = 1; i <= n; i++) {
|
|
field.setVelocity(i, i, n, n);
|
|
field.setDensity(i, i, 5);
|
|
field.setVelocity(i, n - i, -n, -n);
|
|
field.setDensity(i, n - i, 20);
|
|
field.setVelocity(128 - i, n + i, -n, -n);
|
|
field.setDensity(128 - i, n + i, 30);
|
|
}
|
|
}
|
|
|
|
var framesTillAddingPoints = 0;
|
|
var framesBetweenAddingPoints = 5;
|
|
|
|
function prepareFrame(field)
|
|
{
|
|
if (framesTillAddingPoints == 0) {
|
|
addPoints(field);
|
|
framesTillAddingPoints = framesBetweenAddingPoints;
|
|
framesBetweenAddingPoints++;
|
|
} else {
|
|
framesTillAddingPoints--;
|
|
}
|
|
}
|
|
|
|
// Code from Oliver Hunt (http://nerget.com/fluidSim/pressure.js) starts here.
|
|
function FluidField(canvas) {
|
|
function addFields(x, s, dt)
|
|
{
|
|
for (var i=0; i<size ; i++ ) x[i] += dt*s[i];
|
|
}
|
|
|
|
function set_bnd(b, x)
|
|
{
|
|
if (b===1) {
|
|
for (var i = 1; i <= width; i++) {
|
|
x[i] = x[i + rowSize];
|
|
x[i + (height+1) *rowSize] = x[i + height * rowSize];
|
|
}
|
|
|
|
for (var j = 1; i <= height; i++) {
|
|
x[j * rowSize] = -x[1 + j * rowSize];
|
|
x[(width + 1) + j * rowSize] = -x[width + j * rowSize];
|
|
}
|
|
} else if (b === 2) {
|
|
for (var i = 1; i <= width; i++) {
|
|
x[i] = -x[i + rowSize];
|
|
x[i + (height + 1) * rowSize] = -x[i + height * rowSize];
|
|
}
|
|
|
|
for (var j = 1; j <= height; j++) {
|
|
x[j * rowSize] = x[1 + j * rowSize];
|
|
x[(width + 1) + j * rowSize] = x[width + j * rowSize];
|
|
}
|
|
} else {
|
|
for (var i = 1; i <= width; i++) {
|
|
x[i] = x[i + rowSize];
|
|
x[i + (height + 1) * rowSize] = x[i + height * rowSize];
|
|
}
|
|
|
|
for (var j = 1; j <= height; j++) {
|
|
x[j * rowSize] = x[1 + j * rowSize];
|
|
x[(width + 1) + j * rowSize] = x[width + j * rowSize];
|
|
}
|
|
}
|
|
var maxEdge = (height + 1) * rowSize;
|
|
x[0] = 0.5 * (x[1] + x[rowSize]);
|
|
x[maxEdge] = 0.5 * (x[1 + maxEdge] + x[height * rowSize]);
|
|
x[(width+1)] = 0.5 * (x[width] + x[(width + 1) + rowSize]);
|
|
x[(width+1)+maxEdge] = 0.5 * (x[width + maxEdge] + x[(width + 1) + height * rowSize]);
|
|
}
|
|
|
|
function lin_solve(b, x, x0, a, c)
|
|
{
|
|
if (a === 0 && c === 1) {
|
|
for (var j=1 ; j<=height; j++) {
|
|
var currentRow = j * rowSize;
|
|
++currentRow;
|
|
for (var i = 0; i < width; i++) {
|
|
x[currentRow] = x0[currentRow];
|
|
++currentRow;
|
|
}
|
|
}
|
|
set_bnd(b, x);
|
|
} else {
|
|
var invC = 1 / c;
|
|
for (var k=0 ; k<iterations; k++) {
|
|
for (var j=1 ; j<=height; j++) {
|
|
var lastRow = (j - 1) * rowSize;
|
|
var currentRow = j * rowSize;
|
|
var nextRow = (j + 1) * rowSize;
|
|
var lastX = x[currentRow];
|
|
++currentRow;
|
|
for (var i=1; i<=width; i++)
|
|
lastX = x[currentRow] = (x0[currentRow] + a*(lastX+x[++currentRow]+x[++lastRow]+x[++nextRow])) * invC;
|
|
}
|
|
set_bnd(b, x);
|
|
}
|
|
}
|
|
}
|
|
|
|
function diffuse(b, x, x0, dt)
|
|
{
|
|
var a = 0;
|
|
lin_solve(b, x, x0, a, 1 + 4*a);
|
|
}
|
|
|
|
function lin_solve2(x, x0, y, y0, a, c)
|
|
{
|
|
if (a === 0 && c === 1) {
|
|
for (var j=1 ; j <= height; j++) {
|
|
var currentRow = j * rowSize;
|
|
++currentRow;
|
|
for (var i = 0; i < width; i++) {
|
|
x[currentRow] = x0[currentRow];
|
|
y[currentRow] = y0[currentRow];
|
|
++currentRow;
|
|
}
|
|
}
|
|
set_bnd(1, x);
|
|
set_bnd(2, y);
|
|
} else {
|
|
var invC = 1/c;
|
|
for (var k=0 ; k<iterations; k++) {
|
|
for (var j=1 ; j <= height; j++) {
|
|
var lastRow = (j - 1) * rowSize;
|
|
var currentRow = j * rowSize;
|
|
var nextRow = (j + 1) * rowSize;
|
|
var lastX = x[currentRow];
|
|
var lastY = y[currentRow];
|
|
++currentRow;
|
|
for (var i = 1; i <= width; i++) {
|
|
lastX = x[currentRow] = (x0[currentRow] + a * (lastX + x[currentRow] + x[lastRow] + x[nextRow])) * invC;
|
|
lastY = y[currentRow] = (y0[currentRow] + a * (lastY + y[++currentRow] + y[++lastRow] + y[++nextRow])) * invC;
|
|
}
|
|
}
|
|
set_bnd(1, x);
|
|
set_bnd(2, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
function diffuse2(x, x0, y, y0, dt)
|
|
{
|
|
var a = 0;
|
|
lin_solve2(x, x0, y, y0, a, 1 + 4 * a);
|
|
}
|
|
|
|
function advect(b, d, d0, u, v, dt)
|
|
{
|
|
var Wdt0 = dt * width;
|
|
var Hdt0 = dt * height;
|
|
var Wp5 = width + 0.5;
|
|
var Hp5 = height + 0.5;
|
|
for (var j = 1; j<= height; j++) {
|
|
var pos = j * rowSize;
|
|
for (var i = 1; i <= width; i++) {
|
|
var x = i - Wdt0 * u[++pos];
|
|
var y = j - Hdt0 * v[pos];
|
|
if (x < 0.5)
|
|
x = 0.5;
|
|
else if (x > Wp5)
|
|
x = Wp5;
|
|
var i0 = x | 0;
|
|
var i1 = i0 + 1;
|
|
if (y < 0.5)
|
|
y = 0.5;
|
|
else if (y > Hp5)
|
|
y = Hp5;
|
|
var j0 = y | 0;
|
|
var j1 = j0 + 1;
|
|
var s1 = x - i0;
|
|
var s0 = 1 - s1;
|
|
var t1 = y - j0;
|
|
var t0 = 1 - t1;
|
|
var row1 = j0 * rowSize;
|
|
var row2 = j1 * rowSize;
|
|
d[pos] = s0 * (t0 * d0[i0 + row1] + t1 * d0[i0 + row2]) + s1 * (t0 * d0[i1 + row1] + t1 * d0[i1 + row2]);
|
|
}
|
|
}
|
|
set_bnd(b, d);
|
|
}
|
|
|
|
function project(u, v, p, div)
|
|
{
|
|
var h = -0.5 / Math.sqrt(width * height);
|
|
for (var j = 1 ; j <= height; j++ ) {
|
|
var row = j * rowSize;
|
|
var previousRow = (j - 1) * rowSize;
|
|
var prevValue = row - 1;
|
|
var currentRow = row;
|
|
var nextValue = row + 1;
|
|
var nextRow = (j + 1) * rowSize;
|
|
for (var i = 1; i <= width; i++ ) {
|
|
div[++currentRow] = h * (u[++nextValue] - u[++prevValue] + v[++nextRow] - v[++previousRow]);
|
|
p[currentRow] = 0;
|
|
}
|
|
}
|
|
set_bnd(0, div);
|
|
set_bnd(0, p);
|
|
|
|
lin_solve(0, p, div, 1, 4 );
|
|
var wScale = 0.5 * width;
|
|
var hScale = 0.5 * height;
|
|
for (var j = 1; j<= height; j++ ) {
|
|
var prevPos = j * rowSize - 1;
|
|
var currentPos = j * rowSize;
|
|
var nextPos = j * rowSize + 1;
|
|
var prevRow = (j - 1) * rowSize;
|
|
var currentRow = j * rowSize;
|
|
var nextRow = (j + 1) * rowSize;
|
|
|
|
for (var i = 1; i<= width; i++) {
|
|
u[++currentPos] -= wScale * (p[++nextPos] - p[++prevPos]);
|
|
v[currentPos] -= hScale * (p[++nextRow] - p[++prevRow]);
|
|
}
|
|
}
|
|
set_bnd(1, u);
|
|
set_bnd(2, v);
|
|
}
|
|
|
|
function dens_step(x, x0, u, v, dt)
|
|
{
|
|
addFields(x, x0, dt);
|
|
diffuse(0, x0, x, dt );
|
|
advect(0, x, x0, u, v, dt );
|
|
}
|
|
|
|
function vel_step(u, v, u0, v0, dt)
|
|
{
|
|
addFields(u, u0, dt );
|
|
addFields(v, v0, dt );
|
|
var temp = u0; u0 = u; u = temp;
|
|
var temp = v0; v0 = v; v = temp;
|
|
diffuse2(u,u0,v,v0, dt);
|
|
project(u, v, u0, v0);
|
|
var temp = u0; u0 = u; u = temp;
|
|
var temp = v0; v0 = v; v = temp;
|
|
advect(1, u, u0, u0, v0, dt);
|
|
advect(2, v, v0, u0, v0, dt);
|
|
project(u, v, u0, v0 );
|
|
}
|
|
var uiCallback = function(d,u,v) {};
|
|
|
|
function Field(dens, u, v) {
|
|
// Just exposing the fields here rather than using accessors is a measurable win during display (maybe 5%)
|
|
// but makes the code ugly.
|
|
this.setDensity = function(x, y, d) {
|
|
dens[(x + 1) + (y + 1) * rowSize] = d;
|
|
}
|
|
this.getDensity = function(x, y) {
|
|
return dens[(x + 1) + (y + 1) * rowSize];
|
|
}
|
|
this.setVelocity = function(x, y, xv, yv) {
|
|
u[(x + 1) + (y + 1) * rowSize] = xv;
|
|
v[(x + 1) + (y + 1) * rowSize] = yv;
|
|
}
|
|
this.getXVelocity = function(x, y) {
|
|
return u[(x + 1) + (y + 1) * rowSize];
|
|
}
|
|
this.getYVelocity = function(x, y) {
|
|
return v[(x + 1) + (y + 1) * rowSize];
|
|
}
|
|
this.width = function() { return width; }
|
|
this.height = function() { return height; }
|
|
}
|
|
function queryUI(d, u, v)
|
|
{
|
|
for (var i = 0; i < size; i++)
|
|
u[i] = v[i] = d[i] = 0.0;
|
|
uiCallback(new Field(d, u, v));
|
|
}
|
|
|
|
this.update = function () {
|
|
queryUI(dens_prev, u_prev, v_prev);
|
|
vel_step(u, v, u_prev, v_prev, dt);
|
|
dens_step(dens, dens_prev, u, v, dt);
|
|
displayFunc(new Field(dens, u, v));
|
|
}
|
|
this.setDisplayFunction = function(func) {
|
|
displayFunc = func;
|
|
}
|
|
|
|
this.iterations = function() { return iterations; }
|
|
this.setIterations = function(iters) {
|
|
if (iters > 0 && iters <= 100)
|
|
iterations = iters;
|
|
}
|
|
this.setUICallback = function(callback) {
|
|
uiCallback = callback;
|
|
}
|
|
var iterations = 10;
|
|
var visc = 0.5;
|
|
var dt = 0.1;
|
|
var dens;
|
|
var dens_prev;
|
|
var u;
|
|
var u_prev;
|
|
var v;
|
|
var v_prev;
|
|
var width;
|
|
var height;
|
|
var rowSize;
|
|
var size;
|
|
var displayFunc;
|
|
function reset()
|
|
{
|
|
rowSize = width + 2;
|
|
size = (width+2)*(height+2);
|
|
dens = new Array(size);
|
|
dens_prev = new Array(size);
|
|
u = new Array(size);
|
|
u_prev = new Array(size);
|
|
v = new Array(size);
|
|
v_prev = new Array(size);
|
|
for (var i = 0; i < size; i++)
|
|
dens_prev[i] = u_prev[i] = v_prev[i] = dens[i] = u[i] = v[i] = 0;
|
|
}
|
|
this.reset = reset;
|
|
this.setResolution = function (hRes, wRes)
|
|
{
|
|
var res = wRes * hRes;
|
|
if (res > 0 && res < 1000000 && (wRes != width || hRes != height)) {
|
|
width = wRes;
|
|
height = hRes;
|
|
reset();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
this.setResolution(64, 64);
|
|
}
|
|
// Copyright 2008 the V8 project authors. All rights reserved.
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
var success = true;
|
|
|
|
function PrintResult(name, result) {
|
|
print(name + ': ' + result);
|
|
}
|
|
|
|
|
|
function PrintError(name, error) {
|
|
PrintResult(name, error);
|
|
success = false;
|
|
}
|
|
|
|
|
|
function PrintScore(score) {
|
|
if (success) {
|
|
print('----');
|
|
print('Score (version ' + BenchmarkSuite.version + '): ' + score);
|
|
}
|
|
}
|
|
|
|
|
|
BenchmarkSuite.RunSuites({ NotifyResult: PrintResult,
|
|
NotifyError: PrintError,
|
|
NotifyScore: PrintScore });
|