Website: http://localhost """ -#DSP/RX settings +# ==== sdr.hu listing ==== +# (This feature is only available to sdr.hu beta testers by now.) +# If you want your ham receiver to be listed publicly on sdr.hu, then take the following steps: +# 1. Register at: http://sdr.hu/register +# 2. You will get an unique key by email. Copy it and paste here: +sdrhu_key = "" +# 3. Set this setting to True to enable listing: +sdrhu_public_listing = False + +# ==== DSP/RX settings ==== dsp_plugin="csdr" fft_fps=9 fft_size=4096 samp_rate = 250000 + center_freq = 145525000 rf_gain = 5 +ppm = 0 -start_rtl_thread=True #rtl_sdr is more stable than rtl_tcp... -start_rtl_command="rtl_sdr -s {samp_rate} -f {center_freq} - | nc -vvl 127.0.0.1 -p 8888".format(rf_gain=rf_gain, center_freq=center_freq, samp_rate=samp_rate) -#start_rtl_tcp_command="rtl_tcp -s 250000 -f 145525000 -g 0 -p 8888" -#You can use other SDR hardware as well, but if the command above outputs samples in a format other than [unsigned char], then the dsp plugin has to be slightly modified (at the csdr convert_u8_f part). +audio_compression="adpcm" #valid values: "adpcm", "none" +fft_compression="adpcm" #valid values: "adpcm", "none" +start_rtl_thread=True + +# ==== I/Q sources (uncomment the appropriate) ==== + +# >> RTL-SDR via rtl_sdr + +start_rtl_command="rtl_sdr -s {samp_rate} -f {center_freq} -p {ppm} - | nc -vvl 127.0.0.1 8888".format(rf_gain=rf_gain, center_freq=center_freq, samp_rate=samp_rate, ppm=ppm) +format_conversion="csdr convert_u8_f" + +# >> Sound card SDR (needs ALSA) +#I did not have the chance to properly test it. +#samp_rate = 96000 +#start_rtl_command="arecord -f S16_LE -r {samp_rate} -c2 - | nc -vvl 127.0.0.1 8888".format(samp_rate=samp_rate) +#format_conversion="csdr convert_i16_f | csdr gain_ff 30" + +# >> RTL_SDR via rtl_tcp +#start_rtl_command="rtl_tcp -s {samp_rate} -f {center_freq} -g {rf_gain} -P {ppm} -p 8888".format(rf_gain=rf_gain, center_freq=center_freq, samp_rate=samp_rate, ppm=ppm) +#format_conversion="csdr convert_u8_f" + +# >> /dev/urandom test signal source +#samp_rate = 2400000 +#start_rtl_command="cat /dev/urandom | (pv -qL `python -c 'print int({samp_rate} * 2.2)'` 2>&1) | nc -vvl 127.0.0.1 8888".format(rf_gain=rf_gain, center_freq=center_freq, samp_rate=samp_rate) +#format_conversion="csdr convert_u8_f" + +#You can use other SDR hardware as well, by giving your own command that outputs the I/Q samples... + +shown_center_freq = center_freq #you can change this if you use an upconverter + +client_audio_buffer_size = 4 +#increasing client_audio_buffer_size will: +# - also increase the latency +# - decrease the chance of audio underruns diff --git a/htdocs/gfx/openwebrx-avatar-background.png b/htdocs/gfx/openwebrx-avatar-background.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-avatar.png b/htdocs/gfx/openwebrx-avatar.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-background-cool-blue.png b/htdocs/gfx/openwebrx-background-cool-blue.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-background-lingrad.png b/htdocs/gfx/openwebrx-background-lingrad.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-ha5kfu-top-logo.png b/htdocs/gfx/openwebrx-ha5kfu-top-logo.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-logo-big.png b/htdocs/gfx/openwebrx-logo-big.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-panel-log.png b/htdocs/gfx/openwebrx-panel-log.png new file mode 100644 index 0000000..58e6fd5 Binary files /dev/null and b/htdocs/gfx/openwebrx-panel-log.png differ diff --git a/htdocs/gfx/openwebrx-panel-receiver.png b/htdocs/gfx/openwebrx-panel-receiver.png new file mode 100644 index 0000000..5c80c3b Binary files /dev/null and b/htdocs/gfx/openwebrx-panel-receiver.png differ diff --git a/htdocs/gfx/openwebrx-panel-status.png b/htdocs/gfx/openwebrx-panel-status.png new file mode 100644 index 0000000..064b54f Binary files /dev/null and b/htdocs/gfx/openwebrx-panel-status.png differ diff --git a/htdocs/gfx/openwebrx-rx-details-arrow-up.png b/htdocs/gfx/openwebrx-rx-details-arrow-up.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-rx-details-arrow.png b/htdocs/gfx/openwebrx-rx-details-arrow.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-scale-background.png b/htdocs/gfx/openwebrx-scale-background.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-top-logo.png b/htdocs/gfx/openwebrx-top-logo.png old mode 100755 new mode 100644 diff --git a/htdocs/gfx/openwebrx-top-photo.jpg b/htdocs/gfx/openwebrx-top-photo.jpg old mode 100755 new mode 100644 diff --git a/htdocs/index.wrx b/htdocs/index.wrx old mode 100755 new mode 100644 index 7cf73ba..f9b85db --- a/htdocs/index.wrx +++ b/htdocs/index.wrx @@ -1,31 +1,35 @@ -
+ -
+
Status
+ 
Log
+ 
Receiver
+
@@ -61,7 +72,7 @@ This file is part of OpenWebRX.
-
+
-
---.--- MHz
---.--- MHz
@@ -71,17 +82,23 @@ This file is part of OpenWebRX.
-
-
openwebrx.js (beta) client log
+
+
+
+
- Client status: -
Your client ID is: %[CLIENT_ID]
OpenWebRX (beta) client log
Author: HA7ILM. Please send me bug reports and suggestions.- Client status: -
Your client ID is: %[CLIENT_ID]
+
+
+
+
+
+
+
Under construction
We're working on the code right now, so the application might fail. diff --git a/htdocs/openwebrx.css b/htdocs/openwebrx.css old mode 100755 new mode 100644 index 15993fc..b3dc9b4 --- a/htdocs/openwebrx.css +++ b/htdocs/openwebrx.css @@ -1,20 +1,22 @@ /* -OpenWebRX (c) Copyright 2013-2014 Andras Retzler
-This file is part of OpenWebRX.
+ This file is part of OpenWebRX,
+ an open-source SDR receiver software with a web UI.
+ Copyright (c) 2013-2015 by Andras Retzler
- OpenWebRX 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 3 of the License, or
- (at your option) any later version.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as
+ published by the Free Software Foundation, either version 3 of the
+ License, or (at your option) any later version.
- OpenWebRX is distributed in the hope that it will be useful,
+ 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.
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see
+ This file is part of OpenWebRX,
+ an open-source SDR receiver software with a web UI.
+ Copyright (c) 2013-2015 by Andras Retzler
-This file is part of OpenWebRX.
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as
+ published by the Free Software Foundation, either version 3 of the
+ License, or (at your option) any later version.
- OpenWebRX 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 3 of the License, or
- (at your option) any later version.
-
- OpenWebRX is distributed in the hope that it will be useful,
+ 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.
+ GNU Affero General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with OpenWebRX. If not, see =scale_min_space_bw_texts)
- { //and if we have enough space to draw it correctly without clipping
- scale_ctx.textAlign = "left";
- scale_ctx.fillText(text_to_draw, 0, text_h_pos);
- }
+ if( zoom_level==0 && (range.start+spacing.smallbw*spacing.ratio>marker_hz) && (x=scale_min_space_bw_texts)
+ { //and if we have enough space to draw it correctly without clipping
+ scale_ctx.textAlign = "left";
+ scale_ctx.fillText(text_to_draw, 0, text_h_pos);
}
}
- else if(zoom_level==0&&range.end-spacing.smallbw*spacing.ratiowindow.innerWidth-text_measured.width/2)
- { //and if it would be clipped off the screen
- if(window.innerWidth-text_measured.width-scale_px_from_freq(marker_hz-spacing.smallbw*spacing.ratio,range)>=scale_min_space_bw_texts)
- { //and if we have enough space to draw it correctly without clipping
- scale_ctx.textAlign = "right";
- scale_ctx.fillText(text_to_draw, window.innerWidth, text_h_pos);
- }
- }
+ else if( zoom_level==0 && (range.end-spacing.smallbw*spacing.ratiowindow.innerWidth-text_measured.width/2) )
+ { // if this is the last overall marker when zoomed out... and if it would be clipped off the screen...
+ if(window.innerWidth-text_measured.width-scale_px_from_freq(marker_hz-spacing.smallbw*spacing.ratio,range)>=scale_min_space_bw_texts)
+ { //and if we have enough space to draw it correctly without clipping
+ scale_ctx.textAlign = "right";
+ scale_ctx.fillText(text_to_draw, window.innerWidth, text_h_pos);
+ }
}
else scale_ctx.fillText(text_to_draw, x, text_h_pos); //draw text normally
}
@@ -960,11 +959,16 @@ function resize_waterfall_container(check_init)
canvas_container.style.height=(window.innerHeight-e("webrx-top-container").clientHeight-e("openwebrx-scale-container").clientHeight).toString()+"px";
}
+debug_ws_data_received=0;
+max_clients_num=0;
+
+var COMPRESS_FFT_PAD_N=10; //should be the same as in csdr.c
function on_ws_recv(evt)
{
if(!(evt.data instanceof ArrayBuffer)) { divlog("on_ws_recv(): Not ArrayBuffer received...",1); return; }
//
+ debug_ws_data_received+=evt.data.byteLength/1000;
firstChars=getFirstChars(evt.data,3);
if(firstChars=="CLI")
{
@@ -973,7 +977,9 @@ function on_ws_recv(evt)
}
if(firstChars=="AUD")
{
- var audio_data=new Int16Array(evt.data,4);
+ var audio_data;
+ if(audio_compression=="adpcm") audio_data=new Uint8Array(evt.data,4)
+ else audio_data=new Int16Array(evt.data,4);
audio_prepare(audio_data);
audio_buffer_current_size_debug+=audio_data.length;
audio_buffer_all_size_debug+=audio_data.length;
@@ -982,8 +988,15 @@ function on_ws_recv(evt)
else if(firstChars=="FFT")
{
//alert("Yupee! Doing FFT");
- var floatArray = new Float32Array(evt.data,4);
- waterfall_add_queue(floatArray);
+ if(fft_compression=="none") waterfall_add_queue(new Float32Array(evt.data,4));
+ else if(fft_compression="adpcm")
+ {
+ fft_codec.reset();
+ var waterfall_i16=fft_codec.decode(new Uint8Array(evt.data,4));
+ var waterfall_f32=new Float32Array(waterfall_i16.length-COMPRESS_FFT_PAD_N);
+ for(var i=0;i85);
+ break;
+ case "clients":
+ var clients_num=parseInt(param[1]);
+ progressbar_set(e("openwebrx-bar-clients"),clients_num/max_clients_num,"Clients ["+param[1]+"]",clients_num>max_clients_num*0.85);
+ break;
+ case "max_clients":
+ max_clients_num=parseInt(param[1]);
break;
-
}
}
/*}
@@ -1032,17 +1063,33 @@ function add_problem(what)
window.setTimeout(function(ps,ns) { ps.removeChild(ns); }, 1000,problems_span,new_span);
}
+waterfall_measure_minmax=false;
+waterfall_measure_minmax_min=1e100;
+waterfall_measure_minmax_max=-1e100;
+
+function waterfall_measure_minmax_do(what)
+{
+ waterfall_measure_minmax_min=Math.min(waterfall_measure_minmax_min,Math.min.apply(Math,what));
+ waterfall_measure_minmax_max=Math.max(waterfall_measure_minmax_max,Math.max.apply(Math,what));
+}
+
+function waterfall_measure_minmax_print()
+{
+ console.log("Waterfall | min = "+waterfall_measure_minmax_min.toString()+" dB | max = "+waterfall_measure_minmax_max.toString()+" dB");
+}
+
function waterfall_add_queue(what)
{
+ if(waterfall_measure_minmax) waterfall_measure_minmax_do(what);
waterfall_queue.push(what);
}
function waterfall_dequeue()
{
if(waterfall_queue.length) waterfall_add(waterfall_queue.shift());
- if(waterfall_queue.length>Math.max(fft_fps/2,8)) //in case of emergency
+ if(waterfall_queue.length>Math.max(fft_fps/2,20)) //in case of emergency
{
- console.log(waterfall_queue.length);
+ console.log("waterfall queue length:", waterfall_queue.length);
add_problem("fft overflow");
while(waterfall_queue.length) waterfall_add(waterfall_queue.shift());
}
@@ -1054,10 +1101,20 @@ function on_ws_opened()
divlog("WebSocket opened to "+ws_url);
}
+var was_error=0;
+
function divlog(what, is_error)
{
- if(typeof is_error !== undefined && is_error == 1) what=""+what+"";
+ is_error=!!is_error;
+ was_error |= is_error;
+ if(is_error)
+ {
+ what=""+what+"";
+ if(e("openwebrx-panel-log").openwebrxHidden) toggle_panel("openwebrx-panel-log"); //show panel if any error is present
+ }
e("openwebrx-debugdiv").innerHTML+=what+"
"; + var wls=e("openwebrx-log-scroll"); + wls.scrollTop=wls.scrollHeight; //scroll to bottom } var audio_context; @@ -1065,54 +1122,105 @@ var audio_initialized=0; var audio_received = Array(); var audio_buffer_index = 0; -var audio_resampler; +var audio_resampler=new sdrjs.RationalResamplerFF(4,1); +var audio_codec=new sdrjs.ImaAdpcm(); +var audio_compression="unknown"; var audio_node; //var audio_received_sample_rate = 48000; var audio_input_buffer_size; // Optimalise these if audio lags or is choppy: -var audio_buffer_size = 8192;//2048 was choppy -var audio_buffer_maximal_length_sec=1.7; //actual number of samples are calculated from sample rate -var audio_flush_interval_ms=250; //the interval in which audio_flush() is called +var audio_buffer_size = 4096;//2048 was choppy +var audio_buffer_maximal_length_sec=3; //actual number of samples are calculated from sample rate +var audio_buffer_decrease_to_on_overrun_sec=2.2; +var audio_flush_interval_ms=500; //the interval in which audio_flush() is called var audio_prepared_buffers = Array(); +var audio_rebuffer = new sdrjs.Rebuffer(audio_buffer_size,sdrjs.REBUFFER_FIXED); var audio_last_output_buffer = new Float32Array(audio_buffer_size); var audio_last_output_offset = 0; var audio_buffering = false; -var audio_buffering_fill_to=10; //on audio underrun we wait until this n*audio_buffer_size samples are present +//var audio_buffering_fill_to=4; //on audio underrun we wait until this n*audio_buffer_size samples are present + //tnx to the hint from HA3FLT, now we have about half the response time! (original value: 10) + +function gain_ff(gain_value,data) //great! solved clicking! will have to move to sdr.js +{ + for(var i=0;iaudio_buffering_fill_to) audio_buffering=false;
+}
+
+
+function audio_prepare_without_resampler(data)
+{
+ audio_rebuffer.push(sdrjs.ConvertI16_F(data));
+ console.log("prepare",data.length,audio_rebuffer.remaining());
+ while(audio_rebuffer.remaining())
+ {
+ audio_prepared_buffers.push(audio_rebuffer.take());
+ audio_buffer_current_count_debug++;
+ }
+ if(audio_buffering && audio_prepared_buffers.length>audio_buffering_fill_to) audio_buffering=false;
+}
+
+function audio_prepare_old(data)
{
//console.log("audio_prepare :: "+data.length.toString());
//console.log("data.len = "+data.length.toString());
var dopush=function()
{
+ console.log(audio_last_output_buffer);
audio_prepared_buffers.push(audio_last_output_buffer);
audio_last_output_offset=0;
audio_last_output_buffer=new Float32Array(audio_buffer_size);
audio_buffer_current_count_debug++;
};
+ var original_data_length=data.length;
+ var f32data=new Float32Array(data.length);
+ for(var i=0;iaudio_buffering_fill_to) audio_buffering=false;
}
@@ -1127,24 +1235,49 @@ if (!AudioBuffer.prototype.copyToChannel)
}
function audio_onprocess(e)
-{
+{
+ //console.log("audio onprocess");
if(audio_buffering) return;
- if(audio_prepared_buffers.length==0) { add_problem("audio underrun"); audio_buffering=true; }
- else e.outputBuffer.copyToChannel(audio_prepared_buffers.shift(),0);
+ if(audio_prepared_buffers.length==0) { audio_buffer_progressbar_update(); /*add_problem("audio underrun");*/ audio_buffering=true; }
+ else { e.outputBuffer.copyToChannel(audio_prepared_buffers.shift(),0); }
}
+var audio_buffer_progressbar_update_disabled=false;
+
+var audio_buffer_total_average_level=0;
+var audio_buffer_total_average_level_length=0;
+
+function audio_buffer_progressbar_update()
+{
+ if(audio_buffer_progressbar_update_disabled) return;
+ var audio_buffer_value=(audio_prepared_buffers.length*audio_buffer_size)/44100;
+ audio_buffer_total_average_level_length++; audio_buffer_total_average_level=(audio_buffer_total_average_level*((audio_buffer_total_average_level_length-1)/audio_buffer_total_average_level_length))+(audio_buffer_value/audio_buffer_total_average_level_length);
+ var overrun=audio_buffer_value>audio_buffer_maximal_length_sec;
+ var underrun=audio_prepared_buffers.length==0;
+ var text="buffer";
+ if(overrun) text="overrun";
+ if(underrun) text="underrun";
+ if(overrun||underrun)
+ {
+ audio_buffer_progressbar_update_disabled=true;
+ window.setTimeout(function(){audio_buffer_progressbar_update_disabled=false; audio_buffer_progressbar_update();},1000);
+ }
+ progressbar_set(e("openwebrx-bar-audio-buffer"),(underrun)?1:audio_buffer_value/1.5,"Audio "+text+" ["+(audio_buffer_value).toFixed(1)+" s]",overrun||underrun||audio_buffer_value<0.25);
+}
function audio_flush()
{
flushed=false;
- while(audio_buffer_maximal_length_sec*audio_context.sampleRateserver_hostname correctly, because it is left as \"localhost\". Now guessing hostname from page URL.",1);
- ws_url="ws://"+(window.location.origin.split("://")[1])+"/ws/"; //guess automatically
- }
+ //if(ws_url.startswith("ws://localhost:")&&window.location.hostname!="127.0.0.1"&&window.location.hostname!="localhost")
+ //{
+ //divlog("Server administrator should set server_hostname correctly, because it is left as \"localhost\". Now guessing hostname from page URL.",1);
+ ws_url="ws://"+(window.location.origin.split("://")[1])+"/ws/"; //guess automatically -> now default behaviour
+ //}
if (!("WebSocket" in window))
divlog("Your browser does not support WebSocket, which is required for WebRX to run. Please upgrade to a HTML5 compatible browser.");
ws = new WebSocket(ws_url+client_id);
@@ -1293,14 +1435,16 @@ function open_websocket()
//var color_scale=[ 0x000000FF, 0xff5656ff, 0xffffffff];
//2014-04-22
-var color_scale=[0x2e6893ff, 0x69a5d0ff, 0x214b69ff, 0x9dc4e0ff, 0xfff775ff, 0xff8a8aff, 0xb20000ff];
+var color_scale=[0x000000ff,0x2e6893ff, 0x69a5d0ff, 0x214b69ff, 0x9dc4e0ff, 0xfff775ff, 0xff8a8aff, 0xb20000ff]
+//2015-04-10
+//var color_scale=[0x112634ff,0x4991c6ff,0x18364cff,0x9dc4e0ff,0xfff775ff,0xff9f60,0xff4d4dff,0x8d0000ff];
function waterfall_mkcolor(db_value)
{
- min_value=-100; //in dB
- max_value=10
- if(db_valuemax_value) db_value=max_value
+ min_value=-115; //in dB
+ max_value=0;
+ if(db_valuemax_value) db_value=max_value;
full_scale=max_value-min_value;
relative_value=db_value-min_value;
value_percent=relative_value/full_scale;
@@ -1503,11 +1647,12 @@ function waterfall_add(data)
oneline_image.data[x*4+i] = ((color>>>0)>>((3-i)*8))&0xff;
}
-
+
//Draw image
canvas_context.putImageData(oneline_image, 0, canvas_actual_line--);
shift_canvases();
if(canvas_actual_line<0) add_canvas();
+
//divlog("Drawn FFT");
}
@@ -1525,10 +1670,17 @@ function waterfall_shift()
function check_top_bar_congestion()
{
- var wt=e("webrx-rx-title");
- var tl=e("webrx-ha5kfu-top-logo");
- if(wt.offsetLeft+wt.offsetWidth>tl.offsetLeft-20) tl.style.display="none";
- else tl.style.display="block";
+ var rmf=function(x){ return x.offsetLeft+x.offsetWidth; };
+ var wet=e("webrx-rx-title");
+ var wed=e("webrx-rx-desc");
+ var rightmost=Math.max(rmf(wet),rmf(wed));
+ var tl=e("openwebrx-main-buttons");
+
+ [wet, wed].map(function(what) {
+ if(rmf(what)>tl.offsetLeft-20) what.style.opacity=what.style.opacity="0";
+ else wet.style.opacity=wed.style.opacity="1";
+ });
+
}
function openwebrx_resize()
@@ -1546,6 +1698,7 @@ function openwebrx_init()
place_panels();
window.setTimeout(function(){window.setInterval(debug_audio,1000);},1000);
window.addEventListener("resize",openwebrx_resize);
+ check_top_bar_congestion();
}
/*
@@ -1577,18 +1730,33 @@ function debug_audio()
audio_debug_time_since_last_call=(time_now-audio_debug_time_last_start)/1000;
audio_debug_time_last_start=time_now; //now
audio_debug_time_taken=(time_now-audio_debug_time_start)/1000;
- e("openwebrx-audio-sps").innerHTML=
- "audio recv. at "+(audio_buffer_current_size_debug/audio_debug_time_since_last_call).toFixed(0)+" sps ("+
- (audio_buffer_all_size_debug/audio_debug_time_taken).toFixed(1)+" sps avg.), feed at "+
- ((audio_buffer_current_count_debug*audio_buffer_size)/audio_debug_time_taken).toFixed(1)+" sps output";
+ kbps_mult=(audio_compression=="adpcm")?8:16;
+ //e("openwebrx-audio-sps").innerHTML=
+ // ((audio_compression=="adpcm")?"ADPCM compressed":"uncompressed")+" audio downlink:
"+(audio_buffer_current_size_debug*kbps_mult/audio_debug_time_since_last_call).toFixed(0)+" kbps ("+ + // (audio_buffer_all_size_debug*kbps_mult/audio_debug_time_taken).toFixed(1)+" kbps avg.), feed at "+ + // ((audio_buffer_current_count_debug*audio_buffer_size)/audio_debug_time_taken).toFixed(1)+" sps output"; + + var audio_speed_value=audio_buffer_current_size_debug*kbps_mult/audio_debug_time_since_last_call; + progressbar_set(e("openwebrx-bar-audio-speed"),audio_speed_value/500000,"Audio stream ["+(audio_speed_value/1000).toFixed(0)+" kbps]",false); + + var audio_output_value=(audio_buffer_current_count_debug*audio_buffer_size)/audio_debug_time_taken; + progressbar_set(e("openwebrx-bar-audio-output"),audio_output_value/55000,"Audio output ["+(audio_output_value/1000).toFixed(1)+" ksps]",audio_output_value>55000||audio_output_value<10000); + + audio_buffer_progressbar_update(); + + var network_speed_value=debug_ws_data_received/audio_debug_time_taken; + progressbar_set(e("openwebrx-bar-network-speed"),network_speed_value*8/2000,"Network usage ["+(network_speed_value*8).toFixed(1)+" kbps]",false); + audio_buffer_current_size_debug=0; + + if(waterfall_measure_minmax) waterfall_measure_minmax_print(); } // ======================================================== // ======================= PANELS ======================= // ======================================================== -panel_margin=10; +panel_margin=5.9; function pop_bottommost_panel(from) { @@ -1608,8 +1776,19 @@ function pop_bottommost_panel(from) return to_return; } +function toggle_panel(what) +{ + var item=e(what); + if(item.openwebrxDisableClick) return; + item.openwebrxHidden=!item.openwebrxHidden; + place_panels(); + item.openwebrxDisableClick=true; + window.setTimeout(function(){item.openwebrxDisableClick=false;},100); +} + function place_panels() { + var hoffset=0; //added this because the first panel should not have such great gap below var left_col=[]; var right_col=[]; var plist=e("openwebrx-panels-container").children; @@ -1618,33 +1797,61 @@ function place_panels() c=plist[i]; if(c.className=="openwebrx-panel") { + if(c.openwebrxHidden) + { + c.style.display="none"; + continue; + } + c.style.display="block"; + c.openwebrxPanelTransparent=(!!c.dataset.panelTransparent); newSize=c.dataset.panelSize.split(","); if (c.dataset.panelPos=="left") { left_col.push(c); } else if(c.dataset.panelPos=="right") { right_col.push(c); } c.style.width=newSize[0]+"px"; c.style.height=newSize[1]+"px"; - c.style.margin=panel_margin.toString()+"px"; + if(!c.openwebrxPanelTransparent) c.style.margin=panel_margin.toString()+"px"; + else c.style.marginLeft=panel_margin.toString()+"px"; c.openwebrxPanelWidth=parseInt(newSize[0]); c.openwebrxPanelHeight=parseInt(newSize[1]); } } - y=0; + y=hoffset; //was y=0 before hoffset while(left_col.length>0) { p=pop_bottommost_panel(left_col); p.style.left="0px"; p.style.bottom=y.toString()+"px"; p.style.visibility="visible"; - y+=p.openwebrxPanelHeight+3*panel_margin; + y+=p.openwebrxPanelHeight+((p.openwebrxPanelTransparent)?0:3)*panel_margin; } - y=0; + y=hoffset; while(right_col.length>0) { p=pop_bottommost_panel(right_col); - p.style.right="10px"; + p.style.right=(e("webrx-canvas-container").offsetWidth-e("webrx-canvas-container").clientWidth).toString()+"px"; //get scrollbar width p.style.bottom=y.toString()+"px"; p.style.visibility="visible"; - y+=p.openwebrxPanelHeight+3*panel_margin; + y+=p.openwebrxPanelHeight+((p.openwebrxPanelTransparent)?0:3)*panel_margin; } } +function progressbar_set(obj,val,text,over) +{ + if (val<0.05) val=0; + if (val>1) val=1; + var innerBar=null; + var innerText=null; + for(var i=0;i
+
+OpenWebRX
+
+
+
+
+
+
+
+ Copyright (c) Warren Pratt, NR0V
+ Copyright 2006,2010,2012 Free Software Foundation, Inc.
+
+ libcsdr 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 3 of the License, or
+ (at your option) any later version.
+
+ libcsdr 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 libcsdr. If not, see ';
+ });
+ },
+ staticInit: function() {
+ FS.ensureErrnoError();
+
+ FS.nameTable = new Array(4096);
+
+ FS.root = FS.createNode(null, '/', 16384 | 0777, 0);
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ },
+ init: function(input, output, error) {
+ assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
+ FS.init.initialized = true;
+
+ FS.ensureErrnoError();
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },
+ quit: function() {
+ FS.init.initialized = false;
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },
+ getMode: function(canRead, canWrite) {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode;
+ },
+ joinPath: function(parts, forceRelative) {
+ var path = PATH.join.apply(null, parts);
+ if (forceRelative && path[0] == '/') path = path.substr(1);
+ return path;
+ },
+ absolutePath: function(relative, base) {
+ return PATH.resolve(base, relative);
+ },
+ standardizePath: function(path) {
+ return PATH.normalize(path);
+ },
+ findObject: function(path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (ret.exists) {
+ return ret.object;
+ } else {
+ ___setErrNo(ret.error);
+ return null;
+ }
+ },
+ analyzePath: function(path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !dontResolveLastLink
+ });
+ path = lookup.path;
+ } catch (e) {}
+ var ret = {
+ isRoot: false,
+ exists: false,
+ error: 0,
+ name: null,
+ path: null,
+ object: null,
+ parentExists: false,
+ parentPath: null,
+ parentObject: null
+ };
+ try {
+ var lookup = FS.lookupPath(path, {
+ parent: true
+ });
+ ret.parentExists = true;
+ ret.parentPath = lookup.path;
+ ret.parentObject = lookup.node;
+ ret.name = PATH.basename(path);
+ lookup = FS.lookupPath(path, {
+ follow: !dontResolveLastLink
+ });
+ ret.exists = true;
+ ret.path = lookup.path;
+ ret.object = lookup.node;
+ ret.name = lookup.node.name;
+ ret.isRoot = lookup.path === '/';
+ } catch (e) {
+ ret.error = e.errno;
+ };
+ return ret;
+ },
+ createFolder: function(parent, name, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.mkdir(path, mode);
+ },
+ createPath: function(parent, path, canRead, canWrite) {
+ parent = typeof parent === 'string' ? parent : FS.getPath(parent);
+ var parts = path.split('/').reverse();
+ while (parts.length) {
+ var part = parts.pop();
+ if (!part) continue;
+ var current = PATH.join2(parent, part);
+ try {
+ FS.mkdir(current);
+ } catch (e) {
+ // ignore EEXIST
+ }
+ parent = current;
+ }
+ return current;
+ },
+ createFile: function(parent, name, properties, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(canRead, canWrite);
+ return FS.create(path, mode);
+ },
+ createDataFile: function(parent, name, data, canRead, canWrite, canOwn) {
+ var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent;
+ var mode = FS.getMode(canRead, canWrite);
+ var node = FS.create(path, mode);
+ if (data) {
+ if (typeof data === 'string') {
+ var arr = new Array(data.length);
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+ data = arr;
+ }
+ // make sure we can write to the file
+ FS.chmod(node, mode | 146);
+ var stream = FS.open(node, 'w');
+ FS.write(stream, data, 0, data.length, 0, canOwn);
+ FS.close(stream);
+ FS.chmod(node, mode);
+ }
+ return node;
+ },
+ createDevice: function(parent, name, input, output) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ var mode = FS.getMode(!!input, !!output);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open: function(stream) {
+ stream.seekable = false;
+ },
+ close: function(stream) {
+ // flush any pending line data
+ if (output && output.buffer && output.buffer.length) {
+ output(10);
+ }
+ },
+ read: function(stream, buffer, offset, length, pos /* ignored */ ) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset + i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset + i]);
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },
+ createLink: function(parent, name, target, canRead, canWrite) {
+ var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name);
+ return FS.symlink(target, path);
+ },
+ forceLoadFile: function(obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ var success = true;
+ if (typeof XMLHttpRequest !== 'undefined') {
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+ } else if (Module['read']) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(Module['read'](obj.url), true);
+ } catch (e) {
+ success = false;
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ if (!success) ___setErrNo(ERRNO_CODES.EIO);
+ return success;
+ },
+ createLazyFile: function(parent, name, url, canRead, canWrite) {
+ if (typeof XMLHttpRequest !== 'undefined') {
+ if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
+ function LazyUint8Array() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+ if (idx > this.length - 1 || idx < 0) {
+ return undefined;
+ }
+ var chunkOffset = idx % this.chunkSize;
+ var chunkNum = Math.floor(idx / this.chunkSize);
+ return this.getter(chunkNum)[chunkOffset];
+ }
+ LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+ this.getter = getter;
+ }
+ LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+ // Find length
+ var xhr = new XMLHttpRequest();
+ xhr.open('HEAD', url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var chunkSize = 1024 * 1024; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ var doXHR = (function(from, to) {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+
+ // Some hints to the browser that we want binary data.
+ if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType('text/plain; charset=x-user-defined');
+ }
+
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || []);
+ } else {
+ return intArrayFromString(xhr.responseText || '', true);
+ }
+ });
+ var lazyArray = this;
+ lazyArray.setDataGetter(function(chunkNum) {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum + 1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength - 1); // if datalength-1 is selected, this is the last block
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end);
+ }
+ if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum];
+ });
+
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true;
+ }
+
+ var lazyArray = new LazyUint8Array();
+ Object.defineProperty(lazyArray, "length", {
+ get: function() {
+ if (!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._length;
+ }
+ });
+ Object.defineProperty(lazyArray, "chunkSize", {
+ get: function() {
+ if (!this.lengthKnown) {
+ this.cacheLength();
+ }
+ return this._chunkSize;
+ }
+ });
+
+ var properties = {
+ isDevice: false,
+ contents: lazyArray
+ };
+ } else {
+ var properties = {
+ isDevice: false,
+ url: url
+ };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // override each stream op with one that tries to force load the lazy file first
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(function(key) {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = function forceLoadLazyFile() {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ return fn.apply(null, arguments);
+ };
+ });
+ // use a custom read function
+ stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+ if (!FS.forceLoadFile(node)) {
+ throw new FS.ErrnoError(ERRNO_CODES.EIO);
+ }
+ var contents = stream.node.contents;
+ if (position >= contents.length)
+ return 0;
+ var size = Math.min(contents.length - position, length);
+ assert(size >= 0);
+ if (contents.slice) { // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ };
+ node.stream_ops = stream_ops;
+ return node;
+ },
+ createPreloadedFile: function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) {
+ Browser.init();
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent;
+
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if (!dontCreateFile) {
+ FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ if (onload) onload();
+ removeRunDependency('cp ' + fullname);
+ }
+ var handled = false;
+ Module['preloadPlugins'].forEach(function(plugin) {
+ if (handled) return;
+ if (plugin['canHandle'](fullname)) {
+ plugin['handle'](byteArray, fullname, finish, function() {
+ if (onerror) onerror();
+ removeRunDependency('cp ' + fullname);
+ });
+ handled = true;
+ }
+ });
+ if (!handled) finish(byteArray);
+ }
+ addRunDependency('cp ' + fullname);
+ if (typeof url == 'string') {
+ Browser.asyncLoad(url, function(byteArray) {
+ processData(byteArray);
+ }, onerror);
+ } else {
+ processData(url);
+ }
+ },
+ indexedDB: function() {
+ return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },
+ DB_NAME: function() {
+ return 'EM_FS_' + window.location.pathname;
+ },
+ DB_VERSION: 20,
+ DB_STORE_NAME: "FILE_DATA",
+ saveFilesToDB: function(paths, onload, onerror) {
+ onload = onload || function() {};
+ onerror = onerror || function() {};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+ console.log('creating db');
+ var db = openRequest.result;
+ db.createObjectStore(FS.DB_STORE_NAME);
+ };
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite');
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0,
+ fail = 0,
+ total = paths.length;
+
+ function finish() {
+ if (fail == 0) onload();
+ else onerror();
+ }
+ paths.forEach(function(path) {
+ var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+ putRequest.onsuccess = function putRequest_onsuccess() {
+ ok++;
+ if (ok + fail == total) finish()
+ };
+ putRequest.onerror = function putRequest_onerror() {
+ fail++;
+ if (ok + fail == total) finish()
+ };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ },
+ loadFilesFromDB: function(paths, onload, onerror) {
+ onload = onload || function() {};
+ onerror = onerror || function() {};
+ var indexedDB = FS.indexedDB();
+ try {
+ var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+ } catch (e) {
+ return onerror(e);
+ }
+ openRequest.onupgradeneeded = onerror; // no database to load from
+ openRequest.onsuccess = function openRequest_onsuccess() {
+ var db = openRequest.result;
+ try {
+ var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly');
+ } catch (e) {
+ onerror(e);
+ return;
+ }
+ var files = transaction.objectStore(FS.DB_STORE_NAME);
+ var ok = 0,
+ fail = 0,
+ total = paths.length;
+
+ function finish() {
+ if (fail == 0) onload();
+ else onerror();
+ }
+ paths.forEach(function(path) {
+ var getRequest = files.get(path);
+ getRequest.onsuccess = function getRequest_onsuccess() {
+ if (FS.analyzePath(path).exists) {
+ FS.unlink(path);
+ }
+ FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+ ok++;
+ if (ok + fail == total) finish();
+ };
+ getRequest.onerror = function getRequest_onerror() {
+ fail++;
+ if (ok + fail == total) finish()
+ };
+ });
+ transaction.onerror = onerror;
+ };
+ openRequest.onerror = onerror;
+ }
+};
+
+
+
+
+var _mkport = undefined;
+var SOCKFS = {
+ mount: function(mount) {
+ return FS.createNode(null, '/', 16384 | 0777, 0);
+ },
+ createSocket: function(family, type, protocol) {
+ var streaming = type == 1;
+ if (protocol) {
+ assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
+ }
+
+ // create our internal socket structure
+ var sock = {
+ family: family,
+ type: type,
+ protocol: protocol,
+ server: null,
+ peers: {},
+ pending: [],
+ recv_queue: [],
+ sock_ops: SOCKFS.websocket_sock_ops
+ };
+
+ // create the filesystem node to store the socket structure
+ var name = SOCKFS.nextname();
+ var node = FS.createNode(SOCKFS.root, name, 49152, 0);
+ node.sock = sock;
+
+ // and the wrapping stream that enables library functions such
+ // as read and write to indirectly interact with the socket
+ var stream = FS.createStream({
+ path: name,
+ node: node,
+ flags: FS.modeStringToFlags('r+'),
+ seekable: false,
+ stream_ops: SOCKFS.stream_ops
+ });
+
+ // map the new stream to the socket structure (sockets have a 1:1
+ // relationship with a stream)
+ sock.stream = stream;
+
+ return sock;
+ },
+ getSocket: function(fd) {
+ var stream = FS.getStream(fd);
+ if (!stream || !FS.isSocket(stream.node.mode)) {
+ return null;
+ }
+ return stream.node.sock;
+ },
+ stream_ops: {
+ poll: function(stream) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.poll(sock);
+ },
+ ioctl: function(stream, request, varargs) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.ioctl(sock, request, varargs);
+ },
+ read: function(stream, buffer, offset, length, position /* ignored */ ) {
+ var sock = stream.node.sock;
+ var msg = sock.sock_ops.recvmsg(sock, length);
+ if (!msg) {
+ // socket is closed
+ return 0;
+ }
+ buffer.set(msg.buffer, offset);
+ return msg.buffer.length;
+ },
+ write: function(stream, buffer, offset, length, position /* ignored */ ) {
+ var sock = stream.node.sock;
+ return sock.sock_ops.sendmsg(sock, buffer, offset, length);
+ },
+ close: function(stream) {
+ var sock = stream.node.sock;
+ sock.sock_ops.close(sock);
+ }
+ },
+ nextname: function() {
+ if (!SOCKFS.nextname.current) {
+ SOCKFS.nextname.current = 0;
+ }
+ return 'socket[' + (SOCKFS.nextname.current++) + ']';
+ },
+ websocket_sock_ops: {
+ createPeer: function(sock, addr, port) {
+ var ws;
+
+ if (typeof addr === 'object') {
+ ws = addr;
+ addr = null;
+ port = null;
+ }
+
+ if (ws) {
+ // for sockets that've already connected (e.g. we're the server)
+ // we can inspect the _socket property for the address
+ if (ws._socket) {
+ addr = ws._socket.remoteAddress;
+ port = ws._socket.remotePort;
+ }
+ // if we're just now initializing a connection to the remote,
+ // inspect the url property
+ else {
+ var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
+ if (!result) {
+ throw new Error('WebSocket URL must be in the format ws(s)://address:port');
+ }
+ addr = result[1];
+ port = parseInt(result[2], 10);
+ }
+ } else {
+ // create the actual websocket object and connect
+ try {
+ var url = 'ws://' + addr + ':' + port;
+ // the node ws library API is slightly different than the browser's
+ var opts = ENVIRONMENT_IS_NODE ? {
+ headers: {
+ 'websocket-protocol': ['binary']
+ }
+ } : ['binary'];
+ // If node we use the ws library.
+ var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
+ ws = new WebSocket(url, opts);
+ ws.binaryType = 'arraybuffer';
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
+ }
+ }
+
+
+ var peer = {
+ addr: addr,
+ port: port,
+ socket: ws,
+ dgram_send_queue: []
+ };
+
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
+
+ // if this is a bound dgram socket, send the port number first to allow
+ // us to override the ephemeral port reported to us by remotePort on the
+ // remote end.
+ if (sock.type === 2 && typeof sock.sport !== 'undefined') {
+ peer.dgram_send_queue.push(new Uint8Array([
+ 255, 255, 255, 255,
+ 'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0), ((sock.sport & 0xff00) >> 8), (sock.sport & 0xff)
+ ]));
+ }
+
+ return peer;
+ },
+ getPeer: function(sock, addr, port) {
+ return sock.peers[addr + ':' + port];
+ },
+ addPeer: function(sock, peer) {
+ sock.peers[peer.addr + ':' + peer.port] = peer;
+ },
+ removePeer: function(sock, peer) {
+ delete sock.peers[peer.addr + ':' + peer.port];
+ },
+ handlePeerEvents: function(sock, peer) {
+ var first = true;
+
+ var handleOpen = function() {
+ try {
+ var queued = peer.dgram_send_queue.shift();
+ while (queued) {
+ peer.socket.send(queued);
+ queued = peer.dgram_send_queue.shift();
+ }
+ } catch (e) {
+ // not much we can do here in the way of proper error handling as we've already
+ // lied and said this data was sent. shut it down.
+ peer.socket.close();
+ }
+ };
+
+ function handleMessage(data) {
+ assert(typeof data !== 'string' && data.byteLength !== undefined); // must receive an ArrayBuffer
+ data = new Uint8Array(data); // make a typed array view on the array buffer
+
+
+ // if this is the port message, override the peer's port with it
+ var wasfirst = first;
+ first = false;
+ if (wasfirst &&
+ data.length === 10 &&
+ data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
+ data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
+ // update the peer's port and it's key in the peer map
+ var newport = ((data[8] << 8) | data[9]);
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ peer.port = newport;
+ SOCKFS.websocket_sock_ops.addPeer(sock, peer);
+ return;
+ }
+
+ sock.recv_queue.push({
+ addr: peer.addr,
+ port: peer.port,
+ data: data
+ });
+ };
+
+ if (ENVIRONMENT_IS_NODE) {
+ peer.socket.on('open', handleOpen);
+ peer.socket.on('message', function(data, flags) {
+ if (!flags.binary) {
+ return;
+ }
+ handleMessage((new Uint8Array(data)).buffer); // copy from node Buffer -> ArrayBuffer
+ });
+ peer.socket.on('error', function() {
+ // don't throw
+ });
+ } else {
+ peer.socket.onopen = handleOpen;
+ peer.socket.onmessage = function peer_socket_onmessage(event) {
+ handleMessage(event.data);
+ };
+ }
+ },
+ poll: function(sock) {
+ if (sock.type === 1 && sock.server) {
+ // listen sockets should only say they're available for reading
+ // if there are pending clients.
+ return sock.pending.length ? (64 | 1) : 0;
+ }
+
+ var mask = 0;
+ var dest = sock.type === 1 ? // we only care about the socket state for connection-based sockets
+ SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
+ null;
+
+ if (sock.recv_queue.length ||
+ !dest || // connection-less sockets are always ready to read
+ (dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) { // let recv return 0 once closed
+ mask |= (64 | 1);
+ }
+
+ if (!dest || // connection-less sockets are always ready to write
+ (dest && dest.socket.readyState === dest.socket.OPEN)) {
+ mask |= 4;
+ }
+
+ if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
+ (dest && dest.socket.readyState === dest.socket.CLOSED)) {
+ mask |= 16;
+ }
+
+ return mask;
+ },
+ ioctl: function(sock, request, arg) {
+ switch (request) {
+ case 21531:
+ var bytes = 0;
+ if (sock.recv_queue.length) {
+ bytes = sock.recv_queue[0].data.length;
+ }
+ HEAP32[((arg) >> 2)] = bytes;
+ return 0;
+ default:
+ return ERRNO_CODES.EINVAL;
+ }
+ },
+ close: function(sock) {
+ // if we've spawned a listen server, close it
+ if (sock.server) {
+ try {
+ sock.server.close();
+ } catch (e) {}
+ sock.server = null;
+ }
+ // close any peer connections
+ var peers = Object.keys(sock.peers);
+ for (var i = 0; i < peers.length; i++) {
+ var peer = sock.peers[peers[i]];
+ try {
+ peer.socket.close();
+ } catch (e) {}
+ SOCKFS.websocket_sock_ops.removePeer(sock, peer);
+ }
+ return 0;
+ },
+ bind: function(sock, addr, port) {
+ if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already bound
+ }
+ sock.saddr = addr;
+ sock.sport = port || _mkport();
+ // in order to emulate dgram sockets, we need to launch a listen server when
+ // binding on a connection-less socket
+ // note: this is only required on the server side
+ if (sock.type === 2) {
+ // close the existing server if it exists
+ if (sock.server) {
+ sock.server.close();
+ sock.server = null;
+ }
+ // swallow error operation not supported error that occurs when binding in the
+ // browser where this isn't supported
+ try {
+ sock.sock_ops.listen(sock, 0);
+ } catch (e) {
+ if (!(e instanceof FS.ErrnoError)) throw e;
+ if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
+ }
+ }
+ },
+ connect: function(sock, addr, port) {
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODS.EOPNOTSUPP);
+ }
+
+ // TODO autobind
+ // if (!sock.addr && sock.type == 2) {
+ // }
+
+ // early out if we're already connected / in the middle of connecting
+ if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+ if (dest) {
+ if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
+ }
+ }
+ }
+
+ // add the socket to our peer list and set our
+ // destination address / port to match
+ var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ sock.daddr = peer.addr;
+ sock.dport = peer.port;
+
+ // always "fail" in non-blocking mode
+ throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
+ },
+ listen: function(sock, backlog) {
+ if (!ENVIRONMENT_IS_NODE) {
+ throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
+ }
+ if (sock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL); // already listening
+ }
+ var WebSocketServer = require('ws').Server;
+ var host = sock.saddr;
+ sock.server = new WebSocketServer({
+ host: host,
+ port: sock.sport
+ // TODO support backlog
+ });
+
+ sock.server.on('connection', function(ws) {
+ if (sock.type === 1) {
+ var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
+
+ // create a peer on the new socket
+ var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
+ newsock.daddr = peer.addr;
+ newsock.dport = peer.port;
+
+ // push to queue for accept to pick up
+ sock.pending.push(newsock);
+ } else {
+ // create a peer on the listen socket so calling sendto
+ // with the listen socket and an address will resolve
+ // to the correct client
+ SOCKFS.websocket_sock_ops.createPeer(sock, ws);
+ }
+ });
+ sock.server.on('closed', function() {
+ sock.server = null;
+ });
+ sock.server.on('error', function() {
+ // don't throw
+ });
+ },
+ accept: function(listensock) {
+ if (!listensock.server) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ var newsock = listensock.pending.shift();
+ newsock.stream.flags = listensock.stream.flags;
+ return newsock;
+ },
+ getname: function(sock, peer) {
+ var addr, port;
+ if (peer) {
+ if (sock.daddr === undefined || sock.dport === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+ addr = sock.daddr;
+ port = sock.dport;
+ } else {
+ // TODO saddr and sport will be set for bind()'d UDP sockets, but what
+ // should we be returning for TCP sockets that've been connect()'d?
+ addr = sock.saddr || 0;
+ port = sock.sport || 0;
+ }
+ return {
+ addr: addr,
+ port: port
+ };
+ },
+ sendmsg: function(sock, buffer, offset, length, addr, port) {
+ if (sock.type === 2) {
+ // connection-less sockets will honor the message address,
+ // and otherwise fall back to the bound destination address
+ if (addr === undefined || port === undefined) {
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+ // if there was no address to fall back to, error out
+ if (addr === undefined || port === undefined) {
+ throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
+ }
+ } else {
+ // connection-based sockets will only use the bound
+ addr = sock.daddr;
+ port = sock.dport;
+ }
+
+ // find the peer for the destination address
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
+
+ // early out if not connected with a connection-based socket
+ if (sock.type === 1) {
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CONNECTING) {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // create a copy of the incoming data to send, as the WebSocket API
+ // doesn't work entirely with an ArrayBufferView, it'll just send
+ // the entire underlying buffer
+ var data;
+ if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
+ data = buffer.slice(offset, offset + length);
+ } else { // ArrayBufferView
+ data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
+ }
+
+ // if we're emulating a connection-less dgram socket and don't have
+ // a cached connection, queue the buffer to send upon connect and
+ // lie, saying the data was sent now.
+ if (sock.type === 2) {
+ if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
+ // if we're not connected, open a new connection
+ if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
+ }
+ dest.dgram_send_queue.push(data);
+ return length;
+ }
+ }
+
+ try {
+ // send the actual data
+ dest.socket.send(data);
+ return length;
+ } catch (e) {
+ throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+ }
+ },
+ recvmsg: function(sock, length) {
+ // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
+ if (sock.type === 1 && sock.server) {
+ // tcp servers should not be recv()'ing on the listen socket
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ }
+
+ var queued = sock.recv_queue.shift();
+ if (!queued) {
+ if (sock.type === 1) {
+ var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
+
+ if (!dest) {
+ // if we have a destination address but are not connected, error out
+ throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
+ } else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
+ // return null if the socket has closed
+ return null;
+ } else {
+ // else, our socket is in a valid state but truly has nothing available
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ } else {
+ throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
+ }
+ }
+
+ // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
+ // requeued TCP data it'll be an ArrayBufferView
+ var queuedLength = queued.data.byteLength || queued.data.length;
+ var queuedOffset = queued.data.byteOffset || 0;
+ var queuedBuffer = queued.data.buffer || queued.data;
+ var bytesRead = Math.min(length, queuedLength);
+ var res = {
+ buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
+ addr: queued.addr,
+ port: queued.port
+ };
+
+
+ // push back any unread data for TCP connections
+ if (sock.type === 1 && bytesRead < queuedLength) {
+ var bytesRemaining = queuedLength - bytesRead;
+ queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
+ sock.recv_queue.unshift(queued);
+ }
+
+ return res;
+ }
+ }
+};
+
+function _send(fd, buf, len, flags) {
+ var sock = SOCKFS.getSocket(fd);
+ if (!sock) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ // TODO honor flags
+ return _write(fd, buf, len);
+}
+
+function _pwrite(fildes, buf, nbyte, offset) {
+ // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte, offset);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+}
+
+function _write(fildes, buf, nbyte) {
+ // ssize_t write(int fildes, const void *buf, size_t nbyte);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
+ var stream = FS.getStream(fildes);
+ if (!stream) {
+ ___setErrNo(ERRNO_CODES.EBADF);
+ return -1;
+ }
+
+
+ try {
+ var slab = HEAP8;
+ return FS.write(stream, slab, buf, nbyte);
+ } catch (e) {
+ FS.handleFSError(e);
+ return -1;
+ }
+}
+
+function _fwrite(ptr, size, nitems, stream) {
+ // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
+ var bytesToWrite = nitems * size;
+ if (bytesToWrite == 0) return 0;
+ var bytesWritten = _write(stream, ptr, bytesToWrite);
+ if (bytesWritten == -1) {
+ var streamObj = FS.getStream(stream);
+ if (streamObj) streamObj.error = true;
+ return 0;
+ } else {
+ return Math.floor(bytesWritten / size);
+ }
+}
+
+
+
+Module["_strlen"] = _strlen;
+
+function __reallyNegative(x) {
+ return x < 0 || (x === 0 && (1 / x) === -Infinity);
+}
+
+function __formatString(format, varargs) {
+ var textIndex = format;
+ var argIndex = 0;
+
+ function getNextArg(type) {
+ // NOTE: Explicitly ignoring type safety. Otherwise this fails:
+ // int x = 4; printf("%c\n", (char)x);
+ var ret;
+ if (type === 'double') {
+ ret = HEAPF64[(((varargs) + (argIndex)) >> 3)];
+ } else if (type == 'i64') {
+ ret = [HEAP32[(((varargs) + (argIndex)) >> 2)],
+ HEAP32[(((varargs) + (argIndex + 8)) >> 2)]
+ ];
+ argIndex += 8; // each 32-bit chunk is in a 64-bit block
+
+ } else {
+ type = 'i32'; // varargs are always i32, i64, or double
+ ret = HEAP32[(((varargs) + (argIndex)) >> 2)];
+ }
+ argIndex += Math.max(Runtime.getNativeFieldSize(type), Runtime.getAlignSize(type, null, true));
+ return ret;
+ }
+
+ var ret = [];
+ var curr, next, currArg;
+ while (1) {
+ var startTextIndex = textIndex;
+ curr = HEAP8[(textIndex)];
+ if (curr === 0) break;
+ next = HEAP8[((textIndex + 1) | 0)];
+ if (curr == 37) {
+ // Handle flags.
+ var flagAlwaysSigned = false;
+ var flagLeftAlign = false;
+ var flagAlternative = false;
+ var flagZeroPad = false;
+ var flagPadSign = false;
+ flagsLoop: while (1) {
+ switch (next) {
+ case 43:
+ flagAlwaysSigned = true;
+ break;
+ case 45:
+ flagLeftAlign = true;
+ break;
+ case 35:
+ flagAlternative = true;
+ break;
+ case 48:
+ if (flagZeroPad) {
+ break flagsLoop;
+ } else {
+ flagZeroPad = true;
+ break;
+ }
+ case 32:
+ flagPadSign = true;
+ break;
+ default:
+ break flagsLoop;
+ }
+ textIndex++;
+ next = HEAP8[((textIndex + 1) | 0)];
+ }
+
+ // Handle width.
+ var width = 0;
+ if (next == 42) {
+ width = getNextArg('i32');
+ textIndex++;
+ next = HEAP8[((textIndex + 1) | 0)];
+ } else {
+ while (next >= 48 && next <= 57) {
+ width = width * 10 + (next - 48);
+ textIndex++;
+ next = HEAP8[((textIndex + 1) | 0)];
+ }
+ }
+
+ // Handle precision.
+ var precisionSet = false,
+ precision = -1;
+ if (next == 46) {
+ precision = 0;
+ precisionSet = true;
+ textIndex++;
+ next = HEAP8[((textIndex + 1) | 0)];
+ if (next == 42) {
+ precision = getNextArg('i32');
+ textIndex++;
+ } else {
+ while (1) {
+ var precisionChr = HEAP8[((textIndex + 1) | 0)];
+ if (precisionChr < 48 ||
+ precisionChr > 57) break;
+ precision = precision * 10 + (precisionChr - 48);
+ textIndex++;
+ }
+ }
+ next = HEAP8[((textIndex + 1) | 0)];
+ }
+ if (precision === -1) {
+ precision = 6; // Standard default.
+ precisionSet = false;
+ }
+
+ // Handle integer sizes. WARNING: These assume a 32-bit architecture!
+ var argSize;
+ switch (String.fromCharCode(next)) {
+ case 'h':
+ var nextNext = HEAP8[((textIndex + 2) | 0)];
+ if (nextNext == 104) {
+ textIndex++;
+ argSize = 1; // char (actually i32 in varargs)
+ } else {
+ argSize = 2; // short (actually i32 in varargs)
+ }
+ break;
+ case 'l':
+ var nextNext = HEAP8[((textIndex + 2) | 0)];
+ if (nextNext == 108) {
+ textIndex++;
+ argSize = 8; // long long
+ } else {
+ argSize = 4; // long
+ }
+ break;
+ case 'L': // long long
+ case 'q': // int64_t
+ case 'j': // intmax_t
+ argSize = 8;
+ break;
+ case 'z': // size_t
+ case 't': // ptrdiff_t
+ case 'I': // signed ptrdiff_t or unsigned size_t
+ argSize = 4;
+ break;
+ default:
+ argSize = null;
+ }
+ if (argSize) textIndex++;
+ next = HEAP8[((textIndex + 1) | 0)];
+
+ // Handle type specifier.
+ switch (String.fromCharCode(next)) {
+ case 'd':
+ case 'i':
+ case 'u':
+ case 'o':
+ case 'x':
+ case 'X':
+ case 'p':
+ {
+ // Integer.
+ var signed = next == 100 || next == 105;
+ argSize = argSize || 4;
+ var currArg = getNextArg('i' + (argSize * 8));
+ var origArg = currArg;
+ var argText;
+ // Flatten i64-1 [low, high] into a (slightly rounded) double
+ if (argSize == 8) {
+ currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
+ }
+ // Truncate to requested size.
+ if (argSize <= 4) {
+ var limit = Math.pow(256, argSize) - 1;
+ currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
+ }
+ // Format the number.
+ var currAbsArg = Math.abs(currArg);
+ var prefix = '';
+ if (next == 100 || next == 105) {
+ if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], null);
+ else
+ argText = reSign(currArg, 8 * argSize, 1).toString(10);
+ } else if (next == 117) {
+ if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true);
+ else
+ argText = unSign(currArg, 8 * argSize, 1).toString(10);
+ currArg = Math.abs(currArg);
+ } else if (next == 111) {
+ argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
+ } else if (next == 120 || next == 88) {
+ prefix = (flagAlternative && currArg != 0) ? '0x' : '';
+ if (argSize == 8 && i64Math) {
+ if (origArg[1]) {
+ argText = (origArg[1] >>> 0).toString(16);
+ var lower = (origArg[0] >>> 0).toString(16);
+ while (lower.length < 8) lower = '0' + lower;
+ argText += lower;
+ } else {
+ argText = (origArg[0] >>> 0).toString(16);
+ }
+ } else
+ if (currArg < 0) {
+ // Represent negative numbers in hex as 2's complement.
+ currArg = -currArg;
+ argText = (currAbsArg - 1).toString(16);
+ var buffer = [];
+ for (var i = 0; i < argText.length; i++) {
+ buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
+ }
+ argText = buffer.join('');
+ while (argText.length < argSize * 2) argText = 'f' + argText;
+ } else {
+ argText = currAbsArg.toString(16);
+ }
+ if (next == 88) {
+ prefix = prefix.toUpperCase();
+ argText = argText.toUpperCase();
+ }
+ } else if (next == 112) {
+ if (currAbsArg === 0) {
+ argText = '(nil)';
+ } else {
+ prefix = '0x';
+ argText = currAbsArg.toString(16);
+ }
+ }
+ if (precisionSet) {
+ while (argText.length < precision) {
+ argText = '0' + argText;
+ }
+ }
+
+ // Add sign if needed
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ prefix = '+' + prefix;
+ } else if (flagPadSign) {
+ prefix = ' ' + prefix;
+ }
+ }
+
+ // Move sign to prefix so we zero-pad after the sign
+ if (argText.charAt(0) == '-') {
+ prefix = '-' + prefix;
+ argText = argText.substr(1);
+ }
+
+ // Add padding.
+ while (prefix.length + argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad) {
+ argText = '0' + argText;
+ } else {
+ prefix = ' ' + prefix;
+ }
+ }
+ }
+
+ // Insert the result into the buffer.
+ argText = prefix + argText;
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 'f':
+ case 'F':
+ case 'e':
+ case 'E':
+ case 'g':
+ case 'G':
+ {
+ // Float.
+ var currArg = getNextArg('double');
+ var argText;
+ if (isNaN(currArg)) {
+ argText = 'nan';
+ flagZeroPad = false;
+ } else if (!isFinite(currArg)) {
+ argText = (currArg < 0 ? '-' : '') + 'inf';
+ flagZeroPad = false;
+ } else {
+ var isGeneral = false;
+ var effectivePrecision = Math.min(precision, 20);
+
+ // Convert g/G to f/F or e/E, as per:
+ // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
+ if (next == 103 || next == 71) {
+ isGeneral = true;
+ precision = precision || 1;
+ var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
+ if (precision > exponent && exponent >= -4) {
+ next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
+ precision -= exponent + 1;
+ } else {
+ next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
+ precision--;
+ }
+ effectivePrecision = Math.min(precision, 20);
+ }
+
+ if (next == 101 || next == 69) {
+ argText = currArg.toExponential(effectivePrecision);
+ // Make sure the exponent has at least 2 digits.
+ if (/[eE][-+]\d$/.test(argText)) {
+ argText = argText.slice(0, -1) + '0' + argText.slice(-1);
+ }
+ } else if (next == 102 || next == 70) {
+ argText = currArg.toFixed(effectivePrecision);
+ if (currArg === 0 && __reallyNegative(currArg)) {
+ argText = '-' + argText;
+ }
+ }
+
+ var parts = argText.split('e');
+ if (isGeneral && !flagAlternative) {
+ // Discard trailing zeros and periods.
+ while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
+ (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
+ parts[0] = parts[0].slice(0, -1);
+ }
+ } else {
+ // Make sure we have a period in alternative mode.
+ if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
+ // Zero pad until required precision.
+ while (precision > effectivePrecision++) parts[0] += '0';
+ }
+ argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
+
+ // Capitalize 'E' if needed.
+ if (next == 69) argText = argText.toUpperCase();
+
+ // Add sign.
+ if (currArg >= 0) {
+ if (flagAlwaysSigned) {
+ argText = '+' + argText;
+ } else if (flagPadSign) {
+ argText = ' ' + argText;
+ }
+ }
+ }
+
+ // Add padding.
+ while (argText.length < width) {
+ if (flagLeftAlign) {
+ argText += ' ';
+ } else {
+ if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
+ argText = argText[0] + '0' + argText.slice(1);
+ } else {
+ argText = (flagZeroPad ? '0' : ' ') + argText;
+ }
+ }
+ }
+
+ // Adjust case.
+ if (next < 97) argText = argText.toUpperCase();
+
+ // Insert the result into the buffer.
+ argText.split('').forEach(function(chr) {
+ ret.push(chr.charCodeAt(0));
+ });
+ break;
+ }
+ case 's':
+ {
+ // String.
+ var arg = getNextArg('i8*');
+ var argLength = arg ? _strlen(arg) : '(null)'.length;
+ if (precisionSet) argLength = Math.min(argLength, precision);
+ if (!flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ if (arg) {
+ for (var i = 0; i < argLength; i++) {
+ ret.push(HEAPU8[((arg++) | 0)]);
+ }
+ } else {
+ ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
+ }
+ if (flagLeftAlign) {
+ while (argLength < width--) {
+ ret.push(32);
+ }
+ }
+ break;
+ }
+ case 'c':
+ {
+ // Character.
+ if (flagLeftAlign) ret.push(getNextArg('i8'));
+ while (--width > 0) {
+ ret.push(32);
+ }
+ if (!flagLeftAlign) ret.push(getNextArg('i8'));
+ break;
+ }
+ case 'n':
+ {
+ // Write the length written so far to the next parameter.
+ var ptr = getNextArg('i32*');
+ HEAP32[((ptr) >> 2)] = ret.length;
+ break;
+ }
+ case '%':
+ {
+ // Literal percent sign.
+ ret.push(curr);
+ break;
+ }
+ default:
+ {
+ // Unknown specifiers remain untouched.
+ for (var i = startTextIndex; i < textIndex + 2; i++) {
+ ret.push(HEAP8[(i)]);
+ }
+ }
+ }
+ textIndex += 2;
+ // TODO: Support a/A (hex float) and m (last error) specifiers.
+ // TODO: Support %1${specifier} for arg selection.
+ } else {
+ ret.push(curr);
+ textIndex += 1;
+ }
+ }
+ return ret;
+}
+
+function _fprintf(stream, format, varargs) {
+ // int fprintf(FILE *restrict stream, const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var result = __formatString(format, varargs);
+ var stack = Runtime.stackSave();
+ var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
+ Runtime.stackRestore(stack);
+ return ret;
+}
+
+function _printf(format, varargs) {
+ // int printf(const char *restrict format, ...);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
+ var stdout = HEAP32[((_stdout) >> 2)];
+ return _fprintf(stdout, format, varargs);
+}
+
+var _sqrtf = Math_sqrt;
+
+var _fabsf = Math_abs;
+
+
+function _fputs(s, stream) {
+ // int fputs(const char *restrict s, FILE *restrict stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
+ return _write(stream, s, _strlen(s));
+}
+
+function _fputc(c, stream) {
+ // int fputc(int c, FILE *stream);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
+ var chr = unSign(c & 0xFF);
+ HEAP8[((_fputc.ret) | 0)] = chr;
+ var ret = _write(stream, _fputc.ret, 1);
+ if (ret == -1) {
+ var streamObj = FS.getStream(stream);
+ if (streamObj) streamObj.error = true;
+ return -1;
+ } else {
+ return chr;
+ }
+}
+
+function _puts(s) {
+ // int puts(const char *s);
+ // http://pubs.opengroup.org/onlinepubs/000095399/functions/puts.html
+ // NOTE: puts() always writes an extra newline.
+ var stdout = HEAP32[((_stdout) >> 2)];
+ var ret = _fputs(s, stdout);
+ if (ret < 0) {
+ return ret;
+ } else {
+ var newlineRet = _fputc(10, stdout);
+ return (newlineRet < 0) ? -1 : ret + 1;
+ }
+}
+
+function _abort() {
+ Module['abort']();
+}
+
+function ___errno_location() {
+ return ___errno_state;
+}
+
+function _sbrk(bytes) {
+ // Implement a Linux-like 'memory area' for our 'process'.
+ // Changes the size of the memory area by |bytes|; returns the
+ // address of the previous top ('break') of the memory area
+ // We control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP
+ var self = _sbrk;
+ if (!self.called) {
+ DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned
+ self.called = true;
+ assert(Runtime.dynamicAlloc);
+ self.alloc = Runtime.dynamicAlloc;
+ Runtime.dynamicAlloc = function() {
+ abort('cannot dynamically allocate, sbrk now has control')
+ };
+ }
+ var ret = DYNAMICTOP;
+ if (bytes != 0) self.alloc(bytes);
+ return ret; // Previous break location.
+}
+
+function _sysconf(name) {
+ // long sysconf(int name);
+ // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
+ switch (name) {
+ case 30:
+ return PAGE_SIZE;
+ case 132:
+ case 133:
+ case 12:
+ case 137:
+ case 138:
+ case 15:
+ case 235:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 149:
+ case 13:
+ case 10:
+ case 236:
+ case 153:
+ case 9:
+ case 21:
+ case 22:
+ case 159:
+ case 154:
+ case 14:
+ case 77:
+ case 78:
+ case 139:
+ case 80:
+ case 81:
+ case 79:
+ case 82:
+ case 68:
+ case 67:
+ case 164:
+ case 11:
+ case 29:
+ case 47:
+ case 48:
+ case 95:
+ case 52:
+ case 51:
+ case 46:
+ return 200809;
+ case 27:
+ case 246:
+ case 127:
+ case 128:
+ case 23:
+ case 24:
+ case 160:
+ case 161:
+ case 181:
+ case 182:
+ case 242:
+ case 183:
+ case 184:
+ case 243:
+ case 244:
+ case 245:
+ case 165:
+ case 178:
+ case 179:
+ case 49:
+ case 50:
+ case 168:
+ case 169:
+ case 175:
+ case 170:
+ case 171:
+ case 172:
+ case 97:
+ case 76:
+ case 32:
+ case 173:
+ case 35:
+ return -1;
+ case 176:
+ case 177:
+ case 7:
+ case 155:
+ case 8:
+ case 157:
+ case 125:
+ case 126:
+ case 92:
+ case 93:
+ case 129:
+ case 130:
+ case 131:
+ case 94:
+ case 91:
+ return 1;
+ case 74:
+ case 60:
+ case 69:
+ case 70:
+ case 4:
+ return 1024;
+ case 31:
+ case 42:
+ case 72:
+ return 32;
+ case 87:
+ case 26:
+ case 33:
+ return 2147483647;
+ case 34:
+ case 1:
+ return 47839;
+ case 38:
+ case 36:
+ return 99;
+ case 43:
+ case 37:
+ return 2048;
+ case 0:
+ return 2097152;
+ case 3:
+ return 65536;
+ case 28:
+ return 32768;
+ case 44:
+ return 32767;
+ case 75:
+ return 16384;
+ case 39:
+ return 1000;
+ case 89:
+ return 700;
+ case 71:
+ return 256;
+ case 40:
+ return 255;
+ case 2:
+ return 100;
+ case 180:
+ return 64;
+ case 25:
+ return 20;
+ case 5:
+ return 16;
+ case 6:
+ return 6;
+ case 73:
+ return 4;
+ case 84:
+ return 1;
+ }
+ ___setErrNo(ERRNO_CODES.EINVAL);
+ return -1;
+}
+
+function _time(ptr) {
+ var ret = Math.floor(Date.now() / 1000);
+ if (ptr) {
+ HEAP32[((ptr) >> 2)] = ret;
+ }
+ return ret;
+}
+
+
+
+Module["_memset"] = _memset;
+
+
+
+
+var Browser = {
+ mainLoop: {
+ scheduler: null,
+ shouldPause: false,
+ paused: false,
+ queue: [],
+ pause: function() {
+ Browser.mainLoop.shouldPause = true;
+ },
+ resume: function() {
+ if (Browser.mainLoop.paused) {
+ Browser.mainLoop.paused = false;
+ Browser.mainLoop.scheduler();
+ }
+ Browser.mainLoop.shouldPause = false;
+ },
+ updateStatus: function() {
+ if (Module['setStatus']) {
+ var message = Module['statusMessage'] || 'Please wait...';
+ var remaining = Browser.mainLoop.remainingBlockers;
+ var expected = Browser.mainLoop.expectedBlockers;
+ if (remaining) {
+ if (remaining < expected) {
+ Module['setStatus'](message + ' (' + (expected - remaining) + '/' + expected + ')');
+ } else {
+ Module['setStatus'](message);
+ }
+ } else {
+ Module['setStatus']('');
+ }
+ }
+ }
+ },
+ isFullScreen: false,
+ pointerLock: false,
+ moduleContextCreatedCallbacks: [],
+ workers: [],
+ init: function() {
+ if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers
+
+ if (Browser.initted || ENVIRONMENT_IS_WORKER) return;
+ Browser.initted = true;
+
+ try {
+ new Blob();
+ Browser.hasBlobConstructor = true;
+ } catch (e) {
+ Browser.hasBlobConstructor = false;
+ console.log("warning: no blob constructor, cannot create blobs with mimetypes");
+ }
+ Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : (typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : (!Browser.hasBlobConstructor ? console.log("warning: no BlobBuilder") : null));
+ Browser.URLObject = typeof window != "undefined" ? (window.URL ? window.URL : window.webkitURL) : undefined;
+ if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') {
+ console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
+ Module.noImageDecoding = true;
+ }
+
+ // Support for plugins that can process preloaded files. You can add more of these to
+ // your app by creating and appending to Module.preloadPlugins.
+ //
+ // Each plugin is asked if it can handle a file based on the file's name. If it can,
+ // it is given the file's raw data. When it is done, it calls a callback with the file's
+ // (possibly modified) data. For example, a plugin might decompress a file, or it
+ // might create some side data structure for use later (like an Image element, etc.).
+
+ var imagePlugin = {};
+ imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
+ return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
+ };
+ imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) {
+ var b = null;
+ if (Browser.hasBlobConstructor) {
+ try {
+ b = new Blob([byteArray], {
+ type: Browser.getMimetype(name)
+ });
+ if (b.size !== byteArray.length) { // Safari bug #118630
+ // Safari's Blob can only take an ArrayBuffer
+ b = new Blob([(new Uint8Array(byteArray)).buffer], {
+ type: Browser.getMimetype(name)
+ });
+ }
+ } catch (e) {
+ Runtime.warnOnce('Blob constructor present but fails: ' + e + '; falling back to blob builder');
+ }
+ }
+ if (!b) {
+ var bb = new Browser.BlobBuilder();
+ bb.append((new Uint8Array(byteArray)).buffer); // we need to pass a buffer, and must copy the array to get the right data range
+ b = bb.getBlob();
+ }
+ var url = Browser.URLObject.createObjectURL(b);
+ var img = new Image();
+ img.onload = function img_onload() {
+ assert(img.complete, 'Image ' + name + ' could not be decoded');
+ var canvas = document.createElement('canvas');
+ canvas.width = img.width;
+ canvas.height = img.height;
+ var ctx = canvas.getContext('2d');
+ ctx.drawImage(img, 0, 0);
+ Module["preloadedImages"][name] = canvas;
+ Browser.URLObject.revokeObjectURL(url);
+ if (onload) onload(byteArray);
+ };
+ img.onerror = function img_onerror(event) {
+ console.log('Image ' + url + ' could not be decoded');
+ if (onerror) onerror();
+ };
+ img.src = url;
+ };
+ Module['preloadPlugins'].push(imagePlugin);
+
+ var audioPlugin = {};
+ audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
+ return !Module.noAudioDecoding && name.substr(-4) in {
+ '.ogg': 1,
+ '.wav': 1,
+ '.mp3': 1
+ };
+ };
+ audioPlugin['handle'] = function audioPlugin_handle(byteArray, name, onload, onerror) {
+ var done = false;
+
+ function finish(audio) {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = audio;
+ if (onload) onload(byteArray);
+ }
+
+ function fail() {
+ if (done) return;
+ done = true;
+ Module["preloadedAudios"][name] = new Audio(); // empty shim
+ if (onerror) onerror();
+ }
+ if (Browser.hasBlobConstructor) {
+ try {
+ var b = new Blob([byteArray], {
+ type: Browser.getMimetype(name)
+ });
+ } catch (e) {
+ return fail();
+ }
+ var url = Browser.URLObject.createObjectURL(b); // XXX we never revoke this!
+ var audio = new Audio();
+ audio.addEventListener('canplaythrough', function() {
+ finish(audio)
+ }, false); // use addEventListener due to chromium bug 124926
+ audio.onerror = function audio_onerror(event) {
+ if (done) return;
+ console.log('warning: browser could not fully decode audio ' + name + ', trying slower base64 approach');
+
+ function encode64(data) {
+ var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+ var PAD = '=';
+ var ret = '';
+ var leftchar = 0;
+ var leftbits = 0;
+ for (var i = 0; i < data.length; i++) {
+ leftchar = (leftchar << 8) | data[i];
+ leftbits += 8;
+ while (leftbits >= 6) {
+ var curr = (leftchar >> (leftbits - 6)) & 0x3f;
+ leftbits -= 6;
+ ret += BASE[curr];
+ }
+ }
+ if (leftbits == 2) {
+ ret += BASE[(leftchar & 3) << 4];
+ ret += PAD + PAD;
+ } else if (leftbits == 4) {
+ ret += BASE[(leftchar & 0xf) << 2];
+ ret += PAD;
+ }
+ return ret;
+ }
+ audio.src = 'data:audio/x-' + name.substr(-3) + ';base64,' + encode64(byteArray);
+ finish(audio); // we don't wait for confirmation this worked - but it's worth trying
+ };
+ audio.src = url;
+ // workaround for chrome bug 124926 - we do not always get oncanplaythrough or onerror
+ Browser.safeSetTimeout(function() {
+ finish(audio); // try to use it even though it is not necessarily ready to play
+ }, 10000);
+ } else {
+ return fail();
+ }
+ };
+ Module['preloadPlugins'].push(audioPlugin);
+
+ // Canvas event setup
+
+ var canvas = Module['canvas'];
+ canvas.requestPointerLock = canvas['requestPointerLock'] ||
+ canvas['mozRequestPointerLock'] ||
+ canvas['webkitRequestPointerLock'];
+ canvas.exitPointerLock = document['exitPointerLock'] ||
+ document['mozExitPointerLock'] ||
+ document['webkitExitPointerLock'] ||
+ function() {}; // no-op if function does not exist
+ canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
+
+ function pointerLockChange() {
+ Browser.pointerLock = document['pointerLockElement'] === canvas ||
+ document['mozPointerLockElement'] === canvas ||
+ document['webkitPointerLockElement'] === canvas;
+ }
+
+ document.addEventListener('pointerlockchange', pointerLockChange, false);
+ document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+ document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+
+ if (Module['elementPointerLock']) {
+ canvas.addEventListener("click", function(ev) {
+ if (!Browser.pointerLock && canvas.requestPointerLock) {
+ canvas.requestPointerLock();
+ ev.preventDefault();
+ }
+ }, false);
+ }
+ },
+ createContext: function(canvas, useWebGL, setInModule, webGLContextAttributes) {
+ var ctx;
+ try {
+ if (useWebGL) {
+ var contextAttributes = {
+ antialias: false,
+ alpha: false
+ };
+
+ if (webGLContextAttributes) {
+ for (var attribute in webGLContextAttributes) {
+ contextAttributes[attribute] = webGLContextAttributes[attribute];
+ }
+ }
+
+
+ var errorInfo = '?';
+
+ function onContextCreationError(event) {
+ errorInfo = event.statusMessage || errorInfo;
+ }
+ canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
+ try {
+ ['experimental-webgl', 'webgl'].some(function(webglId) {
+ return ctx = canvas.getContext(webglId, contextAttributes);
+ });
+ } finally {
+ canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
+ }
+ } else {
+ ctx = canvas.getContext('2d');
+ }
+ if (!ctx) throw ':(';
+ } catch (e) {
+ Module.print('Could not create canvas: ' + [errorInfo, e]);
+ return null;
+ }
+ if (useWebGL) {
+ // Set the background of the WebGL canvas to black
+ canvas.style.backgroundColor = "black";
+
+ // Warn on context loss
+ canvas.addEventListener('webglcontextlost', function(event) {
+ alert('WebGL context lost. You will need to reload the page.');
+ }, false);
+ }
+ if (setInModule) {
+ GLctx = Module.ctx = ctx;
+ Module.useWebGL = useWebGL;
+ Browser.moduleContextCreatedCallbacks.forEach(function(callback) {
+ callback()
+ });
+ Browser.init();
+ }
+ return ctx;
+ },
+ destroyContext: function(canvas, useWebGL, setInModule) {},
+ fullScreenHandlersInstalled: false,
+ lockPointer: undefined,
+ resizeCanvas: undefined,
+ requestFullScreen: function(lockPointer, resizeCanvas) {
+ Browser.lockPointer = lockPointer;
+ Browser.resizeCanvas = resizeCanvas;
+ if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
+ if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
+
+ var canvas = Module['canvas'];
+
+ function fullScreenChange() {
+ Browser.isFullScreen = false;
+ if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] ||
+ document['mozFullScreenElement'] || document['mozFullscreenElement'] ||
+ document['fullScreenElement'] || document['fullscreenElement']) === canvas) {
+ canvas.cancelFullScreen = document['cancelFullScreen'] ||
+ document['mozCancelFullScreen'] ||
+ document['webkitCancelFullScreen'];
+ canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document);
+ if (Browser.lockPointer) canvas.requestPointerLock();
+ Browser.isFullScreen = true;
+ if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize();
+ } else if (Browser.resizeCanvas) {
+ Browser.setWindowedCanvasSize();
+ }
+ if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen);
+ }
+
+ if (!Browser.fullScreenHandlersInstalled) {
+ Browser.fullScreenHandlersInstalled = true;
+ document.addEventListener('fullscreenchange', fullScreenChange, false);
+ document.addEventListener('mozfullscreenchange', fullScreenChange, false);
+ document.addEventListener('webkitfullscreenchange', fullScreenChange, false);
+ }
+
+ canvas.requestFullScreen = canvas['requestFullScreen'] ||
+ canvas['mozRequestFullScreen'] ||
+ (canvas['webkitRequestFullScreen'] ? function() {
+ canvas['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT'])
+ } : null);
+ canvas.requestFullScreen();
+ },
+ requestAnimationFrame: function requestAnimationFrame(func) {
+ if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js)
+ setTimeout(func, 1000 / 60);
+ } else {
+ if (!window.requestAnimationFrame) {
+ window.requestAnimationFrame = window['requestAnimationFrame'] ||
+ window['mozRequestAnimationFrame'] ||
+ window['webkitRequestAnimationFrame'] ||
+ window['msRequestAnimationFrame'] ||
+ window['oRequestAnimationFrame'] ||
+ window['setTimeout'];
+ }
+ window.requestAnimationFrame(func);
+ }
+ },
+ safeCallback: function(func) {
+ return function() {
+ if (!ABORT) return func.apply(null, arguments);
+ };
+ },
+ safeRequestAnimationFrame: function(func) {
+ return Browser.requestAnimationFrame(function() {
+ if (!ABORT) func();
+ });
+ },
+ safeSetTimeout: function(func, timeout) {
+ return setTimeout(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },
+ safeSetInterval: function(func, timeout) {
+ return setInterval(function() {
+ if (!ABORT) func();
+ }, timeout);
+ },
+ getMimetype: function(name) {
+ return {
+ 'jpg': 'image/jpeg',
+ 'jpeg': 'image/jpeg',
+ 'png': 'image/png',
+ 'bmp': 'image/bmp',
+ 'ogg': 'audio/ogg',
+ 'wav': 'audio/wav',
+ 'mp3': 'audio/mpeg'
+ }[name.substr(name.lastIndexOf('.') + 1)];
+ },
+ getUserMedia: function(func) {
+ if (!window.getUserMedia) {
+ window.getUserMedia = navigator['getUserMedia'] ||
+ navigator['mozGetUserMedia'];
+ }
+ window.getUserMedia(func);
+ },
+ getMovementX: function(event) {
+ return event['movementX'] ||
+ event['mozMovementX'] ||
+ event['webkitMovementX'] ||
+ 0;
+ },
+ getMovementY: function(event) {
+ return event['movementY'] ||
+ event['mozMovementY'] ||
+ event['webkitMovementY'] ||
+ 0;
+ },
+ mouseX: 0,
+ mouseY: 0,
+ mouseMovementX: 0,
+ mouseMovementY: 0,
+ calculateMouseEvent: function(event) { // event should be mousemove, mousedown or mouseup
+ if (Browser.pointerLock) {
+ // When the pointer is locked, calculate the coordinates
+ // based on the movement of the mouse.
+ // Workaround for Firefox bug 764498
+ if (event.type != 'mousemove' &&
+ ('mozMovementX' in event)) {
+ Browser.mouseMovementX = Browser.mouseMovementY = 0;
+ } else {
+ Browser.mouseMovementX = Browser.getMovementX(event);
+ Browser.mouseMovementY = Browser.getMovementY(event);
+ }
+
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
+ Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
+ } else {
+ // just add the mouse delta to the current absolut mouse position
+ // FIXME: ideally this should be clamped against the canvas size and zero
+ Browser.mouseX += Browser.mouseMovementX;
+ Browser.mouseY += Browser.mouseMovementY;
+ }
+ } else {
+ // Otherwise, calculate the movement based on the changes
+ // in the coordinates.
+ var rect = Module["canvas"].getBoundingClientRect();
+ var x, y;
+
+ // Neither .scrollX or .pageXOffset are defined in a spec, but
+ // we prefer .scrollX because it is currently in a spec draft.
+ // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/)
+ var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset);
+ var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset);
+ if (event.type == 'touchstart' ||
+ event.type == 'touchend' ||
+ event.type == 'touchmove') {
+ var t = event.touches.item(0);
+ if (t) {
+ x = t.pageX - (scrollX + rect.left);
+ y = t.pageY - (scrollY + rect.top);
+ } else {
+ return;
+ }
+ } else {
+ x = event.pageX - (scrollX + rect.left);
+ y = event.pageY - (scrollY + rect.top);
+ }
+
+ // the canvas might be CSS-scaled compared to its backbuffer;
+ // SDL-using content will want mouse coordinates in terms
+ // of backbuffer units.
+ var cw = Module["canvas"].width;
+ var ch = Module["canvas"].height;
+ x = x * (cw / rect.width);
+ y = y * (ch / rect.height);
+
+ Browser.mouseMovementX = x - Browser.mouseX;
+ Browser.mouseMovementY = y - Browser.mouseY;
+ Browser.mouseX = x;
+ Browser.mouseY = y;
+ }
+ },
+ xhrLoad: function(url, onload, onerror) {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function xhr_onload() {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0
+ onload(xhr.response);
+ } else {
+ onerror();
+ }
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ },
+ asyncLoad: function(url, onload, onerror, noRunDep) {
+ Browser.xhrLoad(url, function(arrayBuffer) {
+ assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
+ onload(new Uint8Array(arrayBuffer));
+ if (!noRunDep) removeRunDependency('al ' + url);
+ }, function(event) {
+ if (onerror) {
+ onerror();
+ } else {
+ throw 'Loading data file "' + url + '" failed.';
+ }
+ });
+ if (!noRunDep) addRunDependency('al ' + url);
+ },
+ resizeListeners: [],
+ updateResizeListeners: function() {
+ var canvas = Module['canvas'];
+ Browser.resizeListeners.forEach(function(listener) {
+ listener(canvas.width, canvas.height);
+ });
+ },
+ setCanvasSize: function(width, height, noUpdates) {
+ var canvas = Module['canvas'];
+ canvas.width = width;
+ canvas.height = height;
+ if (!noUpdates) Browser.updateResizeListeners();
+ },
+ windowedWidth: 0,
+ windowedHeight: 0,
+ setFullScreenCanvasSize: function() {
+ var canvas = Module['canvas'];
+ this.windowedWidth = canvas.width;
+ this.windowedHeight = canvas.height;
+ canvas.width = screen.width;
+ canvas.height = screen.height;
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen + Runtime.QUANTUM_SIZE * 0) >> 2)];
+ flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen + Runtime.QUANTUM_SIZE * 0) >> 2)] = flags
+ }
+ Browser.updateResizeListeners();
+ },
+ setWindowedCanvasSize: function() {
+ var canvas = Module['canvas'];
+ canvas.width = this.windowedWidth;
+ canvas.height = this.windowedHeight;
+ // check if SDL is available
+ if (typeof SDL != "undefined") {
+ var flags = HEAPU32[((SDL.screen + Runtime.QUANTUM_SIZE * 0) >> 2)];
+ flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
+ HEAP32[((SDL.screen + Runtime.QUANTUM_SIZE * 0) >> 2)] = flags
+ }
+ Browser.updateResizeListeners();
+ }
+};
+FS.staticInit();
+__ATINIT__.unshift({
+ func: function() {
+ if (!Module["noFSInit"] && !FS.init.initialized) FS.init()
+ }
+});
+__ATMAIN__.push({
+ func: function() {
+ FS.ignorePermissions = false
+ }
+});
+__ATEXIT__.push({
+ func: function() {
+ FS.quit()
+ }
+});
+Module["FS_createFolder"] = FS.createFolder;
+Module["FS_createPath"] = FS.createPath;
+Module["FS_createDataFile"] = FS.createDataFile;
+Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
+Module["FS_createLazyFile"] = FS.createLazyFile;
+Module["FS_createLink"] = FS.createLink;
+Module["FS_createDevice"] = FS.createDevice;
+___errno_state = Runtime.staticAlloc(4);
+HEAP32[((___errno_state) >> 2)] = 0;
+__ATINIT__.unshift({
+ func: function() {
+ TTY.init()
+ }
+});
+__ATEXIT__.push({
+ func: function() {
+ TTY.shutdown()
+ }
+});
+TTY.utf8 = new Runtime.UTF8Processor();
+if (ENVIRONMENT_IS_NODE) {
+ var fs = require("fs");
+ NODEFS.staticInit();
+}
+__ATINIT__.push({
+ func: function() {
+ SOCKFS.root = FS.mount(SOCKFS, {}, null);
+ }
+});
+_fputc.ret = allocate([0], "i8", ALLOC_STATIC);
+Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) {
+ Browser.requestFullScreen(lockPointer, resizeCanvas)
+};
+Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) {
+ Browser.requestAnimationFrame(func)
+};
+Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) {
+ Browser.setCanvasSize(width, height, noUpdates)
+};
+Module["pauseMainLoop"] = function Module_pauseMainLoop() {
+ Browser.mainLoop.pause()
+};
+Module["resumeMainLoop"] = function Module_resumeMainLoop() {
+ Browser.mainLoop.resume()
+};
+Module["getUserMedia"] = function Module_getUserMedia() {
+ Browser.getUserMedia()
+}
+STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP);
+
+staticSealed = true; // seal the static portion of memory
+
+STACK_MAX = STACK_BASE + 5242880;
+
+DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX);
+
+assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack");
+
+
+var Math_min = Math.min;
+
+function invoke_vi(index, a1) {
+ try {
+ Module["dynCall_vi"](index, a1);
+ } catch (e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_vii(index, a1, a2) {
+ try {
+ Module["dynCall_vii"](index, a1, a2);
+ } catch (e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_ii(index, a1) {
+ try {
+ return Module["dynCall_ii"](index, a1);
+ } catch (e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_ff(index, a1) {
+ try {
+ return Module["dynCall_ff"](index, a1);
+ } catch (e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_v(index) {
+ try {
+ Module["dynCall_v"](index);
+ } catch (e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function invoke_iii(index, a1, a2) {
+ try {
+ return Module["dynCall_iii"](index, a1, a2);
+ } catch (e) {
+ if (typeof e !== 'number' && e !== 'longjmp') throw e;
+ asm["setThrew"](1, 0);
+ }
+}
+
+function asmPrintInt(x, y) {
+ Module.print('int ' + x + ',' + y); // + ' ' + new Error().stack);
+}
+
+function asmPrintFloat(x, y) {
+ Module.print('float ' + x + ',' + y); // + ' ' + new Error().stack);
+ }
+ // EMSCRIPTEN_START_ASM
+var asm = (function(global, env, buffer) {
+ "use asm";
+ var a = new global.Int8Array(buffer);
+ var b = new global.Int16Array(buffer);
+ var c = new global.Int32Array(buffer);
+ var d = new global.Uint8Array(buffer);
+ var e = new global.Uint16Array(buffer);
+ var f = new global.Uint32Array(buffer);
+ var g = new global.Float32Array(buffer);
+ var h = new global.Float64Array(buffer);
+ var i = env.STACKTOP | 0;
+ var j = env.STACK_MAX | 0;
+ var k = env.tempDoublePtr | 0;
+ var l = env.ABORT | 0;
+ var m = +env.NaN;
+ var n = +env.Infinity;
+ var o = 0;
+ var p = 0;
+ var q = 0;
+ var r = 0;
+ var s = 0,
+ t = 0,
+ u = 0,
+ v = 0,
+ w = 0.0,
+ x = 0,
+ y = 0,
+ z = 0,
+ A = 0.0;
+ var B = 0;
+ var C = 0;
+ var D = 0;
+ var E = 0;
+ var F = 0;
+ var G = 0;
+ var H = 0;
+ var I = 0;
+ var J = 0;
+ var K = 0;
+ var L = global.Math.floor;
+ var M = global.Math.abs;
+ var N = global.Math.sqrt;
+ var O = global.Math.pow;
+ var P = global.Math.cos;
+ var Q = global.Math.sin;
+ var R = global.Math.tan;
+ var S = global.Math.acos;
+ var T = global.Math.asin;
+ var U = global.Math.atan;
+ var V = global.Math.atan2;
+ var W = global.Math.exp;
+ var X = global.Math.log;
+ var Y = global.Math.ceil;
+ var Z = global.Math.imul;
+ var _ = env.abort;
+ var $ = env.assert;
+ var aa = env.asmPrintInt;
+ var ba = env.asmPrintFloat;
+ var ca = env.min;
+ var da = env.invoke_vi;
+ var ea = env.invoke_vii;
+ var fa = env.invoke_ii;
+ var ga = env.invoke_ff;
+ var ha = env.invoke_v;
+ var ia = env.invoke_iii;
+ var ja = env._strncmp;
+ var ka = env._fabsf;
+ var la = env._sysconf;
+ var ma = env._abort;
+ var na = env._fprintf;
+ var oa = env._printf;
+ var pa = env._fflush;
+ var qa = env.__reallyNegative;
+ var ra = env._sqrtf;
+ var sa = env._fputc;
+ var ta = env._fabs;
+ var ua = env.___setErrNo;
+ var va = env._fwrite;
+ var wa = env._send;
+ var xa = env._write;
+ var ya = env._fputs;
+ var za = env._log10;
+ var Aa = env._sin;
+ var Ba = env._ceilf;
+ var Ca = env.__formatString;
+ var Da = env._cos;
+ var Ea = env._pwrite;
+ var Fa = env._puts;
+ var Ga = env._sbrk;
+ var Ha = env.___errno_location;
+ var Ia = env._atan2;
+ var Ja = env._time;
+ var Ka = env._strcmp;
+ var La = 0.0;
+ // EMSCRIPTEN_START_FUNCS
+ function Sa(a) {
+ a = a | 0;
+ var b = 0;
+ b = i;
+ i = i + a | 0;
+ i = i + 7 & -8;
+ return b | 0
+ }
+
+ function Ta() {
+ return i | 0
+ }
+
+ function Ua(a) {
+ a = a | 0;
+ i = a
+ }
+
+ function Va(a, b) {
+ a = a | 0;
+ b = b | 0;
+ if ((o | 0) == 0) {
+ o = a;
+ p = b
+ }
+ }
+
+ function Wa(b) {
+ b = b | 0;
+ a[k] = a[b];
+ a[k + 1 | 0] = a[b + 1 | 0];
+ a[k + 2 | 0] = a[b + 2 | 0];
+ a[k + 3 | 0] = a[b + 3 | 0]
+ }
+
+ function Xa(b) {
+ b = b | 0;
+ a[k] = a[b];
+ a[k + 1 | 0] = a[b + 1 | 0];
+ a[k + 2 | 0] = a[b + 2 | 0];
+ a[k + 3 | 0] = a[b + 3 | 0];
+ a[k + 4 | 0] = a[b + 4 | 0];
+ a[k + 5 | 0] = a[b + 5 | 0];
+ a[k + 6 | 0] = a[b + 6 | 0];
+ a[k + 7 | 0] = a[b + 7 | 0]
+ }
+
+ function Ya(a) {
+ a = a | 0;
+ B = a
+ }
+
+ function Za(a) {
+ a = a | 0;
+ C = a
+ }
+
+ function _a(a) {
+ a = a | 0;
+ D = a
+ }
+
+ function $a(a) {
+ a = a | 0;
+ E = a
+ }
+
+ function ab(a) {
+ a = a | 0;
+ F = a
+ }
+
+ function bb(a) {
+ a = a | 0;
+ G = a
+ }
+
+ function cb(a) {
+ a = a | 0;
+ H = a
+ }
+
+ function db(a) {
+ a = a | 0;
+ I = a
+ }
+
+ function eb(a) {
+ a = a | 0;
+ J = a
+ }
+
+ function fb(a) {
+ a = a | 0;
+ K = a
+ }
+
+ function gb() {}
+
+ function hb(a) {
+ a = a | 0;
+ ac(c[a + 12 >> 2] | 0);
+ return
+ }
+
+ function ib(a) {
+ a = a | 0;
+ if ((Ka(2160, a | 0) | 0) == 0) {
+ return 0
+ } else {
+ a = (Ka(2144, a | 0) | 0) == 0;
+ return (a ? 1 : 2) | 0
+ }
+ return 0
+ }
+
+ function jb(a) {
+ a = a | 0;
+ if ((a | 0) == 1) {
+ a = 2144
+ } else if ((a | 0) == 2) {
+ a = 2136
+ } else if ((a | 0) == 0) {
+ a = 2160
+ } else {
+ a = 2128
+ }
+ return a | 0
+ }
+
+ function kb(a) {
+ a = +a;
+ a = a * .5 + .5;
+ return +(.42 - +P(a * 6.2831854820251465) * .5 + +P(a * 12.566370964050293) * .08)
+ }
+
+ function lb(a) {
+ a = +a;
+ return +(.54 - +P((a * .5 + .5) * 6.2831854820251465) * .46)
+ }
+
+ function mb(a) {
+ a = +a;
+ return +1.0
+ }
+
+ function nb(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = +c;
+ d = d | 0;
+ var e = 0,
+ f = 0.0,
+ h = 0,
+ i = 0.0,
+ j = 0.0;
+ e = (b | 0) / 2 | 0;
+ if ((d | 0) == 1) {
+ d = 6
+ } else if ((d | 0) == 0) {
+ d = 2
+ } else {
+ d = 4
+ }
+ c = c * 6.2831854820251465;
+ g[a + (e << 2) >> 2] = c * +Pa[d & 7](0.0);
+ if ((b | 0) >= 2) {
+ f = +(e | 0);
+ h = 1;
+ do {
+ i = +(h | 0);
+ j = +Q(c * i) / +(h | 0);
+ i = j * +Pa[d & 7](i / f);
+ g[a + (h + e << 2) >> 2] = i;
+ g[a + (e - h << 2) >> 2] = i;
+ h = h + 1 | 0;
+ } while ((e | 0) >= (h | 0))
+ }
+ e = (b | 0) > 0;
+ if (e) {
+ c = 0.0;
+ d = 0
+ } else {
+ return
+ }
+ do {
+ c = c + +g[a + (d << 2) >> 2];
+ d = d + 1 | 0;
+ } while ((d | 0) < (b | 0));
+ if (e) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ h = a + (e << 2) | 0;
+ g[h >> 2] = +g[h >> 2] / c;
+ e = e + 1 | 0;
+ } while ((e | 0) < (b | 0));
+ return
+ }
+
+ function ob(a, b, c, d, e) {
+ a = a | 0;
+ b = b | 0;
+ c = +c;
+ d = +d;
+ e = e | 0;
+ var f = 0,
+ h = 0,
+ i = 0.0,
+ j = 0.0,
+ k = 0,
+ l = 0.0,
+ m = 0.0;
+ f = bc(b << 2) | 0;
+ i = (d - c) * .5;
+ h = (b | 0) / 2 | 0;
+ if ((e | 0) == 0) {
+ e = 2
+ } else if ((e | 0) == 1) {
+ e = 6
+ } else {
+ e = 4
+ }
+ j = i * 6.2831854820251465;
+ g[f + (h << 2) >> 2] = j * +Pa[e & 7](0.0);
+ if ((b | 0) >= 2) {
+ i = +(h | 0);
+ k = 1;
+ do {
+ l = +(k | 0);
+ m = +Q(j * l) / +(k | 0);
+ l = m * +Pa[e & 7](l / i);
+ g[f + (k + h << 2) >> 2] = l;
+ g[f + (h - k << 2) >> 2] = l;
+ k = k + 1 | 0;
+ } while ((h | 0) >= (k | 0))
+ }
+ h = (b | 0) > 0;
+ if (h) {
+ i = 0.0;
+ e = 0
+ } else {
+ return
+ }
+ while (1) {
+ i = i + +g[f + (e << 2) >> 2];
+ e = e + 1 | 0;
+ if ((e | 0) >= (b | 0)) {
+ e = 0;
+ break
+ }
+ }
+ do {
+ k = f + (e << 2) | 0;
+ g[k >> 2] = +g[k >> 2] / i;
+ e = e + 1 | 0;
+ } while ((e | 0) < (b | 0));
+ if (!h) {
+ return
+ }
+ c = (c + d) * .5 * 6.2831854820251465;
+ j = 0.0;
+ h = 0;
+ do {
+ d = j;
+ i = +P(d);
+ d = +Q(d);
+ j = c + j;
+ if (j > 6.2831854820251465) {
+ do {
+ j = j + -6.2831854820251465;
+ } while (j > 6.2831854820251465)
+ }
+ if (j < 0.0) {
+ do {
+ j = j + 6.2831854820251465;
+ } while (j < 0.0)
+ }
+ m = +g[f + (h << 2) >> 2];
+ k = a + (h << 3) | 0;
+ g[k >> 2] = i * m;
+ g[k + 4 >> 2] = d * m;
+ h = h + 1 | 0;
+ } while ((h | 0) < (b | 0));
+ return
+ }
+
+ function pb(a) {
+ a = +a;
+ var b = 0;
+ b = ~~(4.0 / a);
+ return (b & 1 ^ 1) + b | 0
+ }
+
+ function qb(a, b, c, d, e) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ e = +e;
+ var f = 0,
+ h = 0,
+ i = 0,
+ j = 0.0,
+ k = 0,
+ l = 0.0;
+ d = d * 2.0 * 3.1415927410125732;
+ if ((c | 0) > 0) {
+ f = 0
+ } else {
+ return +e
+ }
+ do {
+ l = e;
+ j = +P(l);
+ l = +Q(l);
+ k = a + (f << 3) | 0;
+ i = k + 4 | 0;
+ h = b + (f << 3) | 0;
+ g[h >> 2] = j * +g[k >> 2] - l * +g[i >> 2];
+ g[h + 4 >> 2] = l * +g[k >> 2] + j * +g[i >> 2];
+ e = d + e;
+ if (e > 6.2831854820251465) {
+ do {
+ e = e + -6.2831854820251465;
+ } while (e > 6.2831854820251465)
+ }
+ if (e < 0.0) {
+ do {
+ e = e + 6.2831854820251465;
+ } while (e < 0.0)
+ }
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ return +e
+ }
+
+ function rb(a, b) {
+ a = a | 0;
+ b = b | 0;
+ var d = 0,
+ e = 0.0,
+ f = 0;
+ d = bc(b << 2) | 0;
+ if ((b | 0) > 0) {
+ e = +(b | 0);
+ f = 0;
+ do {
+ g[d + (f << 2) >> 2] = +Q(+(f | 0) / e * 1.5707963705062866);
+ f = f + 1 | 0;
+ } while ((f | 0) < (b | 0))
+ }
+ c[a >> 2] = d;
+ c[a + 4 >> 2] = b;
+ return
+ }
+
+ function sb(a) {
+ a = a | 0;
+ var b = 0,
+ d = 0;
+ b = i;
+ d = a;
+ a = i;
+ i = i + 8 | 0;
+ c[a >> 2] = c[d >> 2];
+ c[a + 4 >> 2] = c[d + 4 >> 2];
+ cc(c[a >> 2] | 0);
+ i = b;
+ return
+ }
+
+ function tb(a, b, d, e, f, h) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = +e;
+ f = f | 0;
+ h = +h;
+ var j = 0,
+ k = 0.0,
+ l = 0,
+ m = 0,
+ n = 0.0,
+ o = 0,
+ p = 0,
+ q = 0,
+ r = 0.0,
+ s = 0;
+ j = i;
+ s = f;
+ f = i;
+ i = i + 8 | 0;
+ c[f >> 2] = c[s >> 2];
+ c[f + 4 >> 2] = c[s + 4 >> 2];
+ e = e * 2.0 * 3.1415927410125732;
+ if ((d | 0) <= 0) {
+ r = h;
+ i = j;
+ return +r
+ }
+ l = c[f + 4 >> 2] | 0;
+ k = +(l | 0);
+ l = l - 1 | 0;
+ f = c[f >> 2] | 0;
+ m = 0;
+ do {
+ s = ~~(h / 1.5707963705062866);
+ o = ~~((h - +(s | 0) * 1.5707963705062866) / 1.5707963705062866 * k);
+ p = l - o | 0;
+ q = (s & 1 | 0) == 0;
+ if ((s | 0) == 0) {
+ n = 1.0
+ } else {
+ n = (s | 0) < 3 ? -1.0 : 1.0
+ }
+ r = ((s | 0) > 1 ? -1.0 : 1.0) * +g[f + ((q ? o : p) << 2) >> 2];
+ n = n * +g[f + ((q ? p : o) << 2) >> 2];
+ p = a + (m << 3) | 0;
+ q = p + 4 | 0;
+ s = b + (m << 3) | 0;
+ g[s >> 2] = n * +g[p >> 2] - r * +g[q >> 2];
+ g[s + 4 >> 2] = r * +g[p >> 2] + n * +g[q >> 2];
+ h = e + h;
+ if (h > 6.2831854820251465) {
+ do {
+ h = h + -6.2831854820251465;
+ } while (h > 6.2831854820251465)
+ }
+ if (h < 0.0) {
+ do {
+ h = h + 6.2831854820251465;
+ } while (h < 0.0)
+ }
+ m = m + 1 | 0;
+ } while ((m | 0) < (d | 0));
+ i = j;
+ return +h
+ }
+
+ function ub(a, b, c, d, e, f) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = d | 0;
+ e = e | 0;
+ f = f | 0;
+ var h = 0,
+ i = 0,
+ j = 0.0,
+ k = 0.0,
+ l = 0;
+ if ((c | 0) < 1 | (f | 0) > (c | 0)) {
+ l = 0;
+ return l | 0
+ }
+ if ((f | 0) > 0) {
+ i = 0;
+ h = 0
+ } else {
+ i = 0;
+ a = 0;
+ do {
+ l = b + (i << 3) | 0;
+ g[l >> 2] = 0.0;
+ g[l + 4 >> 2] = 0.0;
+ i = i + 1 | 0;
+ a = a + d | 0;
+ } while (!((a | 0) >= (c | 0) | (a + f | 0) > (c | 0)));
+ return i | 0
+ }
+ do {
+ j = 0.0;
+ l = 0;
+ while (1) {
+ j = j + +g[a + (l + h << 3) >> 2] * +g[e + (l << 2) >> 2];
+ l = l + 1 | 0;
+ if ((l | 0) >= (f | 0)) {
+ k = 0.0;
+ l = 0;
+ break
+ }
+ }
+ do {
+ k = k + +g[a + (l + h << 3) + 4 >> 2] * +g[e + (l << 2) >> 2];
+ l = l + 1 | 0;
+ } while ((l | 0) < (f | 0));
+ l = b + (i << 3) | 0;
+ g[l >> 2] = j;
+ g[l + 4 >> 2] = k;
+ i = i + 1 | 0;
+ h = h + d | 0;
+ } while (!((h | 0) >= (c | 0) | (h + f | 0) > (c | 0)));
+ return i | 0
+ }
+
+ function vb(a, b, d, e, f, h, i, j, k) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = f | 0;
+ h = h | 0;
+ i = i | 0;
+ j = j | 0;
+ k = k | 0;
+ var l = 0,
+ m = 0,
+ n = 0.0,
+ o = 0,
+ p = 0,
+ q = 0,
+ r = 0,
+ s = 0,
+ t = 0,
+ u = 0.0;
+ q = (Z(f, e) | 0) / (h | 0) | 0;
+ a: do {
+ if ((q | 0) > 0) {
+ r = f - 1 - k | 0;
+ p = (j | 0) / (f | 0) | 0;
+ n = +(f | 0);
+ l = 0;
+ do {
+ m = Z(l, h) | 0;
+ o = (r + m | 0) / (f | 0) | 0;
+ m = (k - m + (Z(o, f) | 0) | 0) % (f | 0) | 0;
+ if ((p + o | 0) >= (e | 0)) {
+ break a
+ }
+ s = (j - m | 0) / (f | 0) | 0;
+ if ((s | 0) > 0) {
+ u = 0.0;
+ t = 0;
+ do {
+ u = u + +g[b + (t + o << 2) >> 2] * +g[i + ((Z(t, f) | 0) + m << 2) >> 2];
+ t = t + 1 | 0;
+ } while ((t | 0) < (s | 0))
+ } else {
+ u = 0.0
+ }
+ g[d + (l << 2) >> 2] = n * u;
+ l = l + 1 | 0;
+ } while ((l | 0) < (q | 0))
+ } else {
+ o = 0;
+ m = 0;
+ l = 0
+ }
+ } while (0);
+ c[a >> 2] = o;
+ c[a + 4 >> 2] = l;
+ c[a + 8 >> 2] = m;
+ return
+ }
+
+ function wb(a, b, c, d, e) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = d | 0;
+ e = e | 0;
+ var f = 0.0,
+ h = 0.0,
+ i = 0.0,
+ j = 0.0;
+ f = 1.0 / +(c | 0);
+ h = 1.0 / +(d | 0);
+ f = (f < h ? f : h) * .5;
+ d = (b | 0) / 2 | 0;
+ if ((e | 0) == 1) {
+ e = 6
+ } else if ((e | 0) == 0) {
+ e = 2
+ } else {
+ e = 4
+ }
+ h = f * 6.2831854820251465;
+ g[a + (d << 2) >> 2] = h * +Pa[e & 7](0.0);
+ if ((b | 0) >= 2) {
+ f = +(d | 0);
+ c = 1;
+ do {
+ i = +(c | 0);
+ j = +Q(h * i) / +(c | 0);
+ i = j * +Pa[e & 7](i / f);
+ g[a + (c + d << 2) >> 2] = i;
+ g[a + (d - c << 2) >> 2] = i;
+ c = c + 1 | 0;
+ } while ((d | 0) >= (c | 0))
+ }
+ if ((b | 0) > 0) {
+ f = 0.0;
+ d = 0
+ } else {
+ return
+ }
+ while (1) {
+ f = f + +g[a + (d << 2) >> 2];
+ d = d + 1 | 0;
+ if ((d | 0) >= (b | 0)) {
+ d = 0;
+ break
+ }
+ }
+ do {
+ c = a + (d << 2) | 0;
+ g[c >> 2] = +g[c >> 2] / f;
+ d = d + 1 | 0;
+ } while ((d | 0) < (b | 0));
+ return
+ }
+
+ function xb(a, b, d, e, f, h, j, k) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = +f;
+ h = h | 0;
+ j = j | 0;
+ k = k | 0;
+ var l = 0,
+ m = 0,
+ n = 0,
+ o = 0,
+ p = 0.0,
+ q = 0,
+ r = 0,
+ s = 0,
+ t = 0,
+ u = 0,
+ v = 0.0,
+ w = 0,
+ x = 0.0,
+ y = 0.0;
+ l = i;
+ w = k;
+ k = i;
+ i = i + 12 | 0;
+ i = i + 7 & -8;
+ c[k >> 2] = c[w >> 2];
+ c[k + 4 >> 2] = c[w + 4 >> 2];
+ c[k + 8 >> 2] = c[w + 8 >> 2];
+ if (f <= 1.0) {
+ w = a;
+ u = k;
+ c[w >> 2] = c[u >> 2];
+ c[w + 4 >> 2] = c[u + 4 >> 2];
+ c[w + 8 >> 2] = c[u + 8 >> 2];
+ i = l;
+ return
+ }
+ m = k | 0;
+ p = +g[m >> 2];
+ if (p == 0.0) {
+ if ((j | 0) > 0) {
+ v = 0.0;
+ o = 0;
+ do {
+ v = v + +g[h + (o << 2) >> 2] * +g[b + (o << 2) >> 2];
+ o = o + 1 | 0;
+ } while ((o | 0) < (j | 0))
+ } else {
+ v = 0.0
+ }
+ g[d >> 2] = v;
+ q = 1;
+ p = p + f
+ } else {
+ q = 0
+ }
+ r = ~~+Y(p);
+ t = r - 1 | 0;
+ if ((r + j | 0) < (e | 0)) {
+ o = (j | 0) > 0;
+ v = 0.0;
+ s = -1;
+ while (1) {
+ do {
+ if ((s | 0) == (t | 0)) {
+ n = 12
+ } else {
+ s = r - 1 | 0;
+ if (o) {
+ v = 0.0;
+ n = 0
+ } else {
+ x = 0.0;
+ v = 0.0;
+ break
+ }
+ while (1) {
+ v = v + +g[h + (n << 2) >> 2] * +g[b + (s + n << 2) >> 2];
+ n = n + 1 | 0;
+ if ((n | 0) >= (j | 0)) {
+ n = 12;
+ break
+ }
+ }
+ }
+ } while (0);
+ do {
+ if ((n | 0) == 12) {
+ n = 0;
+ if (o) {
+ x = 0.0;
+ s = 0
+ } else {
+ x = 0.0;
+ break
+ }
+ do {
+ x = x + +g[h + (s << 2) >> 2] * +g[b + (s + r << 2) >> 2];
+ s = s + 1 | 0;
+ } while ((s | 0) < (j | 0))
+ }
+ } while (0);
+ y = p - +(r | 0) + 1.0;
+ u = q + 1 | 0;
+ g[d + (q << 2) >> 2] = (1.0 - y) * v + y * x;
+ p = p + f;
+ w = ~~+Y(p);
+ t = w - 1 | 0;
+ if ((w + j | 0) < (e | 0)) {
+ v = x;
+ s = r;
+ q = u;
+ r = w
+ } else {
+ q = u;
+ break
+ }
+ }
+ }
+ c[k + 4 >> 2] = t;
+ g[m >> 2] = p - +(t | 0);
+ c[k + 8 >> 2] = q;
+ w = a;
+ u = k;
+ c[w >> 2] = c[u >> 2];
+ c[w + 4 >> 2] = c[u + 4 >> 2];
+ c[w + 8 >> 2] = c[u + 8 >> 2];
+ i = l;
+ return
+ }
+
+ function yb(a, b, d, e, f) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = f | 0;
+ var h = 0,
+ i = 0,
+ j = 0,
+ k = 0,
+ l = 0,
+ m = 0,
+ n = 0,
+ o = 0,
+ p = 0;
+ hb(a);
+ h = a | 0;
+ if ((c[h >> 2] | 0) > 0) {
+ a = c[a + 8 >> 2] | 0;
+ i = c[b + 4 >> 2] | 0;
+ j = 0;
+ do {
+ p = j << 1;
+ o = a + (p << 2) | 0;
+ l = d + (j << 3) | 0;
+ k = p | 1;
+ m = a + (k << 2) | 0;
+ n = l + 4 | 0;
+ g[i + (p << 2) >> 2] = +g[o >> 2] * +g[l >> 2] - +g[m >> 2] * +g[n >> 2];
+ g[i + (k << 2) >> 2] = +g[o >> 2] * +g[n >> 2] + +g[m >> 2] * +g[l >> 2];
+ j = j + 1 | 0;
+ } while ((j | 0) < (c[h >> 2] | 0))
+ }
+ hb(b);
+ d = c[b + 8 >> 2] | 0;
+ i = c[h >> 2] | 0;
+ if ((i | 0) > 0) {
+ a = d;
+ b = 0;
+ do {
+ p = b << 1;
+ o = a + (p << 2) | 0;
+ g[o >> 2] = +g[o >> 2] / +(i | 0);
+ p = a + ((p | 1) << 2) | 0;
+ g[p >> 2] = +g[p >> 2] / +(c[h >> 2] | 0);
+ b = b + 1 | 0;
+ i = c[h >> 2] | 0;
+ } while ((b | 0) < (i | 0))
+ }
+ if ((f | 0) <= 0) {
+ return
+ }
+ h = 0;
+ do {
+ p = h << 1;
+ n = d + (p << 2) | 0;
+ o = e + (h << 3) | 0;
+ g[n >> 2] = +g[n >> 2] + +g[o >> 2];
+ p = d + ((p | 1) << 2) | 0;
+ g[p >> 2] = +g[p >> 2] + +g[o + 4 >> 2];
+ h = h + 1 | 0;
+ } while ((h | 0) < (f | 0));
+ return
+ }
+
+ function zb(a, b, c) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ var d = 0,
+ e = 0,
+ f = 0.0,
+ h = 0.0,
+ i = 0;
+ d = (c | 0) > 0;
+ if (d) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ i = a + (e << 3) | 0;
+ h = +g[i >> 2];
+ f = +g[i + 4 >> 2];
+ g[b + (e << 2) >> 2] = h * h + f * f;
+ e = e + 1 | 0;
+ } while ((e | 0) < (c | 0));
+ if (d) {
+ a = 0
+ } else {
+ return
+ }
+ do {
+ i = b + (a << 2) | 0;
+ g[i >> 2] = +N(+g[i >> 2]);
+ a = a + 1 | 0;
+ } while ((a | 0) < (c | 0));
+ return
+ }
+
+ function Ab(a, b, c, d, e) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ e = +e;
+ var f = 0,
+ h = 0.0,
+ i = 0,
+ j = 0.0;
+ f = d == 0.0;
+ d = f ? .9475436210632324 : d;
+ e = f ? .39248543977737427 : e;
+ if ((c | 0) > 0) {
+ f = 0
+ } else {
+ return
+ }
+ do {
+ i = a + (f << 3) | 0;
+ h = +g[i >> 2];
+ if (h < 0.0) {
+ h = -0.0 - h
+ }
+ j = +g[i + 4 >> 2];
+ if (j < 0.0) {
+ j = -0.0 - j
+ }
+ g[b + (f << 2) >> 2] = d * (j > h ? j : h) + e * (j < h ? j : h);
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ return
+ }
+
+ function Bb(a, b, d, e, f, h) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = +f;
+ h = h | 0;
+ var j = 0,
+ k = 0,
+ l = 0,
+ m = 0,
+ n = 0.0;
+ j = i;
+ m = h;
+ h = i;
+ i = i + 8 | 0;
+ c[h >> 2] = c[m >> 2];
+ c[h + 4 >> 2] = c[m + 4 >> 2];
+ f = f == 0.0 ? .9990000128746033 : f;
+ k = h | 0;
+ l = h + 4 | 0;
+ n = +g[b >> 2] - +g[k >> 2] + f * +g[l >> 2];
+ g[d >> 2] = n;
+ if ((e | 0) > 1) {
+ m = 1;
+ do {
+ n = +g[b + (m << 2) >> 2] - +g[b + (m - 1 << 2) >> 2] + f * n;
+ g[d + (m << 2) >> 2] = n;
+ m = m + 1 | 0;
+ } while ((m | 0) < (e | 0))
+ }
+ m = e - 1 | 0;
+ g[k >> 2] = +g[b + (m << 2) >> 2];
+ g[l >> 2] = +g[d + (m << 2) >> 2];
+ k = h;
+ m = a;
+ l = c[k + 4 >> 2] | 0;
+ c[m >> 2] = c[k >> 2];
+ c[m + 4 >> 2] = l;
+ i = j;
+ return
+ }
+
+ function Cb(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ var e = 0.0,
+ f = 0,
+ h = 0.0,
+ i = 0.0,
+ j = 0;
+ f = (c | 0) > 0;
+ if (f) {
+ j = 0;
+ h = 0.0
+ } else {
+ i = 0.0 / +(c | 0);
+ return +i
+ }
+ do {
+ h = h + +g[a + (j << 2) >> 2];
+ j = j + 1 | 0;
+ } while ((j | 0) < (c | 0));
+ e = +(c | 0);
+ h = h / e;
+ i = h - d;
+ if (f) {
+ f = 0
+ } else {
+ i = h;
+ return +i
+ }
+ do {
+ g[b + (f << 2) >> 2] = +g[a + (f << 2) >> 2] - (i * (+(f | 0) / e) + d);
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ return +h
+ }
+
+ function Db(a, b) {
+ a = a | 0;
+ b = b | 0;
+ var d = 0,
+ e = 0,
+ f = 0.0,
+ h = 0,
+ i = 0,
+ j = 0,
+ k = 0.0,
+ l = 0,
+ m = 0.0,
+ n = 0,
+ o = 0.0;
+ d = a + 20 | 0;
+ e = c[d >> 2] | 0;
+ j = (e | 0) > 0;
+ if (j) {
+ h = c[a + 8 >> 2] | 0;
+ i = 0;
+ f = 0.0;
+ do {
+ k = +M(+(+g[h + (i << 2) >> 2]));
+ f = k > f ? k : f;
+ i = i + 1 | 0;
+ } while ((i | 0) < (e | 0))
+ } else {
+ f = 0.0
+ }
+ i = a + 16 | 0;
+ m = +g[i >> 2];
+ o = f < m ? m : f;
+ h = a + 12 | 0;
+ k = +g[h >> 2];
+ k = +g[a + 24 >> 2] / (o < k ? k : o);
+ k = k > 65.0e3 ? 65.0e3 : k;
+ if (j) {
+ j = a + 28 | 0;
+ l = a | 0;
+ n = 0;
+ do {
+ o = +(n | 0) / +(e | 0);
+ g[b + (n << 2) >> 2] = +g[(c[l >> 2] | 0) + (n << 2) >> 2] * (k * o + +g[j >> 2] * (1.0 - o));
+ n = n + 1 | 0;
+ e = c[d >> 2] | 0;
+ } while ((n | 0) < (e | 0));
+ m = +g[i >> 2]
+ } else {
+ l = a | 0;
+ j = a + 28 | 0
+ }
+ e = c[l >> 2] | 0;
+ b = a + 4 | 0;
+ c[l >> 2] = c[b >> 2];
+ g[h >> 2] = m;
+ n = a + 8 | 0;
+ c[b >> 2] = c[n >> 2];
+ g[i >> 2] = f;
+ c[n >> 2] = e;
+ g[j >> 2] = k;
+ return
+ }
+
+ function Eb(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ var e = 0.0,
+ f = 0,
+ h = 0;
+ if ((c | 0) > 0) {
+ f = 0
+ } else {
+ return +d
+ }
+ while (1) {
+ h = a + (f << 3) | 0;
+ e = +V(+(+g[h + 4 >> 2]), +(+g[h >> 2]));
+ d = e - d;
+ if (d < -3.1415927410125732) {
+ d = d + 6.2831854820251465
+ }
+ if (d > 3.1415927410125732) {
+ d = d + -6.2831854820251465
+ }
+ g[b + (f << 2) >> 2] = d / 3.1415927410125732;
+ f = f + 1 | 0;
+ if ((f | 0) < (c | 0)) {
+ d = e
+ } else {
+ break
+ }
+ }
+ return +e
+ }
+
+ function Fb(a, b, d, e, f) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = f | 0;
+ var h = 0,
+ j = 0,
+ k = 0.0,
+ l = 0.0,
+ m = 0,
+ n = 0;
+ h = i;
+ m = f;
+ j = i;
+ i = i + 8 | 0;
+ c[j >> 2] = c[m >> 2];
+ c[j + 4 >> 2] = c[m + 4 >> 2];
+ f = b | 0;
+ l = +g[f >> 2];
+ k = +g[f + 4 >> 2];
+ g[d >> 2] = (l * (k - +g[j + 4 >> 2]) - k * (l - +g[j >> 2])) * .340447550238101 / (l * l + k * k);
+ if ((e | 0) > 1) {
+ j = 1;
+ do {
+ n = b + (j << 3) | 0;
+ k = +g[n + 4 >> 2];
+ m = j << 1;
+ l = +g[n >> 2];
+ g[d + (j << 2) >> 2] = (l * (k - +g[f + (m - 1 << 2) >> 2]) - k * (l - +g[f + (m - 2 << 2) >> 2])) * .340447550238101 / (k * k + l * l);
+ j = j + 1 | 0;
+ } while ((j | 0) < (e | 0))
+ }
+ j = b + (e - 1 << 3) | 0;
+ n = a;
+ m = c[j + 4 >> 2] | 0;
+ c[n >> 2] = c[j >> 2];
+ c[n + 4 >> 2] = m;
+ i = h;
+ return
+ }
+
+ function Gb(a, b, d, e, f, h) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = f | 0;
+ h = h | 0;
+ var j = 0,
+ k = 0,
+ l = 0,
+ m = 0,
+ n = 0,
+ o = 0.0,
+ p = 0.0;
+ j = i;
+ m = h;
+ h = i;
+ i = i + 8 | 0;
+ c[h >> 2] = c[m >> 2];
+ c[h + 4 >> 2] = c[m + 4 >> 2];
+ m = f + (e << 2) | 0;
+ k = b | 0;
+ g[f >> 2] = +g[k + 4 >> 2] - +g[h + 4 >> 2];
+ l = (e | 0) > 1;
+ do {
+ if (l) {
+ n = 1;
+ do {
+ g[f + (n << 2) >> 2] = +g[b + (n << 3) + 4 >> 2] - +g[k + ((n << 1) - 1 << 2) >> 2];
+ n = n + 1 | 0;
+ } while ((n | 0) < (e | 0));
+ g[m >> 2] = +g[k >> 2] - +g[h >> 2];
+ if (l) {
+ l = 1
+ } else {
+ break
+ }
+ do {
+ g[f + (l + e << 2) >> 2] = +g[b + (l << 3) >> 2] - +g[k + ((l << 1) - 2 << 2) >> 2];
+ l = l + 1 | 0;
+ } while ((l | 0) < (e | 0))
+ } else {
+ g[m >> 2] = +g[k >> 2] - +g[h >> 2]
+ }
+ } while (0);
+ k = (e | 0) > 0;
+ do {
+ if (k) {
+ l = 0;
+ do {
+ n = b + (l << 3) | 0;
+ g[d + (l << 2) >> 2] = +g[n >> 2] * +g[f + (l << 2) >> 2] - +g[n + 4 >> 2] * +g[f + (l + e << 2) >> 2];
+ l = l + 1 | 0;
+ } while ((l | 0) < (e | 0));
+ if (k) {
+ l = 0
+ } else {
+ break
+ }
+ do {
+ n = b + (l << 3) | 0;
+ p = +g[n >> 2];
+ o = +g[n + 4 >> 2];
+ g[f + (l << 2) >> 2] = p * p + o * o;
+ l = l + 1 | 0;
+ } while ((l | 0) < (e | 0));
+ if (k) {
+ k = 0
+ } else {
+ break
+ }
+ do {
+ n = d + (k << 2) | 0;
+ g[n >> 2] = +g[n >> 2] * .340447550238101 / +g[f + (k << 2) >> 2];
+ k = k + 1 | 0;
+ } while ((k | 0) < (e | 0))
+ }
+ } while (0);
+ m = b + (e - 1 << 3) | 0;
+ n = a;
+ h = c[m + 4 >> 2] | 0;
+ c[n >> 2] = c[m >> 2];
+ c[n + 4 >> 2] = h;
+ i = j;
+ return
+ }
+
+ function Hb(a, b, d, e, f, h) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = +e;
+ f = f | 0;
+ h = +h;
+ var i = 0.0;
+ i = 1.0 / +(f | 0);
+ e = i / (i + e);
+ f = (g[k >> 2] = h, c[k >> 2] | 0);
+ if ((f & 2139095040 | 0) == 2139095040) {
+ i = (f & 8388607 | 0) != 0 ? 0.0 : h
+ } else {
+ i = h
+ }
+ h = 1.0 - e;
+ i = h * i + e * +g[a >> 2];
+ g[b >> 2] = i;
+ if ((d | 0) > 1) {
+ f = 1
+ } else {
+ f = d - 1 | 0;
+ f = b + (f << 2) | 0;
+ i = +g[f >> 2];
+ return +i
+ }
+ do {
+ i = e * +g[a + (f << 2) >> 2] + h * i;
+ g[b + (f << 2) >> 2] = i;
+ f = f + 1 | 0;
+ } while ((f | 0) < (d | 0));
+ f = d - 1 | 0;
+ f = b + (f << 2) | 0;
+ i = +g[f >> 2];
+ return +i
+ }
+
+ function Ib(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = d | 0;
+ var e = 0,
+ f = 0,
+ h = 0,
+ i = 0,
+ j = 0.0;
+ f = (d | 0) == 44100;
+ i = (d | 0) == 8e3;
+ h = (d | 0) == 11025;
+ e = h ? 1776 : i ? 144 : f ? 1280 : 472;
+ d = h ? 81 : i ? 81 : f ? 123 : (d | 0) == 48e3 ? 201 : 0;
+ if ((d | 0) == 0) {
+ i = 0;
+ return i | 0
+ }
+ c = c - d | 0;
+ if ((c | 0) > 0) {
+ f = 0
+ } else {
+ i = 0;
+ return i | 0
+ }
+ do {
+ j = 0.0;
+ h = 0;
+ do {
+ j = j + +g[e + (h << 2) >> 2] * +g[a + (h + f << 2) >> 2];
+ h = h + 1 | 0;
+ } while ((h | 0) < (d | 0));
+ g[b + (f << 2) >> 2] = j;
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ return c | 0
+ }
+
+ function Jb(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ var e = 0.0,
+ f = 0,
+ h = 0.0;
+ if ((c | 0) <= 0) {
+ return
+ }
+ e = -0.0 - d;
+ f = 0;
+ do {
+ h = +g[a + (f << 2) >> 2];
+ h = h > d ? d : h;
+ g[b + (f << 2) >> 2] = h < e ? e : h;
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ return
+ }
+
+ function Kb(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ var e = 0;
+ if ((c | 0) > 0) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ g[b + (e << 2) >> 2] = +g[a + (e << 2) >> 2] * d;
+ e = e + 1 | 0;
+ } while ((e | 0) < (c | 0));
+ return
+ }
+
+ function Lb(a) {
+ a = a | 0;
+ var b = 0,
+ c = 0;
+ c = -1;
+ b = 0;
+ while (1) {
+ if ((1 << b & a | 0) != 0) {
+ if ((c | 0) == -1) {
+ c = b
+ } else {
+ c = -1;
+ a = 5;
+ break
+ }
+ }
+ b = b + 1 | 0;
+ if ((b | 0) >= 31) {
+ a = 5;
+ break
+ }
+ }
+ if ((a | 0) == 5) {
+ return c | 0
+ }
+ return 0
+ }
+
+ function Mb(a) {
+ a = a | 0;
+ var b = 0,
+ c = 0;
+ c = 0;
+ while (1) {
+ b = 1 << c;
+ c = c + 1 | 0;
+ if ((b | 0) > (a | 0)) {
+ break
+ }
+ if ((c | 0) >= 31) {
+ b = -1;
+ break
+ }
+ }
+ return b | 0
+ }
+
+ function Nb(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = d | 0;
+ var e = 0.0,
+ f = 0,
+ h = 0,
+ i = 0.0,
+ j = 0.0,
+ k = 0;
+ if ((d | 0) == 1) {
+ d = 6
+ } else if ((d | 0) == 0) {
+ d = 2
+ } else {
+ d = 4
+ }
+ if ((c | 0) <= 0) {
+ return
+ }
+ e = +(c - 1 | 0);
+ f = 0;
+ do {
+ k = a + (f << 3) | 0;
+ j = +g[k >> 2];
+ i = +(f | 0) / e * 2.0 + 1.0;
+ h = b + (f << 3) | 0;
+ g[h >> 2] = j * +Pa[d & 7](i);
+ j = +g[k + 4 >> 2];
+ g[h + 4 >> 2] = j * +Pa[d & 7](i);
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ return
+ }
+
+ function Ob(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = d | 0;
+ var e = 0.0,
+ f = 0,
+ h = 0.0;
+ if ((d | 0) == 1) {
+ d = 6
+ } else if ((d | 0) == 0) {
+ d = 2
+ } else {
+ d = 4
+ }
+ if ((c | 0) <= 0) {
+ return
+ }
+ e = +(c - 1 | 0);
+ f = 0;
+ do {
+ h = +g[a + (f << 2) >> 2];
+ g[b + (f << 2) >> 2] = h * +Pa[d & 7](+(f | 0) / e * 2.0 + 1.0);
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ return
+ }
+
+ function Pb(a, b, c, d) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ var e = 0,
+ f = 0,
+ h = 0.0,
+ i = 0.0,
+ j = 0;
+ e = (c | 0) > 0;
+ if (e) {
+ f = 0
+ } else {
+ return
+ }
+ do {
+ j = a + (f << 3) | 0;
+ i = +g[j >> 2];
+ h = +g[j + 4 >> 2];
+ g[b + (f << 2) >> 2] = i * i + h * h;
+ f = f + 1 | 0;
+ } while ((f | 0) < (c | 0));
+ if (e) {
+ a = 0
+ } else {
+ return
+ }
+ do {
+ j = b + (a << 2) | 0;
+ g[j >> 2] = +za(+(+g[j >> 2]));
+ a = a + 1 | 0;
+ } while ((a | 0) < (c | 0));
+ if (e) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ j = b + (e << 2) | 0;
+ g[j >> 2] = +g[j >> 2] * 10.0 + d;
+ e = e + 1 | 0;
+ } while ((e | 0) < (c | 0));
+ return
+ }
+
+ function Qb(a, b, c) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ var e = 0;
+ if ((c | 0) > 0) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ g[b + (e << 2) >> 2] = +((d[a + e | 0] | 0) >>> 0) / 127.5 + -1.0;
+ e = e + 1 | 0;
+ } while ((e | 0) < (c | 0));
+ return
+ }
+
+ function Rb(a, c, d) {
+ a = a | 0;
+ c = c | 0;
+ d = d | 0;
+ var e = 0;
+ if ((d | 0) > 0) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ g[c + (e << 2) >> 2] = +(b[a + (e << 1) >> 1] | 0) / 32767.0;
+ e = e + 1 | 0;
+ } while ((e | 0) < (d | 0));
+ return
+ }
+
+ function Sb(b, c, d) {
+ b = b | 0;
+ c = c | 0;
+ d = d | 0;
+ var e = 0;
+ if ((d | 0) > 0) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ a[c + e | 0] = ~~(+g[b + (e << 2) >> 2] * 255.0 * .5 + 128.0);
+ e = e + 1 | 0;
+ } while ((e | 0) < (d | 0));
+ return
+ }
+
+ function Tb(a, c, d) {
+ a = a | 0;
+ c = c | 0;
+ d = d | 0;
+ var e = 0;
+ if ((d | 0) > 0) {
+ e = 0
+ } else {
+ return
+ }
+ do {
+ b[c + (e << 1) >> 1] = ~~(+g[a + (e << 2) >> 2] * 32767.0);
+ e = e + 1 | 0;
+ } while ((e | 0) < (d | 0));
+ return
+ }
+
+ function Ub(a, b, d, e, f) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = +f;
+ var h = 0,
+ j = 0.0,
+ k = 0.0,
+ l = 0.0,
+ m = 0.0,
+ n = 0.0,
+ o = 0,
+ p = 0,
+ q = 0,
+ r = 0;
+ h = i;
+ o = e;
+ e = i;
+ i = i + 12 | 0;
+ i = i + 7 & -8;
+ c[e >> 2] = c[o >> 2];
+ c[e + 4 >> 2] = c[o + 4 >> 2];
+ c[e + 8 >> 2] = c[o + 8 >> 2];
+ j = f;
+ if ((d | 0) > 0) {
+ m = +Q(j);
+ n = +P(j);
+ k = +g[e + 4 >> 2];
+ l = +g[e >> 2];
+ o = 0;
+ while (1) {
+ r = a + (o << 3) | 0;
+ q = r + 4 | 0;
+ p = b + (o << 3) | 0;
+ g[p >> 2] = n * +g[r >> 2] - m * +g[q >> 2];
+ g[p + 4 >> 2] = m * +g[r >> 2] + n * +g[q >> 2];
+ j = n * k - m * l;
+ o = o + 1 | 0;
+ if ((o | 0) < (d | 0)) {
+ m = m * k + n * l;
+ n = j
+ } else {
+ break
+ }
+ }
+ }
+ f = +(d | 0) * +g[e + 8 >> 2] * 3.1415927410125732 + f;
+ if (f > 3.1415927410125732) {
+ do {
+ f = f + -6.2831854820251465;
+ } while (f > 3.1415927410125732)
+ }
+ if (f >= -3.1415927410125732) {
+ n = f;
+ i = h;
+ return +n
+ }
+ do {
+ f = f + 6.2831854820251465;
+ } while (f < -3.1415927410125732);
+ i = h;
+ return +f
+ }
+
+ function Vb(a, b) {
+ a = a | 0;
+ b = +b;
+ var c = 0.0,
+ d = 0.0;
+ b = b * 2.0;
+ d = b * 3.1415927410125732;
+ c = +P(d);
+ g[a >> 2] = +Q(d);
+ g[a + 4 >> 2] = c;
+ g[a + 8 >> 2] = b;
+ return
+ }
+
+ function Wb(a) {
+ a = a | 0;
+ var b = 0,
+ d = 0.0,
+ e = 0.0,
+ f = 0.0,
+ j = 0.0,
+ k = 0.0,
+ l = 0,
+ m = 0.0,
+ n = 0.0,
+ o = 0.0,
+ p = 0,
+ q = 0.0,
+ r = 0;
+ b = i;
+ l = a;
+ p = i;
+ i = i + 12 | 0;
+ i = i + 7 & -8;
+ c[p >> 2] = c[l >> 2];
+ c[p + 4 >> 2] = c[l + 4 >> 2];
+ c[p + 8 >> 2] = c[l + 8 >> 2];
+ e = +g[p + 8 >> 2];
+ a = ~~(2.0 / e + 1.0);
+ oa(2112, (l = i, i = i + 1 | 0, i = i + 7 & -8, c[l >> 2] = 0, l) | 0) | 0;
+ i = l;
+ j = +g[p + 4 >> 2];
+ f = +g[p >> 2];
+ e = e * 3.1415927410125732;
+ d = +(a | 0);
+ m = 0.0;
+ q = 1.0;
+ n = 0.0;
+ p = 0;
+ o = 0.0;
+ l = 0;
+ while (1) {
+ k = q * j - m * f;
+ m = m * j + q * f;
+ n = n + e;
+ if (n > 6.2831854820251465) {
+ do {
+ n = n + -6.2831854820251465;
+ } while (n > 6.2831854820251465)
+ }
+ r = ((l >>> 0) % 1e4 | 0 | 0) == 0;
+ p = r ? a : p;
+ o = r ? 0.0 : o;
+ do {
+ if ((p | 0) == 0) {
+ p = 0
+ } else {
+ o = o + +M(+(k - +P(n)));
+ p = p - 1 | 0;
+ if ((p | 0) != 0) {
+ break
+ }
+ oa(2104, (p = i, i = i + 8 | 0, h[p >> 3] = o / d, p) | 0) | 0;
+ i = p;
+ p = 0
+ }
+ } while (0);
+ l = l + 1 | 0;
+ if (l >>> 0 < 5e5 >>> 0) {
+ q = k
+ } else {
+ break
+ }
+ }
+ Fa(8) | 0;
+ i = b;
+ return
+ }
+
+ function Xb(a, b, c) {
+ a = a | 0;
+ b = +b;
+ c = c | 0;
+ var d = 0.0,
+ e = 0.0;
+ b = +(c | 0) * b * 2.0;
+ e = b * 3.1415927410125732;
+ d = +P(e);
+ g[a >> 2] = +Q(e);
+ g[a + 4 >> 2] = d;
+ g[a + 8 >> 2] = b;
+ return
+ }
+
+ function Yb(a, b, d, e, f, h, j) {
+ a = a | 0;
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ f = f | 0;
+ h = h | 0;
+ j = j | 0;
+ var k = 0,
+ l = 0,
+ m = 0,
+ n = 0.0,
+ o = 0.0,
+ p = 0.0,
+ q = 0.0,
+ r = 0.0,
+ s = 0,
+ t = 0,
+ u = 0.0,
+ v = 0,
+ w = 0,
+ x = 0;
+ l = i;
+ k = f;
+ f = i;
+ i = i + 12 | 0;
+ i = i + 7 & -8;
+ c[f >> 2] = c[k >> 2];
+ c[f + 4 >> 2] = c[k + 4 >> 2];
+ c[f + 8 >> 2] = c[k + 8 >> 2];
+ k = j;
+ j = i;
+ i = i + 12 | 0;
+ i = i + 7 & -8;
+ c[j >> 2] = c[k >> 2];
+ c[j + 4 >> 2] = c[k + 4 >> 2];
+ c[j + 8 >> 2] = c[k + 8 >> 2];
+ k = j + 4 | 0;
+ n = +g[k >> 2];
+ o = n;
+ m = j | 0;
+ t = c[m >> 2] | 0;
+ if ((t | 0) < (e | 0)) {
+ p = +Q(o);
+ o = +P(o);
+ q = +g[f + 4 >> 2];
+ r = +g[f >> 2];
+ s = 0;
+ while (1) {
+ x = b + (t << 3) | 0;
+ w = x + 4 | 0;
+ v = d + (s << 3) | 0;
+ g[v >> 2] = o * +g[x >> 2] - p * +g[w >> 2];
+ g[v + 4 >> 2] = p * +g[x >> 2] + o * +g[w >> 2];
+ s = s + 1 | 0;
+ u = o * q - p * r;
+ t = t + h | 0;
+ if ((t | 0) < (e | 0)) {
+ p = p * q + o * r;
+ o = u
+ } else {
+ break
+ }
+ }
+ } else {
+ s = 0
+ }
+ c[m >> 2] = t - e;
+ n = n + +(s | 0) * +g[f + 8 >> 2] * 3.1415927410125732;
+ g[k >> 2] = n;
+ c[j + 8 >> 2] = s;
+ if (n > 3.1415927410125732) {
+ do {
+ n = n + -6.2831854820251465;
+ } while (n > 3.1415927410125732);
+ g[k >> 2] = n
+ }
+ if (n >= -3.1415927410125732) {
+ x = a;
+ w = j;
+ c[x >> 2] = c[w >> 2];
+ c[x + 4 >> 2] = c[w + 4 >> 2];
+ c[x + 8 >> 2] = c[w + 8 >> 2];
+ i = l;
+ return
+ }
+ do {
+ n = n + 6.2831854820251465;
+ } while (n < -3.1415927410125732);
+ g[k >> 2] = n;
+ x = a;
+ w = j;
+ c[x >> 2] = c[w >> 2];
+ c[x + 4 >> 2] = c[w + 4 >> 2];
+ c[x + 8 >> 2] = c[w + 8 >> 2];
+ i = l;
+ return
+ }
+
+ function Zb(a, b, c, d, e, f, h, i, j, k, l) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ d = +d;
+ e = +e;
+ f = +f;
+ h = +h;
+ i = i | 0;
+ j = j | 0;
+ k = +k;
+ l = +l;
+ var m = 0.0,
+ n = 0,
+ o = 0,
+ p = 0.0,
+ q = 0,
+ r = 0.0,
+ s = 0,
+ t = 0.0;
+ g[b >> 2] = +g[a >> 2] * l;
+ if ((c | 0) <= 1) {
+ t = l;
+ return +t
+ }
+ o = 0;
+ m = l;
+ p = d / l;
+ q = 0;
+ n = 1;
+ while (1) {
+ l = +g[a + (n << 2) >> 2];
+ t = +M(+l);
+ r = d / t - m;
+ do {
+ if (l != 0.0) {
+ do {
+ if (r < 0.0) {
+ s = p < t;
+ o = s ? j : o;
+ p = s ? t : p;
+ if (o << 16 >> 16 > 0) {
+ r = 0.0;
+ o = o - 1 & 65535;
+ break
+ } else {
+ r = r * e;
+ q = i;
+ break
+ }
+ } else {
+ if (q << 16 >> 16 > 0) {
+ r = 0.0;
+ q = q - 1 & 65535;
+ break
+ } else {
+ r = r * f;
+ break
+ }
+ }
+ } while (0);
+ r = m + r;
+ r = r > h ? h : r;
+ if (r >= 0.0) {
+ break
+ }
+ r = 0.0
+ } else {
+ r = m
+ }
+ } while (0);
+ g[b + (n << 2) >> 2] = (m + r - m * k) * l;
+ n = n + 1 | 0;
+ if ((n | 0) < (c | 0)) {
+ m = r
+ } else {
+ break
+ }
+ }
+ return +r
+ }
+
+ function _b(d, e, f, g, h) {
+ d = d | 0;
+ e = e | 0;
+ f = f | 0;
+ g = g | 0;
+ h = h | 0;
+ var j = 0,
+ k = 0,
+ l = 0,
+ m = 0,
+ n = 0,
+ o = 0,
+ p = 0,
+ q = 0,
+ r = 0,
+ s = 0,
+ t = 0,
+ u = 0,
+ v = 0;
+ j = i;
+ k = h;
+ h = i;
+ i = i + 8 | 0;
+ c[h >> 2] = c[k >> 2];
+ c[h + 4 >> 2] = c[k + 4 >> 2];
+ k = (g | 0) / 2 | 0;
+ if ((g | 0) <= 1) {
+ u = h;
+ v = d;
+ s = u | 0;
+ s = c[s >> 2] | 0;
+ u = u + 4 | 0;
+ u = c[u >> 2] | 0;
+ t = v | 0;
+ c[t >> 2] = s;
+ v = v + 4 | 0;
+ c[v >> 2] = u;
+ i = j;
+ return
+ }
+ g = h + 4 | 0;
+ l = h | 0;
+ m = 0;
+ p = c[g >> 2] | 0;
+ o = c[l >> 2] | 0;
+ while (1) {
+ q = m << 1;
+ n = (b[e + (q << 1) >> 1] | 0) - p | 0;
+ r = c[2168 + (o << 2) >> 2] | 0;
+ s = (n | 0) < 0 ? -n | 0 : n;
+ n = n >> 31 & 8;
+ if ((s | 0) < (r | 0)) {
+ t = s
+ } else {
+ n = n | 4;
+ t = s - r | 0
+ }
+ s = r >> 1;
+ if ((t | 0) >= (s | 0)) {
+ n = n | 2;
+ t = t - s | 0
+ }
+ u = r >> 2;
+ if ((t | 0) < (u | 0)) {
+ n = n & 255
+ } else {
+ n = (n | 1) & 255
+ }
+ t = n & 255;
+ r = (r >> 3) + ((t & 1 | 0) == 0 ? 0 : u) + ((t & 2 | 0) == 0 ? 0 : s) + ((t & 4 | 0) == 0 ? 0 : r) | 0;
+ p = ((t & 8 | 0) == 0 ? r : -r | 0) + p | 0;
+ if ((p | 0) > 32767) {
+ p = 32767
+ } else {
+ p = (p | 0) < -32768 ? -32768 : p
+ }
+ o = (c[80 + (t << 2) >> 2] | 0) + o | 0;
+ if ((o | 0) < 0) {
+ r = 0
+ } else {
+ r = (o | 0) > 88 ? 88 : o
+ }
+ o = f + m | 0;
+ a[o] = n;
+ s = (b[e + ((q | 1) << 1) >> 1] | 0) - p | 0;
+ q = c[2168 + (r << 2) >> 2] | 0;
+ u = (s | 0) < 0 ? -s | 0 : s;
+ s = s >> 31 & 8;
+ if ((u | 0) >= (q | 0)) {
+ s = s | 4;
+ u = u - q | 0
+ }
+ t = q >> 1;
+ if ((u | 0) >= (t | 0)) {
+ s = s | 2;
+ u = u - t | 0
+ }
+ v = q >> 2;
+ if ((u | 0) < (v | 0)) {
+ s = s & 255
+ } else {
+ s = (s | 1) & 255
+ }
+ u = s & 255;
+ q = (q >> 3) + ((u & 1 | 0) == 0 ? 0 : v) + ((u & 2 | 0) == 0 ? 0 : t) + ((u & 4 | 0) == 0 ? 0 : q) | 0;
+ p = ((u & 8 | 0) == 0 ? q : -q | 0) + p | 0;
+ if ((p | 0) > 32767) {
+ p = 32767
+ } else {
+ p = (p | 0) < -32768 ? -32768 : p
+ }
+ q = (c[80 + (u << 2) >> 2] | 0) + r | 0;
+ if ((q | 0) < 0) {
+ q = 0
+ } else {
+ q = (q | 0) > 88 ? 88 : q
+ }
+ m = m + 1 | 0;
+ a[o] = n | s << 4;
+ if ((m | 0) < (k | 0)) {
+ o = q
+ } else {
+ break
+ }
+ }
+ c[g >> 2] = p;
+ c[l >> 2] = q;
+ u = h;
+ v = d;
+ s = u | 0;
+ s = c[s >> 2] | 0;
+ u = u + 4 | 0;
+ u = c[u >> 2] | 0;
+ t = v | 0;
+ c[t >> 2] = s;
+ v = v + 4 | 0;
+ c[v >> 2] = u;
+ i = j;
+ return
+ }
+
+ function $b(e, f, g, h, j) {
+ e = e | 0;
+ f = f | 0;
+ g = g | 0;
+ h = h | 0;
+ j = j | 0;
+ var k = 0,
+ l = 0,
+ m = 0,
+ n = 0,
+ o = 0,
+ p = 0,
+ q = 0,
+ r = 0,
+ s = 0,
+ t = 0,
+ u = 0;
+ n = i;
+ u = j;
+ j = i;
+ i = i + 8 | 0;
+ c[j >> 2] = c[u >> 2];
+ c[j + 4 >> 2] = c[u + 4 >> 2];
+ if ((h | 0) <= 0) {
+ t = j;
+ u = e;
+ r = t | 0;
+ r = c[r >> 2] | 0;
+ t = t + 4 | 0;
+ t = c[t >> 2] | 0;
+ s = u | 0;
+ c[s >> 2] = r;
+ u = u + 4 | 0;
+ c[u >> 2] = t;
+ i = n;
+ return
+ }
+ k = j | 0;
+ l = j + 4 | 0;
+ m = 0;
+ o = 0;
+ q = c[k >> 2] | 0;
+ r = c[l >> 2] | 0;
+ while (1) {
+ p = f + o | 0;
+ t = c[2168 + (q << 2) >> 2] | 0;
+ u = t >> 3;
+ s = a[p] & 15;
+ if ((s & 1 | 0) != 0) {
+ u = u + (t >> 2) | 0
+ }
+ if ((s & 2 | 0) != 0) {
+ u = u + (t >> 1) | 0
+ }
+ t = u + ((s & 4 | 0) == 0 ? 0 : t) | 0;
+ u = ((s & 8 | 0) == 0 ? t : -t | 0) + r | 0;
+ if ((u | 0) > 32767) {
+ t = 32767;
+ r = 32767
+ } else {
+ r = (u | 0) < -32768;
+ t = r ? -32768 : u & 65535;
+ r = r ? -32768 : u
+ }
+ q = (c[80 + (s << 2) >> 2] | 0) + q | 0;
+ if ((q | 0) < 0) {
+ q = 0
+ } else {
+ q = (q | 0) > 88 ? 88 : q
+ }
+ b[g + (m << 1) >> 1] = t;
+ s = c[2168 + (q << 2) >> 2] | 0;
+ t = s >> 3;
+ p = (d[p] | 0) >>> 4 & 255;
+ if ((p & 1 | 0) != 0) {
+ t = t + (s >> 2) | 0
+ }
+ if ((p & 2 | 0) != 0) {
+ t = t + (s >> 1) | 0
+ }
+ s = t + ((p & 4 | 0) == 0 ? 0 : s) | 0;
+ r = ((p & 8 | 0) == 0 ? s : -s | 0) + r | 0;
+ if ((r | 0) > 32767) {
+ s = 32767;
+ r = 32767
+ } else {
+ t = (r | 0) < -32768;
+ s = t ? -32768 : r & 65535;
+ r = t ? -32768 : r
+ }
+ p = (c[80 + (p << 2) >> 2] | 0) + q | 0;
+ if ((p | 0) < 0) {
+ q = 0
+ } else {
+ q = (p | 0) > 88 ? 88 : p
+ }
+ b[g + ((m | 1) << 1) >> 1] = s;
+ o = o + 1 | 0;
+ if ((o | 0) < (h | 0)) {
+ m = m + 2 | 0
+ } else {
+ break
+ }
+ }
+ c[k >> 2] = q;
+ c[l >> 2] = r;
+ t = j;
+ u = e;
+ r = t | 0;
+ r = c[r >> 2] | 0;
+ t = t + 4 | 0;
+ t = c[t >> 2] | 0;
+ s = u | 0;
+ c[s >> 2] = r;
+ u = u + 4 | 0;
+ c[u >> 2] = t;
+ i = n;
+ return
+ }
+
+ function ac(a) {
+ a = a | 0;
+ var b = 0,
+ d = 0;
+ b = i;
+ d = c[a >> 2] | 0;
+ Na[c[c[d >> 2] >> 2] & 1](d, c[a + 4 >> 2] | 0);
+ i = b;
+ return
+ }
+
+ function bc(a) {
+ a = a | 0;
+ var b = 0,
+ d = 0,
+ e = 0,
+ f = 0,
+ g = 0,
+ h = 0,
+ i = 0,
+ j = 0,
+ k = 0,
+ l = 0,
+ m = 0,
+ n = 0,
+ o = 0,
+ p = 0,
+ q = 0;
+ do {
+ if (a >>> 0 < 245 >>> 0) {
+ if (a >>> 0 < 11 >>> 0) {
+ a = 16
+ } else {
+ a = a + 11 & -8
+ }
+ f = a >>> 3;
+ e = c[638] | 0;
+ b = e >>> (f >>> 0);
+ if ((b & 3 | 0) != 0) {
+ h = (b & 1 ^ 1) + f | 0;
+ a = h << 1;
+ d = 2592 + (a << 2) | 0;
+ a = 2592 + (a + 2 << 2) | 0;
+ g = c[a >> 2] | 0;
+ f = g + 8 | 0;
+ b = c[f >> 2] | 0;
+ do {
+ if ((d | 0) == (b | 0)) {
+ c[638] = e & ~(1 << h)
+ } else {
+ if (b >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ e = b + 12 | 0;
+ if ((c[e >> 2] | 0) == (g | 0)) {
+ c[e >> 2] = d;
+ c[a >> 2] = b;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ q = h << 3;
+ c[g + 4 >> 2] = q | 3;
+ q = g + (q | 4) | 0;
+ c[q >> 2] = c[q >> 2] | 1;
+ q = f;
+ return q | 0
+ }
+ if (a >>> 0 <= (c[640] | 0) >>> 0) {
+ break
+ }
+ if ((b | 0) != 0) {
+ i = 2 << f;
+ i = b << f & (i | -i);
+ i = (i & -i) - 1 | 0;
+ b = i >>> 12 & 16;
+ i = i >>> (b >>> 0);
+ h = i >>> 5 & 8;
+ i = i >>> (h >>> 0);
+ f = i >>> 2 & 4;
+ i = i >>> (f >>> 0);
+ g = i >>> 1 & 2;
+ i = i >>> (g >>> 0);
+ d = i >>> 1 & 1;
+ d = (h | b | f | g | d) + (i >>> (d >>> 0)) | 0;
+ i = d << 1;
+ g = 2592 + (i << 2) | 0;
+ i = 2592 + (i + 2 << 2) | 0;
+ f = c[i >> 2] | 0;
+ b = f + 8 | 0;
+ h = c[b >> 2] | 0;
+ do {
+ if ((g | 0) == (h | 0)) {
+ c[638] = e & ~(1 << d)
+ } else {
+ if (h >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ e = h + 12 | 0;
+ if ((c[e >> 2] | 0) == (f | 0)) {
+ c[e >> 2] = g;
+ c[i >> 2] = h;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ q = d << 3;
+ d = q - a | 0;
+ c[f + 4 >> 2] = a | 3;
+ e = f + a | 0;
+ c[f + (a | 4) >> 2] = d | 1;
+ c[f + q >> 2] = d;
+ f = c[640] | 0;
+ if ((f | 0) != 0) {
+ a = c[643] | 0;
+ i = f >>> 3;
+ g = i << 1;
+ f = 2592 + (g << 2) | 0;
+ h = c[638] | 0;
+ i = 1 << i;
+ do {
+ if ((h & i | 0) == 0) {
+ c[638] = h | i;
+ h = f;
+ g = 2592 + (g + 2 << 2) | 0
+ } else {
+ g = 2592 + (g + 2 << 2) | 0;
+ h = c[g >> 2] | 0;
+ if (h >>> 0 >= (c[642] | 0) >>> 0) {
+ break
+ }
+ ma();
+ return 0
+ }
+ } while (0);
+ c[g >> 2] = a;
+ c[h + 12 >> 2] = a;
+ c[a + 8 >> 2] = h;
+ c[a + 12 >> 2] = f
+ }
+ c[640] = d;
+ c[643] = e;
+ q = b;
+ return q | 0
+ }
+ b = c[639] | 0;
+ if ((b | 0) == 0) {
+ break
+ }
+ e = (b & -b) - 1 | 0;
+ p = e >>> 12 & 16;
+ e = e >>> (p >>> 0);
+ o = e >>> 5 & 8;
+ e = e >>> (o >>> 0);
+ q = e >>> 2 & 4;
+ e = e >>> (q >>> 0);
+ b = e >>> 1 & 2;
+ e = e >>> (b >>> 0);
+ d = e >>> 1 & 1;
+ d = c[2856 + ((o | p | q | b | d) + (e >>> (d >>> 0)) << 2) >> 2] | 0;
+ e = d;
+ b = d;
+ d = (c[d + 4 >> 2] & -8) - a | 0;
+ while (1) {
+ h = c[e + 16 >> 2] | 0;
+ if ((h | 0) == 0) {
+ h = c[e + 20 >> 2] | 0;
+ if ((h | 0) == 0) {
+ break
+ }
+ }
+ g = (c[h + 4 >> 2] & -8) - a | 0;
+ f = g >>> 0 < d >>> 0;
+ e = h;
+ b = f ? h : b;
+ d = f ? g : d
+ }
+ f = b;
+ h = c[642] | 0;
+ if (f >>> 0 < h >>> 0) {
+ ma();
+ return 0
+ }
+ q = f + a | 0;
+ e = q;
+ if (f >>> 0 >= q >>> 0) {
+ ma();
+ return 0
+ }
+ g = c[b + 24 >> 2] | 0;
+ i = c[b + 12 >> 2] | 0;
+ do {
+ if ((i | 0) == (b | 0)) {
+ j = b + 20 | 0;
+ i = c[j >> 2] | 0;
+ if ((i | 0) == 0) {
+ j = b + 16 | 0;
+ i = c[j >> 2] | 0;
+ if ((i | 0) == 0) {
+ i = 0;
+ break
+ }
+ }
+ while (1) {
+ l = i + 20 | 0;
+ k = c[l >> 2] | 0;
+ if ((k | 0) != 0) {
+ i = k;
+ j = l;
+ continue
+ }
+ k = i + 16 | 0;
+ l = c[k >> 2] | 0;
+ if ((l | 0) == 0) {
+ break
+ } else {
+ i = l;
+ j = k
+ }
+ }
+ if (j >>> 0 < h >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[j >> 2] = 0;
+ break
+ }
+ } else {
+ j = c[b + 8 >> 2] | 0;
+ if (j >>> 0 < h >>> 0) {
+ ma();
+ return 0
+ }
+ h = j + 12 | 0;
+ if ((c[h >> 2] | 0) != (b | 0)) {
+ ma();
+ return 0
+ }
+ k = i + 8 | 0;
+ if ((c[k >> 2] | 0) == (b | 0)) {
+ c[h >> 2] = i;
+ c[k >> 2] = j;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ a: do {
+ if ((g | 0) != 0) {
+ j = b + 28 | 0;
+ h = 2856 + (c[j >> 2] << 2) | 0;
+ do {
+ if ((b | 0) == (c[h >> 2] | 0)) {
+ c[h >> 2] = i;
+ if ((i | 0) != 0) {
+ break
+ }
+ c[639] = c[639] & ~(1 << c[j >> 2]);
+ break a
+ } else {
+ if (g >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ h = g + 16 | 0;
+ if ((c[h >> 2] | 0) == (b | 0)) {
+ c[h >> 2] = i
+ } else {
+ c[g + 20 >> 2] = i
+ }
+ if ((i | 0) == 0) {
+ break a
+ }
+ }
+ } while (0);
+ if (i >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ c[i + 24 >> 2] = g;
+ g = c[b + 16 >> 2] | 0;
+ do {
+ if ((g | 0) != 0) {
+ if (g >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[i + 16 >> 2] = g;
+ c[g + 24 >> 2] = i;
+ break
+ }
+ }
+ } while (0);
+ g = c[b + 20 >> 2] | 0;
+ if ((g | 0) == 0) {
+ break
+ }
+ if (g >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[i + 20 >> 2] = g;
+ c[g + 24 >> 2] = i;
+ break
+ }
+ }
+ } while (0);
+ if (d >>> 0 < 16 >>> 0) {
+ q = d + a | 0;
+ c[b + 4 >> 2] = q | 3;
+ q = f + (q + 4) | 0;
+ c[q >> 2] = c[q >> 2] | 1
+ } else {
+ c[b + 4 >> 2] = a | 3;
+ c[f + (a | 4) >> 2] = d | 1;
+ c[f + (d + a) >> 2] = d;
+ f = c[640] | 0;
+ if ((f | 0) != 0) {
+ a = c[643] | 0;
+ h = f >>> 3;
+ g = h << 1;
+ f = 2592 + (g << 2) | 0;
+ i = c[638] | 0;
+ h = 1 << h;
+ do {
+ if ((i & h | 0) == 0) {
+ c[638] = i | h;
+ h = f;
+ g = 2592 + (g + 2 << 2) | 0
+ } else {
+ g = 2592 + (g + 2 << 2) | 0;
+ h = c[g >> 2] | 0;
+ if (h >>> 0 >= (c[642] | 0) >>> 0) {
+ break
+ }
+ ma();
+ return 0
+ }
+ } while (0);
+ c[g >> 2] = a;
+ c[h + 12 >> 2] = a;
+ c[a + 8 >> 2] = h;
+ c[a + 12 >> 2] = f
+ }
+ c[640] = d;
+ c[643] = e
+ }
+ q = b + 8 | 0;
+ return q | 0
+ } else {
+ if (a >>> 0 > 4294967231 >>> 0) {
+ a = -1;
+ break
+ }
+ b = a + 11 | 0;
+ a = b & -8;
+ f = c[639] | 0;
+ if ((f | 0) == 0) {
+ break
+ }
+ e = -a | 0;
+ b = b >>> 8;
+ do {
+ if ((b | 0) == 0) {
+ g = 0
+ } else {
+ if (a >>> 0 > 16777215 >>> 0) {
+ g = 31;
+ break
+ }
+ p = (b + 1048320 | 0) >>> 16 & 8;
+ q = b << p;
+ o = (q + 520192 | 0) >>> 16 & 4;
+ q = q << o;
+ g = (q + 245760 | 0) >>> 16 & 2;
+ g = 14 - (o | p | g) + (q << g >>> 15) | 0;
+ g = a >>> ((g + 7 | 0) >>> 0) & 1 | g << 1
+ }
+ } while (0);
+ h = c[2856 + (g << 2) >> 2] | 0;
+ b: do {
+ if ((h | 0) == 0) {
+ b = 0;
+ j = 0
+ } else {
+ if ((g | 0) == 31) {
+ i = 0
+ } else {
+ i = 25 - (g >>> 1) | 0
+ }
+ b = 0;
+ i = a << i;
+ j = 0;
+ while (1) {
+ l = c[h + 4 >> 2] & -8;
+ k = l - a | 0;
+ if (k >>> 0 < e >>> 0) {
+ if ((l | 0) == (a | 0)) {
+ b = h;
+ e = k;
+ j = h;
+ break b
+ } else {
+ b = h;
+ e = k
+ }
+ }
+ k = c[h + 20 >> 2] | 0;
+ h = c[h + 16 + (i >>> 31 << 2) >> 2] | 0;
+ j = (k | 0) == 0 | (k | 0) == (h | 0) ? j : k;
+ if ((h | 0) == 0) {
+ break
+ } else {
+ i = i << 1
+ }
+ }
+ }
+ } while (0);
+ if ((j | 0) == 0 & (b | 0) == 0) {
+ q = 2 << g;
+ f = f & (q | -q);
+ if ((f | 0) == 0) {
+ break
+ }
+ q = (f & -f) - 1 | 0;
+ n = q >>> 12 & 16;
+ q = q >>> (n >>> 0);
+ m = q >>> 5 & 8;
+ q = q >>> (m >>> 0);
+ o = q >>> 2 & 4;
+ q = q >>> (o >>> 0);
+ p = q >>> 1 & 2;
+ q = q >>> (p >>> 0);
+ j = q >>> 1 & 1;
+ j = c[2856 + ((m | n | o | p | j) + (q >>> (j >>> 0)) << 2) >> 2] | 0
+ }
+ if ((j | 0) != 0) {
+ while (1) {
+ g = (c[j + 4 >> 2] & -8) - a | 0;
+ f = g >>> 0 < e >>> 0;
+ e = f ? g : e;
+ b = f ? j : b;
+ f = c[j + 16 >> 2] | 0;
+ if ((f | 0) != 0) {
+ j = f;
+ continue
+ }
+ j = c[j + 20 >> 2] | 0;
+ if ((j | 0) == 0) {
+ break
+ }
+ }
+ }
+ if ((b | 0) == 0) {
+ break
+ }
+ if (e >>> 0 >= ((c[640] | 0) - a | 0) >>> 0) {
+ break
+ }
+ d = b;
+ i = c[642] | 0;
+ if (d >>> 0 < i >>> 0) {
+ ma();
+ return 0
+ }
+ g = d + a | 0;
+ f = g;
+ if (d >>> 0 >= g >>> 0) {
+ ma();
+ return 0
+ }
+ h = c[b + 24 >> 2] | 0;
+ j = c[b + 12 >> 2] | 0;
+ do {
+ if ((j | 0) == (b | 0)) {
+ k = b + 20 | 0;
+ j = c[k >> 2] | 0;
+ if ((j | 0) == 0) {
+ k = b + 16 | 0;
+ j = c[k >> 2] | 0;
+ if ((j | 0) == 0) {
+ j = 0;
+ break
+ }
+ }
+ while (1) {
+ l = j + 20 | 0;
+ m = c[l >> 2] | 0;
+ if ((m | 0) != 0) {
+ j = m;
+ k = l;
+ continue
+ }
+ l = j + 16 | 0;
+ m = c[l >> 2] | 0;
+ if ((m | 0) == 0) {
+ break
+ } else {
+ j = m;
+ k = l
+ }
+ }
+ if (k >>> 0 < i >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[k >> 2] = 0;
+ break
+ }
+ } else {
+ k = c[b + 8 >> 2] | 0;
+ if (k >>> 0 < i >>> 0) {
+ ma();
+ return 0
+ }
+ i = k + 12 | 0;
+ if ((c[i >> 2] | 0) != (b | 0)) {
+ ma();
+ return 0
+ }
+ l = j + 8 | 0;
+ if ((c[l >> 2] | 0) == (b | 0)) {
+ c[i >> 2] = j;
+ c[l >> 2] = k;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ c: do {
+ if ((h | 0) != 0) {
+ i = b + 28 | 0;
+ k = 2856 + (c[i >> 2] << 2) | 0;
+ do {
+ if ((b | 0) == (c[k >> 2] | 0)) {
+ c[k >> 2] = j;
+ if ((j | 0) != 0) {
+ break
+ }
+ c[639] = c[639] & ~(1 << c[i >> 2]);
+ break c
+ } else {
+ if (h >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ i = h + 16 | 0;
+ if ((c[i >> 2] | 0) == (b | 0)) {
+ c[i >> 2] = j
+ } else {
+ c[h + 20 >> 2] = j
+ }
+ if ((j | 0) == 0) {
+ break c
+ }
+ }
+ } while (0);
+ if (j >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ c[j + 24 >> 2] = h;
+ h = c[b + 16 >> 2] | 0;
+ do {
+ if ((h | 0) != 0) {
+ if (h >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[j + 16 >> 2] = h;
+ c[h + 24 >> 2] = j;
+ break
+ }
+ }
+ } while (0);
+ h = c[b + 20 >> 2] | 0;
+ if ((h | 0) == 0) {
+ break
+ }
+ if (h >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[j + 20 >> 2] = h;
+ c[h + 24 >> 2] = j;
+ break
+ }
+ }
+ } while (0);
+ d: do {
+ if (e >>> 0 < 16 >>> 0) {
+ q = e + a | 0;
+ c[b + 4 >> 2] = q | 3;
+ q = d + (q + 4) | 0;
+ c[q >> 2] = c[q >> 2] | 1
+ } else {
+ c[b + 4 >> 2] = a | 3;
+ c[d + (a | 4) >> 2] = e | 1;
+ c[d + (e + a) >> 2] = e;
+ h = e >>> 3;
+ if (e >>> 0 < 256 >>> 0) {
+ g = h << 1;
+ e = 2592 + (g << 2) | 0;
+ i = c[638] | 0;
+ h = 1 << h;
+ do {
+ if ((i & h | 0) == 0) {
+ c[638] = i | h;
+ h = e;
+ g = 2592 + (g + 2 << 2) | 0
+ } else {
+ g = 2592 + (g + 2 << 2) | 0;
+ h = c[g >> 2] | 0;
+ if (h >>> 0 >= (c[642] | 0) >>> 0) {
+ break
+ }
+ ma();
+ return 0
+ }
+ } while (0);
+ c[g >> 2] = f;
+ c[h + 12 >> 2] = f;
+ c[d + (a + 8) >> 2] = h;
+ c[d + (a + 12) >> 2] = e;
+ break
+ }
+ f = e >>> 8;
+ do {
+ if ((f | 0) == 0) {
+ h = 0
+ } else {
+ if (e >>> 0 > 16777215 >>> 0) {
+ h = 31;
+ break
+ }
+ p = (f + 1048320 | 0) >>> 16 & 8;
+ q = f << p;
+ o = (q + 520192 | 0) >>> 16 & 4;
+ q = q << o;
+ h = (q + 245760 | 0) >>> 16 & 2;
+ h = 14 - (o | p | h) + (q << h >>> 15) | 0;
+ h = e >>> ((h + 7 | 0) >>> 0) & 1 | h << 1
+ }
+ } while (0);
+ f = 2856 + (h << 2) | 0;
+ c[d + (a + 28) >> 2] = h;
+ c[d + (a + 20) >> 2] = 0;
+ c[d + (a + 16) >> 2] = 0;
+ j = c[639] | 0;
+ i = 1 << h;
+ if ((j & i | 0) == 0) {
+ c[639] = j | i;
+ c[f >> 2] = g;
+ c[d + (a + 24) >> 2] = f;
+ c[d + (a + 12) >> 2] = g;
+ c[d + (a + 8) >> 2] = g;
+ break
+ }
+ f = c[f >> 2] | 0;
+ if ((h | 0) == 31) {
+ h = 0
+ } else {
+ h = 25 - (h >>> 1) | 0
+ }
+ e: do {
+ if ((c[f + 4 >> 2] & -8 | 0) != (e | 0)) {
+ h = e << h;
+ while (1) {
+ i = f + 16 + (h >>> 31 << 2) | 0;
+ j = c[i >> 2] | 0;
+ if ((j | 0) == 0) {
+ break
+ }
+ if ((c[j + 4 >> 2] & -8 | 0) == (e | 0)) {
+ f = j;
+ break e
+ } else {
+ f = j;
+ h = h << 1
+ }
+ }
+ if (i >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[i >> 2] = g;
+ c[d + (a + 24) >> 2] = f;
+ c[d + (a + 12) >> 2] = g;
+ c[d + (a + 8) >> 2] = g;
+ break d
+ }
+ }
+ } while (0);
+ h = f + 8 | 0;
+ e = c[h >> 2] | 0;
+ q = c[642] | 0;
+ if (f >>> 0 >= q >>> 0 & e >>> 0 >= q >>> 0) {
+ c[e + 12 >> 2] = g;
+ c[h >> 2] = g;
+ c[d + (a + 8) >> 2] = e;
+ c[d + (a + 12) >> 2] = f;
+ c[d + (a + 24) >> 2] = 0;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ q = b + 8 | 0;
+ return q | 0
+ }
+ } while (0);
+ b = c[640] | 0;
+ if (b >>> 0 >= a >>> 0) {
+ d = b - a | 0;
+ e = c[643] | 0;
+ if (d >>> 0 > 15 >>> 0) {
+ q = e;
+ c[643] = q + a;
+ c[640] = d;
+ c[q + (a + 4) >> 2] = d | 1;
+ c[q + b >> 2] = d;
+ c[e + 4 >> 2] = a | 3
+ } else {
+ c[640] = 0;
+ c[643] = 0;
+ c[e + 4 >> 2] = b | 3;
+ q = e + (b + 4) | 0;
+ c[q >> 2] = c[q >> 2] | 1
+ }
+ q = e + 8 | 0;
+ return q | 0
+ }
+ b = c[641] | 0;
+ if (b >>> 0 > a >>> 0) {
+ o = b - a | 0;
+ c[641] = o;
+ q = c[644] | 0;
+ p = q;
+ c[644] = p + a;
+ c[p + (a + 4) >> 2] = o | 1;
+ c[q + 4 >> 2] = a | 3;
+ q = q + 8 | 0;
+ return q | 0
+ }
+ do {
+ if ((c[632] | 0) == 0) {
+ b = la(30) | 0;
+ if ((b - 1 & b | 0) == 0) {
+ c[634] = b;
+ c[633] = b;
+ c[635] = -1;
+ c[636] = -1;
+ c[637] = 0;
+ c[749] = 0;
+ c[632] = (Ja(0) | 0) & -16 ^ 1431655768;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ h = a + 48 | 0;
+ e = c[634] | 0;
+ g = a + 47 | 0;
+ b = e + g | 0;
+ e = -e | 0;
+ f = b & e;
+ if (f >>> 0 <= a >>> 0) {
+ q = 0;
+ return q | 0
+ }
+ i = c[748] | 0;
+ do {
+ if ((i | 0) != 0) {
+ p = c[746] | 0;
+ q = p + f | 0;
+ if (q >>> 0 <= p >>> 0 | q >>> 0 > i >>> 0) {
+ a = 0
+ } else {
+ break
+ }
+ return a | 0
+ }
+ } while (0);
+ f: do {
+ if ((c[749] & 4 | 0) == 0) {
+ k = c[644] | 0;
+ g: do {
+ if ((k | 0) == 0) {
+ d = 181
+ } else {
+ l = 3e3;
+ while (1) {
+ j = l | 0;
+ m = c[j >> 2] | 0;
+ if (m >>> 0 <= k >>> 0) {
+ i = l + 4 | 0;
+ if ((m + (c[i >> 2] | 0) | 0) >>> 0 > k >>> 0) {
+ break
+ }
+ }
+ l = c[l + 8 >> 2] | 0;
+ if ((l | 0) == 0) {
+ d = 181;
+ break g
+ }
+ }
+ if ((l | 0) == 0) {
+ d = 181;
+ break
+ }
+ e = b - (c[641] | 0) & e;
+ if (e >>> 0 >= 2147483647 >>> 0) {
+ e = 0;
+ break
+ }
+ b = Ga(e | 0) | 0;
+ if ((b | 0) == ((c[j >> 2] | 0) + (c[i >> 2] | 0) | 0)) {
+ d = 190
+ } else {
+ d = 191
+ }
+ }
+ } while (0);
+ do {
+ if ((d | 0) == 181) {
+ i = Ga(0) | 0;
+ if ((i | 0) == -1) {
+ e = 0;
+ break
+ }
+ e = i;
+ b = c[633] | 0;
+ j = b - 1 | 0;
+ if ((j & e | 0) == 0) {
+ e = f
+ } else {
+ e = f - e + (j + e & -b) | 0
+ }
+ j = c[746] | 0;
+ b = j + e | 0;
+ if (!(e >>> 0 > a >>> 0 & e >>> 0 < 2147483647 >>> 0)) {
+ e = 0;
+ break
+ }
+ k = c[748] | 0;
+ if ((k | 0) != 0) {
+ if (b >>> 0 <= j >>> 0 | b >>> 0 > k >>> 0) {
+ e = 0;
+ break
+ }
+ }
+ b = Ga(e | 0) | 0;
+ if ((b | 0) == (i | 0)) {
+ b = i;
+ d = 190
+ } else {
+ d = 191
+ }
+ }
+ } while (0);
+ h: do {
+ if ((d | 0) == 190) {
+ if ((b | 0) != -1) {
+ d = 201;
+ break f
+ }
+ } else if ((d | 0) == 191) {
+ d = -e | 0;
+ do {
+ if ((b | 0) != -1 & e >>> 0 < 2147483647 >>> 0 & h >>> 0 > e >>> 0) {
+ q = c[634] | 0;
+ g = g - e + q & -q;
+ if (g >>> 0 >= 2147483647 >>> 0) {
+ break
+ }
+ if ((Ga(g | 0) | 0) == -1) {
+ Ga(d | 0) | 0;
+ e = 0;
+ break h
+ } else {
+ e = g + e | 0;
+ break
+ }
+ }
+ } while (0);
+ if ((b | 0) == -1) {
+ e = 0
+ } else {
+ d = 201;
+ break f
+ }
+ }
+ } while (0);
+ c[749] = c[749] | 4;
+ d = 198
+ } else {
+ e = 0;
+ d = 198
+ }
+ } while (0);
+ do {
+ if ((d | 0) == 198) {
+ if (f >>> 0 >= 2147483647 >>> 0) {
+ break
+ }
+ b = Ga(f | 0) | 0;
+ f = Ga(0) | 0;
+ if (!((b | 0) != -1 & (f | 0) != -1 & b >>> 0 < f >>> 0)) {
+ break
+ }
+ g = f - b | 0;
+ f = g >>> 0 > (a + 40 | 0) >>> 0;
+ if (f) {
+ e = f ? g : e;
+ d = 201
+ }
+ }
+ } while (0);
+ do {
+ if ((d | 0) == 201) {
+ f = (c[746] | 0) + e | 0;
+ c[746] = f;
+ if (f >>> 0 > (c[747] | 0) >>> 0) {
+ c[747] = f
+ }
+ f = c[644] | 0;
+ i: do {
+ if ((f | 0) == 0) {
+ q = c[642] | 0;
+ if ((q | 0) == 0 | b >>> 0 < q >>> 0) {
+ c[642] = b
+ }
+ c[750] = b;
+ c[751] = e;
+ c[753] = 0;
+ c[647] = c[632];
+ c[646] = -1;
+ d = 0;
+ do {
+ q = d << 1;
+ p = 2592 + (q << 2) | 0;
+ c[2592 + (q + 3 << 2) >> 2] = p;
+ c[2592 + (q + 2 << 2) >> 2] = p;
+ d = d + 1 | 0;
+ } while (d >>> 0 < 32 >>> 0);
+ d = b + 8 | 0;
+ if ((d & 7 | 0) == 0) {
+ d = 0
+ } else {
+ d = -d & 7
+ }
+ q = e - 40 - d | 0;
+ c[644] = b + d;
+ c[641] = q;
+ c[b + (d + 4) >> 2] = q | 1;
+ c[b + (e - 36) >> 2] = 40;
+ c[645] = c[636]
+ } else {
+ g = 3e3;
+ do {
+ j = c[g >> 2] | 0;
+ i = g + 4 | 0;
+ h = c[i >> 2] | 0;
+ if ((b | 0) == (j + h | 0)) {
+ d = 213;
+ break
+ }
+ g = c[g + 8 >> 2] | 0;
+ } while ((g | 0) != 0);
+ do {
+ if ((d | 0) == 213) {
+ if ((c[g + 12 >> 2] & 8 | 0) != 0) {
+ break
+ }
+ q = f;
+ if (!(q >>> 0 >= j >>> 0 & q >>> 0 < b >>> 0)) {
+ break
+ }
+ c[i >> 2] = h + e;
+ q = c[644] | 0;
+ b = (c[641] | 0) + e | 0;
+ d = q;
+ e = q + 8 | 0;
+ if ((e & 7 | 0) == 0) {
+ e = 0
+ } else {
+ e = -e & 7
+ }
+ q = b - e | 0;
+ c[644] = d + e;
+ c[641] = q;
+ c[d + (e + 4) >> 2] = q | 1;
+ c[d + (b + 4) >> 2] = 40;
+ c[645] = c[636];
+ break i
+ }
+ } while (0);
+ if (b >>> 0 < (c[642] | 0) >>> 0) {
+ c[642] = b
+ }
+ g = b + e | 0;
+ i = 3e3;
+ do {
+ h = i | 0;
+ if ((c[h >> 2] | 0) == (g | 0)) {
+ d = 223;
+ break
+ }
+ i = c[i + 8 >> 2] | 0;
+ } while ((i | 0) != 0);
+ do {
+ if ((d | 0) == 223) {
+ if ((c[i + 12 >> 2] & 8 | 0) != 0) {
+ break
+ }
+ c[h >> 2] = b;
+ d = i + 4 | 0;
+ c[d >> 2] = (c[d >> 2] | 0) + e;
+ d = b + 8 | 0;
+ if ((d & 7 | 0) == 0) {
+ d = 0
+ } else {
+ d = -d & 7
+ }
+ f = b + (e + 8) | 0;
+ if ((f & 7 | 0) == 0) {
+ j = 0
+ } else {
+ j = -f & 7
+ }
+ m = b + (j + e) | 0;
+ l = m;
+ f = d + a | 0;
+ h = b + f | 0;
+ g = h;
+ i = m - (b + d) - a | 0;
+ c[b + (d + 4) >> 2] = a | 3;
+ j: do {
+ if ((l | 0) == (c[644] | 0)) {
+ q = (c[641] | 0) + i | 0;
+ c[641] = q;
+ c[644] = g;
+ c[b + (f + 4) >> 2] = q | 1
+ } else {
+ if ((l | 0) == (c[643] | 0)) {
+ q = (c[640] | 0) + i | 0;
+ c[640] = q;
+ c[643] = g;
+ c[b + (f + 4) >> 2] = q | 1;
+ c[b + (q + f) >> 2] = q;
+ break
+ }
+ k = e + 4 | 0;
+ o = c[b + (k + j) >> 2] | 0;
+ if ((o & 3 | 0) == 1) {
+ a = o & -8;
+ n = o >>> 3;
+ k: do {
+ if (o >>> 0 < 256 >>> 0) {
+ k = c[b + ((j | 8) + e) >> 2] | 0;
+ m = c[b + (e + 12 + j) >> 2] | 0;
+ o = 2592 + (n << 1 << 2) | 0;
+ do {
+ if ((k | 0) != (o | 0)) {
+ if (k >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ if ((c[k + 12 >> 2] | 0) == (l | 0)) {
+ break
+ }
+ ma();
+ return 0
+ }
+ } while (0);
+ if ((m | 0) == (k | 0)) {
+ c[638] = c[638] & ~(1 << n);
+ break
+ }
+ do {
+ if ((m | 0) == (o | 0)) {
+ n = m + 8 | 0
+ } else {
+ if (m >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ n = m + 8 | 0;
+ if ((c[n >> 2] | 0) == (l | 0)) {
+ break
+ }
+ ma();
+ return 0
+ }
+ } while (0);
+ c[k + 12 >> 2] = m;
+ c[n >> 2] = k
+ } else {
+ l = c[b + ((j | 24) + e) >> 2] | 0;
+ n = c[b + (e + 12 + j) >> 2] | 0;
+ do {
+ if ((n | 0) == (m | 0)) {
+ p = j | 16;
+ o = b + (k + p) | 0;
+ n = c[o >> 2] | 0;
+ if ((n | 0) == 0) {
+ o = b + (p + e) | 0;
+ n = c[o >> 2] | 0;
+ if ((n | 0) == 0) {
+ n = 0;
+ break
+ }
+ }
+ while (1) {
+ q = n + 20 | 0;
+ p = c[q >> 2] | 0;
+ if ((p | 0) != 0) {
+ n = p;
+ o = q;
+ continue
+ }
+ p = n + 16 | 0;
+ q = c[p >> 2] | 0;
+ if ((q | 0) == 0) {
+ break
+ } else {
+ n = q;
+ o = p
+ }
+ }
+ if (o >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[o >> 2] = 0;
+ break
+ }
+ } else {
+ q = c[b + ((j | 8) + e) >> 2] | 0;
+ if (q >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ o = q + 12 | 0;
+ if ((c[o >> 2] | 0) != (m | 0)) {
+ ma();
+ return 0
+ }
+ p = n + 8 | 0;
+ if ((c[p >> 2] | 0) == (m | 0)) {
+ c[o >> 2] = n;
+ c[p >> 2] = q;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ if ((l | 0) == 0) {
+ break
+ }
+ o = b + (e + 28 + j) | 0;
+ p = 2856 + (c[o >> 2] << 2) | 0;
+ do {
+ if ((m | 0) == (c[p >> 2] | 0)) {
+ c[p >> 2] = n;
+ if ((n | 0) != 0) {
+ break
+ }
+ c[639] = c[639] & ~(1 << c[o >> 2]);
+ break k
+ } else {
+ if (l >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ o = l + 16 | 0;
+ if ((c[o >> 2] | 0) == (m | 0)) {
+ c[o >> 2] = n
+ } else {
+ c[l + 20 >> 2] = n
+ }
+ if ((n | 0) == 0) {
+ break k
+ }
+ }
+ } while (0);
+ if (n >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ }
+ c[n + 24 >> 2] = l;
+ m = j | 16;
+ l = c[b + (m + e) >> 2] | 0;
+ do {
+ if ((l | 0) != 0) {
+ if (l >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[n + 16 >> 2] = l;
+ c[l + 24 >> 2] = n;
+ break
+ }
+ }
+ } while (0);
+ k = c[b + (k + m) >> 2] | 0;
+ if ((k | 0) == 0) {
+ break
+ }
+ if (k >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[n + 20 >> 2] = k;
+ c[k + 24 >> 2] = n;
+ break
+ }
+ }
+ } while (0);
+ l = b + ((a | j) + e) | 0;
+ i = a + i | 0
+ }
+ e = l + 4 | 0;
+ c[e >> 2] = c[e >> 2] & -2;
+ c[b + (f + 4) >> 2] = i | 1;
+ c[b + (i + f) >> 2] = i;
+ e = i >>> 3;
+ if (i >>> 0 < 256 >>> 0) {
+ h = e << 1;
+ a = 2592 + (h << 2) | 0;
+ i = c[638] | 0;
+ e = 1 << e;
+ do {
+ if ((i & e | 0) == 0) {
+ c[638] = i | e;
+ e = a;
+ h = 2592 + (h + 2 << 2) | 0
+ } else {
+ h = 2592 + (h + 2 << 2) | 0;
+ e = c[h >> 2] | 0;
+ if (e >>> 0 >= (c[642] | 0) >>> 0) {
+ break
+ }
+ ma();
+ return 0
+ }
+ } while (0);
+ c[h >> 2] = g;
+ c[e + 12 >> 2] = g;
+ c[b + (f + 8) >> 2] = e;
+ c[b + (f + 12) >> 2] = a;
+ break
+ }
+ a = i >>> 8;
+ do {
+ if ((a | 0) == 0) {
+ e = 0
+ } else {
+ if (i >>> 0 > 16777215 >>> 0) {
+ e = 31;
+ break
+ }
+ p = (a + 1048320 | 0) >>> 16 & 8;
+ q = a << p;
+ o = (q + 520192 | 0) >>> 16 & 4;
+ q = q << o;
+ e = (q + 245760 | 0) >>> 16 & 2;
+ e = 14 - (o | p | e) + (q << e >>> 15) | 0;
+ e = i >>> ((e + 7 | 0) >>> 0) & 1 | e << 1
+ }
+ } while (0);
+ a = 2856 + (e << 2) | 0;
+ c[b + (f + 28) >> 2] = e;
+ c[b + (f + 20) >> 2] = 0;
+ c[b + (f + 16) >> 2] = 0;
+ j = c[639] | 0;
+ g = 1 << e;
+ if ((j & g | 0) == 0) {
+ c[639] = j | g;
+ c[a >> 2] = h;
+ c[b + (f + 24) >> 2] = a;
+ c[b + (f + 12) >> 2] = h;
+ c[b + (f + 8) >> 2] = h;
+ break
+ }
+ a = c[a >> 2] | 0;
+ if ((e | 0) == 31) {
+ e = 0
+ } else {
+ e = 25 - (e >>> 1) | 0
+ }
+ l: do {
+ if ((c[a + 4 >> 2] & -8 | 0) != (i | 0)) {
+ j = i << e;
+ while (1) {
+ g = a + 16 + (j >>> 31 << 2) | 0;
+ e = c[g >> 2] | 0;
+ if ((e | 0) == 0) {
+ break
+ }
+ if ((c[e + 4 >> 2] & -8 | 0) == (i | 0)) {
+ a = e;
+ break l
+ } else {
+ a = e;
+ j = j << 1
+ }
+ }
+ if (g >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[g >> 2] = h;
+ c[b + (f + 24) >> 2] = a;
+ c[b + (f + 12) >> 2] = h;
+ c[b + (f + 8) >> 2] = h;
+ break j
+ }
+ }
+ } while (0);
+ e = a + 8 | 0;
+ g = c[e >> 2] | 0;
+ q = c[642] | 0;
+ if (a >>> 0 >= q >>> 0 & g >>> 0 >= q >>> 0) {
+ c[g + 12 >> 2] = h;
+ c[e >> 2] = h;
+ c[b + (f + 8) >> 2] = g;
+ c[b + (f + 12) >> 2] = a;
+ c[b + (f + 24) >> 2] = 0;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ q = b + (d | 8) | 0;
+ return q | 0
+ }
+ } while (0);
+ d = f;
+ j = 3e3;
+ while (1) {
+ i = c[j >> 2] | 0;
+ if (i >>> 0 <= d >>> 0) {
+ h = c[j + 4 >> 2] | 0;
+ g = i + h | 0;
+ if (g >>> 0 > d >>> 0) {
+ break
+ }
+ }
+ j = c[j + 8 >> 2] | 0
+ }
+ j = i + (h - 39) | 0;
+ if ((j & 7 | 0) == 0) {
+ j = 0
+ } else {
+ j = -j & 7
+ }
+ h = i + (h - 47 + j) | 0;
+ h = h >>> 0 < (f + 16 | 0) >>> 0 ? d : h;
+ i = h + 8 | 0;
+ j = b + 8 | 0;
+ if ((j & 7 | 0) == 0) {
+ j = 0
+ } else {
+ j = -j & 7
+ }
+ q = e - 40 - j | 0;
+ c[644] = b + j;
+ c[641] = q;
+ c[b + (j + 4) >> 2] = q | 1;
+ c[b + (e - 36) >> 2] = 40;
+ c[645] = c[636];
+ c[h + 4 >> 2] = 27;
+ c[i >> 2] = c[750];
+ c[i + 4 >> 2] = c[751];
+ c[i + 8 >> 2] = c[752];
+ c[i + 12 >> 2] = c[753];
+ c[750] = b;
+ c[751] = e;
+ c[753] = 0;
+ c[752] = i;
+ e = h + 28 | 0;
+ c[e >> 2] = 7;
+ if ((h + 32 | 0) >>> 0 < g >>> 0) {
+ while (1) {
+ b = e + 4 | 0;
+ c[b >> 2] = 7;
+ if ((e + 8 | 0) >>> 0 < g >>> 0) {
+ e = b
+ } else {
+ break
+ }
+ }
+ }
+ if ((h | 0) == (d | 0)) {
+ break
+ }
+ e = h - f | 0;
+ g = d + (e + 4) | 0;
+ c[g >> 2] = c[g >> 2] & -2;
+ c[f + 4 >> 2] = e | 1;
+ c[d + e >> 2] = e;
+ g = e >>> 3;
+ if (e >>> 0 < 256 >>> 0) {
+ d = g << 1;
+ b = 2592 + (d << 2) | 0;
+ e = c[638] | 0;
+ g = 1 << g;
+ do {
+ if ((e & g | 0) == 0) {
+ c[638] = e | g;
+ e = b;
+ d = 2592 + (d + 2 << 2) | 0
+ } else {
+ d = 2592 + (d + 2 << 2) | 0;
+ e = c[d >> 2] | 0;
+ if (e >>> 0 >= (c[642] | 0) >>> 0) {
+ break
+ }
+ ma();
+ return 0
+ }
+ } while (0);
+ c[d >> 2] = f;
+ c[e + 12 >> 2] = f;
+ c[f + 8 >> 2] = e;
+ c[f + 12 >> 2] = b;
+ break
+ }
+ b = f;
+ d = e >>> 8;
+ do {
+ if ((d | 0) == 0) {
+ d = 0
+ } else {
+ if (e >>> 0 > 16777215 >>> 0) {
+ d = 31;
+ break
+ }
+ p = (d + 1048320 | 0) >>> 16 & 8;
+ q = d << p;
+ o = (q + 520192 | 0) >>> 16 & 4;
+ q = q << o;
+ d = (q + 245760 | 0) >>> 16 & 2;
+ d = 14 - (o | p | d) + (q << d >>> 15) | 0;
+ d = e >>> ((d + 7 | 0) >>> 0) & 1 | d << 1
+ }
+ } while (0);
+ g = 2856 + (d << 2) | 0;
+ c[f + 28 >> 2] = d;
+ c[f + 20 >> 2] = 0;
+ c[f + 16 >> 2] = 0;
+ i = c[639] | 0;
+ h = 1 << d;
+ if ((i & h | 0) == 0) {
+ c[639] = i | h;
+ c[g >> 2] = b;
+ c[f + 24 >> 2] = g;
+ c[f + 12 >> 2] = f;
+ c[f + 8 >> 2] = f;
+ break
+ }
+ i = c[g >> 2] | 0;
+ if ((d | 0) == 31) {
+ g = 0
+ } else {
+ g = 25 - (d >>> 1) | 0
+ }
+ m: do {
+ if ((c[i + 4 >> 2] & -8 | 0) != (e | 0)) {
+ d = i;
+ h = e << g;
+ while (1) {
+ g = d + 16 + (h >>> 31 << 2) | 0;
+ i = c[g >> 2] | 0;
+ if ((i | 0) == 0) {
+ break
+ }
+ if ((c[i + 4 >> 2] & -8 | 0) == (e | 0)) {
+ break m
+ } else {
+ d = i;
+ h = h << 1
+ }
+ }
+ if (g >>> 0 < (c[642] | 0) >>> 0) {
+ ma();
+ return 0
+ } else {
+ c[g >> 2] = b;
+ c[f + 24 >> 2] = d;
+ c[f + 12 >> 2] = f;
+ c[f + 8 >> 2] = f;
+ break i
+ }
+ }
+ } while (0);
+ d = i + 8 | 0;
+ e = c[d >> 2] | 0;
+ q = c[642] | 0;
+ if (i >>> 0 >= q >>> 0 & e >>> 0 >= q >>> 0) {
+ c[e + 12 >> 2] = b;
+ c[d >> 2] = b;
+ c[f + 8 >> 2] = e;
+ c[f + 12 >> 2] = i;
+ c[f + 24 >> 2] = 0;
+ break
+ } else {
+ ma();
+ return 0
+ }
+ }
+ } while (0);
+ b = c[641] | 0;
+ if (b >>> 0 <= a >>> 0) {
+ break
+ }
+ o = b - a | 0;
+ c[641] = o;
+ q = c[644] | 0;
+ p = q;
+ c[644] = p + a;
+ c[p + (a + 4) >> 2] = o | 1;
+ c[q + 4 >> 2] = a | 3;
+ q = q + 8 | 0;
+ return q | 0
+ }
+ } while (0);
+ c[(Ha() | 0) >> 2] = 12;
+ q = 0;
+ return q | 0
+ }
+
+ function cc(a) {
+ a = a | 0;
+ var b = 0,
+ d = 0,
+ e = 0,
+ f = 0,
+ g = 0,
+ h = 0,
+ i = 0,
+ j = 0,
+ k = 0,
+ l = 0,
+ m = 0,
+ n = 0,
+ o = 0,
+ p = 0,
+ q = 0,
+ r = 0,
+ s = 0,
+ t = 0,
+ u = 0,
+ v = 0,
+ w = 0;
+ if ((a | 0) == 0) {
+ return
+ }
+ p = a - 8 | 0;
+ r = p;
+ q = c[642] | 0;
+ if (p >>> 0 < q >>> 0) {
+ ma()
+ }
+ n = c[a - 4 >> 2] | 0;
+ m = n & 3;
+ if ((m | 0) == 1) {
+ ma()
+ }
+ h = n & -8;
+ k = a + (h - 8) | 0;
+ i = k;
+ a: do {
+ if ((n & 1 | 0) == 0) {
+ u = c[p >> 2] | 0;
+ if ((m | 0) == 0) {
+ return
+ }
+ p = -8 - u | 0;
+ r = a + p | 0;
+ m = r;
+ n = u + h | 0;
+ if (r >>> 0 < q >>> 0) {
+ ma()
+ }
+ if ((m | 0) == (c[643] | 0)) {
+ b = a + (h - 4) | 0;
+ if ((c[b >> 2] & 3 | 0) != 3) {
+ b = m;
+ l = n;
+ break
+ }
+ c[640] = n;
+ c[b >> 2] = c[b >> 2] & -2;
+ c[a + (p + 4) >> 2] = n | 1;
+ c[k >> 2] = n;
+ return
+ }
+ t = u >>> 3;
+ if (u >>> 0 < 256 >>> 0) {
+ b = c[a + (p + 8) >> 2] | 0;
+ l = c[a + (p + 12) >> 2] | 0;
+ o = 2592 + (t << 1 << 2) | 0;
+ do {
+ if ((b | 0) != (o | 0)) {
+ if (b >>> 0 < q >>> 0) {
+ ma()
+ }
+ if ((c[b + 12 >> 2] | 0) == (m | 0)) {
+ break
+ }
+ ma()
+ }
+ } while (0);
+ if ((l | 0) == (b | 0)) {
+ c[638] = c[638] & ~(1 << t);
+ b = m;
+ l = n;
+ break
+ }
+ do {
+ if ((l | 0) == (o | 0)) {
+ s = l + 8 | 0
+ } else {
+ if (l >>> 0 < q >>> 0) {
+ ma()
+ }
+ o = l + 8 | 0;
+ if ((c[o >> 2] | 0) == (m | 0)) {
+ s = o;
+ break
+ }
+ ma()
+ }
+ } while (0);
+ c[b + 12 >> 2] = l;
+ c[s >> 2] = b;
+ b = m;
+ l = n;
+ break
+ }
+ s = c[a + (p + 24) >> 2] | 0;
+ u = c[a + (p + 12) >> 2] | 0;
+ do {
+ if ((u | 0) == (r | 0)) {
+ u = a + (p + 20) | 0;
+ t = c[u >> 2] | 0;
+ if ((t | 0) == 0) {
+ u = a + (p + 16) | 0;
+ t = c[u >> 2] | 0;
+ if ((t | 0) == 0) {
+ o = 0;
+ break
+ }
+ }
+ while (1) {
+ w = t + 20 | 0;
+ v = c[w >> 2] | 0;
+ if ((v | 0) != 0) {
+ t = v;
+ u = w;
+ continue
+ }
+ v = t + 16 | 0;
+ w = c[v >> 2] | 0;
+ if ((w | 0) == 0) {
+ break
+ } else {
+ t = w;
+ u = v
+ }
+ }
+ if (u >>> 0 < q >>> 0) {
+ ma()
+ } else {
+ c[u >> 2] = 0;
+ o = t;
+ break
+ }
+ } else {
+ t = c[a + (p + 8) >> 2] | 0;
+ if (t >>> 0 < q >>> 0) {
+ ma()
+ }
+ q = t + 12 | 0;
+ if ((c[q >> 2] | 0) != (r | 0)) {
+ ma()
+ }
+ v = u + 8 | 0;
+ if ((c[v >> 2] | 0) == (r | 0)) {
+ c[q >> 2] = u;
+ c[v >> 2] = t;
+ o = u;
+ break
+ } else {
+ ma()
+ }
+ }
+ } while (0);
+ if ((s | 0) == 0) {
+ b = m;
+ l = n;
+ break
+ }
+ q = a + (p + 28) | 0;
+ t = 2856 + (c[q >> 2] << 2) | 0;
+ do {
+ if ((r | 0) == (c[t >> 2] | 0)) {
+ c[t >> 2] = o;
+ if ((o | 0) != 0) {
+ break
+ }
+ c[639] = c[639] & ~(1 << c[q >> 2]);
+ b = m;
+ l = n;
+ break a
+ } else {
+ if (s >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ }
+ q = s + 16 | 0;
+ if ((c[q >> 2] | 0) == (r | 0)) {
+ c[q >> 2] = o
+ } else {
+ c[s + 20 >> 2] = o
+ }
+ if ((o | 0) == 0) {
+ b = m;
+ l = n;
+ break a
+ }
+ }
+ } while (0);
+ if (o >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ }
+ c[o + 24 >> 2] = s;
+ q = c[a + (p + 16) >> 2] | 0;
+ do {
+ if ((q | 0) != 0) {
+ if (q >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ } else {
+ c[o + 16 >> 2] = q;
+ c[q + 24 >> 2] = o;
+ break
+ }
+ }
+ } while (0);
+ p = c[a + (p + 20) >> 2] | 0;
+ if ((p | 0) == 0) {
+ b = m;
+ l = n;
+ break
+ }
+ if (p >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ } else {
+ c[o + 20 >> 2] = p;
+ c[p + 24 >> 2] = o;
+ b = m;
+ l = n;
+ break
+ }
+ } else {
+ b = r;
+ l = h
+ }
+ } while (0);
+ m = b;
+ if (m >>> 0 >= k >>> 0) {
+ ma()
+ }
+ n = a + (h - 4) | 0;
+ o = c[n >> 2] | 0;
+ if ((o & 1 | 0) == 0) {
+ ma()
+ }
+ do {
+ if ((o & 2 | 0) == 0) {
+ if ((i | 0) == (c[644] | 0)) {
+ w = (c[641] | 0) + l | 0;
+ c[641] = w;
+ c[644] = b;
+ c[b + 4 >> 2] = w | 1;
+ if ((b | 0) != (c[643] | 0)) {
+ return
+ }
+ c[643] = 0;
+ c[640] = 0;
+ return
+ }
+ if ((i | 0) == (c[643] | 0)) {
+ w = (c[640] | 0) + l | 0;
+ c[640] = w;
+ c[643] = b;
+ c[b + 4 >> 2] = w | 1;
+ c[m + w >> 2] = w;
+ return
+ }
+ l = (o & -8) + l | 0;
+ n = o >>> 3;
+ b: do {
+ if (o >>> 0 < 256 >>> 0) {
+ g = c[a + h >> 2] | 0;
+ h = c[a + (h | 4) >> 2] | 0;
+ a = 2592 + (n << 1 << 2) | 0;
+ do {
+ if ((g | 0) != (a | 0)) {
+ if (g >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ }
+ if ((c[g + 12 >> 2] | 0) == (i | 0)) {
+ break
+ }
+ ma()
+ }
+ } while (0);
+ if ((h | 0) == (g | 0)) {
+ c[638] = c[638] & ~(1 << n);
+ break
+ }
+ do {
+ if ((h | 0) == (a | 0)) {
+ j = h + 8 | 0
+ } else {
+ if (h >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ }
+ a = h + 8 | 0;
+ if ((c[a >> 2] | 0) == (i | 0)) {
+ j = a;
+ break
+ }
+ ma()
+ }
+ } while (0);
+ c[g + 12 >> 2] = h;
+ c[j >> 2] = g
+ } else {
+ i = c[a + (h + 16) >> 2] | 0;
+ n = c[a + (h | 4) >> 2] | 0;
+ do {
+ if ((n | 0) == (k | 0)) {
+ n = a + (h + 12) | 0;
+ j = c[n >> 2] | 0;
+ if ((j | 0) == 0) {
+ n = a + (h + 8) | 0;
+ j = c[n >> 2] | 0;
+ if ((j | 0) == 0) {
+ g = 0;
+ break
+ }
+ }
+ while (1) {
+ p = j + 20 | 0;
+ o = c[p >> 2] | 0;
+ if ((o | 0) != 0) {
+ j = o;
+ n = p;
+ continue
+ }
+ o = j + 16 | 0;
+ p = c[o >> 2] | 0;
+ if ((p | 0) == 0) {
+ break
+ } else {
+ j = p;
+ n = o
+ }
+ }
+ if (n >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ } else {
+ c[n >> 2] = 0;
+ g = j;
+ break
+ }
+ } else {
+ o = c[a + h >> 2] | 0;
+ if (o >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ }
+ p = o + 12 | 0;
+ if ((c[p >> 2] | 0) != (k | 0)) {
+ ma()
+ }
+ j = n + 8 | 0;
+ if ((c[j >> 2] | 0) == (k | 0)) {
+ c[p >> 2] = n;
+ c[j >> 2] = o;
+ g = n;
+ break
+ } else {
+ ma()
+ }
+ }
+ } while (0);
+ if ((i | 0) == 0) {
+ break
+ }
+ j = a + (h + 20) | 0;
+ n = 2856 + (c[j >> 2] << 2) | 0;
+ do {
+ if ((k | 0) == (c[n >> 2] | 0)) {
+ c[n >> 2] = g;
+ if ((g | 0) != 0) {
+ break
+ }
+ c[639] = c[639] & ~(1 << c[j >> 2]);
+ break b
+ } else {
+ if (i >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ }
+ j = i + 16 | 0;
+ if ((c[j >> 2] | 0) == (k | 0)) {
+ c[j >> 2] = g
+ } else {
+ c[i + 20 >> 2] = g
+ }
+ if ((g | 0) == 0) {
+ break b
+ }
+ }
+ } while (0);
+ if (g >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ }
+ c[g + 24 >> 2] = i;
+ i = c[a + (h + 8) >> 2] | 0;
+ do {
+ if ((i | 0) != 0) {
+ if (i >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ } else {
+ c[g + 16 >> 2] = i;
+ c[i + 24 >> 2] = g;
+ break
+ }
+ }
+ } while (0);
+ h = c[a + (h + 12) >> 2] | 0;
+ if ((h | 0) == 0) {
+ break
+ }
+ if (h >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ } else {
+ c[g + 20 >> 2] = h;
+ c[h + 24 >> 2] = g;
+ break
+ }
+ }
+ } while (0);
+ c[b + 4 >> 2] = l | 1;
+ c[m + l >> 2] = l;
+ if ((b | 0) != (c[643] | 0)) {
+ break
+ }
+ c[640] = l;
+ return
+ } else {
+ c[n >> 2] = o & -2;
+ c[b + 4 >> 2] = l | 1;
+ c[m + l >> 2] = l
+ }
+ } while (0);
+ g = l >>> 3;
+ if (l >>> 0 < 256 >>> 0) {
+ a = g << 1;
+ d = 2592 + (a << 2) | 0;
+ h = c[638] | 0;
+ g = 1 << g;
+ do {
+ if ((h & g | 0) == 0) {
+ c[638] = h | g;
+ f = d;
+ e = 2592 + (a + 2 << 2) | 0
+ } else {
+ h = 2592 + (a + 2 << 2) | 0;
+ g = c[h >> 2] | 0;
+ if (g >>> 0 >= (c[642] | 0) >>> 0) {
+ f = g;
+ e = h;
+ break
+ }
+ ma()
+ }
+ } while (0);
+ c[e >> 2] = b;
+ c[f + 12 >> 2] = b;
+ c[b + 8 >> 2] = f;
+ c[b + 12 >> 2] = d;
+ return
+ }
+ e = b;
+ f = l >>> 8;
+ do {
+ if ((f | 0) == 0) {
+ f = 0
+ } else {
+ if (l >>> 0 > 16777215 >>> 0) {
+ f = 31;
+ break
+ }
+ v = (f + 1048320 | 0) >>> 16 & 8;
+ w = f << v;
+ u = (w + 520192 | 0) >>> 16 & 4;
+ w = w << u;
+ f = (w + 245760 | 0) >>> 16 & 2;
+ f = 14 - (u | v | f) + (w << f >>> 15) | 0;
+ f = l >>> ((f + 7 | 0) >>> 0) & 1 | f << 1
+ }
+ } while (0);
+ g = 2856 + (f << 2) | 0;
+ c[b + 28 >> 2] = f;
+ c[b + 20 >> 2] = 0;
+ c[b + 16 >> 2] = 0;
+ a = c[639] | 0;
+ h = 1 << f;
+ c: do {
+ if ((a & h | 0) == 0) {
+ c[639] = a | h;
+ c[g >> 2] = e;
+ c[b + 24 >> 2] = g;
+ c[b + 12 >> 2] = b;
+ c[b + 8 >> 2] = b
+ } else {
+ h = c[g >> 2] | 0;
+ if ((f | 0) == 31) {
+ g = 0
+ } else {
+ g = 25 - (f >>> 1) | 0
+ }
+ d: do {
+ if ((c[h + 4 >> 2] & -8 | 0) == (l | 0)) {
+ d = h
+ } else {
+ f = h;
+ h = l << g;
+ while (1) {
+ a = f + 16 + (h >>> 31 << 2) | 0;
+ g = c[a >> 2] | 0;
+ if ((g | 0) == 0) {
+ break
+ }
+ if ((c[g + 4 >> 2] & -8 | 0) == (l | 0)) {
+ d = g;
+ break d
+ } else {
+ f = g;
+ h = h << 1
+ }
+ }
+ if (a >>> 0 < (c[642] | 0) >>> 0) {
+ ma()
+ } else {
+ c[a >> 2] = e;
+ c[b + 24 >> 2] = f;
+ c[b + 12 >> 2] = b;
+ c[b + 8 >> 2] = b;
+ break c
+ }
+ }
+ } while (0);
+ f = d + 8 | 0;
+ g = c[f >> 2] | 0;
+ w = c[642] | 0;
+ if (d >>> 0 >= w >>> 0 & g >>> 0 >= w >>> 0) {
+ c[g + 12 >> 2] = e;
+ c[f >> 2] = e;
+ c[b + 8 >> 2] = g;
+ c[b + 12 >> 2] = d;
+ c[b + 24 >> 2] = 0;
+ break
+ } else {
+ ma()
+ }
+ }
+ } while (0);
+ w = (c[646] | 0) - 1 | 0;
+ c[646] = w;
+ if ((w | 0) == 0) {
+ b = 3008
+ } else {
+ return
+ }
+ while (1) {
+ b = c[b >> 2] | 0;
+ if ((b | 0) == 0) {
+ break
+ } else {
+ b = b + 8 | 0
+ }
+ }
+ c[646] = -1;
+ return
+ }
+
+ function dc(b, d, e) {
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ var f = 0;
+ f = b | 0;
+ if ((b & 3) == (d & 3)) {
+ while (b & 3) {
+ if ((e | 0) == 0) return f | 0;
+ a[b] = a[d] | 0;
+ b = b + 1 | 0;
+ d = d + 1 | 0;
+ e = e - 1 | 0
+ }
+ while ((e | 0) >= 4) {
+ c[b >> 2] = c[d >> 2];
+ b = b + 4 | 0;
+ d = d + 4 | 0;
+ e = e - 4 | 0
+ }
+ }
+ while ((e | 0) > 0) {
+ a[b] = a[d] | 0;
+ b = b + 1 | 0;
+ d = d + 1 | 0;
+ e = e - 1 | 0
+ }
+ return f | 0
+ }
+
+ function ec(b) {
+ b = b | 0;
+ var c = 0;
+ c = b;
+ while (a[c] | 0) {
+ c = c + 1 | 0
+ }
+ return c - b | 0
+ }
+
+ function fc(b, d, e) {
+ b = b | 0;
+ d = d | 0;
+ e = e | 0;
+ var f = 0,
+ g = 0,
+ h = 0,
+ i = 0;
+ f = b + e | 0;
+ if ((e | 0) >= 20) {
+ d = d & 255;
+ i = b & 3;
+ h = d | d << 8 | d << 16 | d << 24;
+ g = f & ~3;
+ if (i) {
+ i = b + 4 - i | 0;
+ while ((b | 0) < (i | 0)) {
+ a[b] = d;
+ b = b + 1 | 0
+ }
+ }
+ while ((b | 0) < (g | 0)) {
+ c[b >> 2] = h;
+ b = b + 4 | 0
+ }
+ }
+ while ((b | 0) < (f | 0)) {
+ a[b] = d;
+ b = b + 1 | 0
+ }
+ return b - e | 0
+ }
+
+ function gc(a, b) {
+ a = a | 0;
+ b = b | 0;
+ Ma[a & 1](b | 0)
+ }
+
+ function hc(a, b, c) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ Na[a & 1](b | 0, c | 0)
+ }
+
+ function ic(a, b) {
+ a = a | 0;
+ b = b | 0;
+ return Oa[a & 1](b | 0) | 0
+ }
+
+ function jc(a, b) {
+ a = a | 0;
+ b = +b;
+ return +Pa[a & 7](+b)
+ }
+
+ function kc(a) {
+ a = a | 0;
+ Qa[a & 1]()
+ }
+
+ function lc(a, b, c) {
+ a = a | 0;
+ b = b | 0;
+ c = c | 0;
+ return Ra[a & 1](b | 0, c | 0) | 0
+ }
+
+ function mc(a) {
+ a = a | 0;
+ _(0)
+ }
+
+ function nc(a, b) {
+ a = a | 0;
+ b = b | 0;
+ _(1)
+ }
+
+ function oc(a) {
+ a = a | 0;
+ _(2);
+ return 0
+ }
+
+ function pc(a) {
+ a = +a;
+ _(3);
+ return 0.0
+ }
+
+ function qc() {
+ _(4)
+ }
+
+ function rc(a, b) {
+ a = a | 0;
+ b = b | 0;
+ _(5);
+ return 0
+ }
+
+
+
+
+ // EMSCRIPTEN_END_FUNCS
+ var Ma = [mc, mc];
+ var Na = [nc, nc];
+ var Oa = [oc, oc];
+ var Pa = [pc, pc, mb, pc, lb, pc, kb, pc];
+ var Qa = [qc, qc];
+ var Ra = [rc, rc];
+ return {
+ _firdes_get_window_from_string: ib,
+ _strlen: ec,
+ _firdes_lowpass_f: nb,
+ _next_pow2: Mb,
+ _gain_ff: Kb,
+ _shift_table_cc: tb,
+ _firdes_wkernel_hamming: lb,
+ _fir_decimate_cc: ub,
+ _encode_ima_adpcm_i16_u8: _b,
+ _convert_i16_f: Rb,
+ _shift_addition_init: Vb,
+ _decimating_shift_addition_cc: Yb,
+ _decimating_shift_addition_init: Xb,
+ _shift_table_init: rb,
+ _convert_u8_f: Qb,
+ _fastagc_ff: Db,
+ _memset: fc,
+ _fmdemod_quadri_cf: Gb,
+ _amdemod_cf: zb,
+ _log2n: Lb,
+ _convert_f_u8: Sb,
+ _rational_resampler_get_lowpass_f: wb,
+ _apply_fir_fft_cc: yb,
+ _fractional_decimator_ff: xb,
+ _amdemod_estimator_cf: Ab,
+ _limit_ff: Jb,
+ _fmdemod_atan_cf: Eb,
+ _fmdemod_quadri_novect_cf: Fb,
+ _shift_addition_cc: Ub,
+ _firdes_wkernel_blackman: kb,
+ _deemphasis_wfm_ff: Hb,
+ _firdes_filter_len: pb,
+ _decode_ima_adpcm_u8_i16: $b,
+ _firdes_wkernel_boxcar: mb,
+ _shift_math_cc: qb,
+ _agc_ff: Zb,
+ _dcblock_ff: Bb,
+ _free: cc,
+ _fastdcblock_ff: Cb,
+ _firdes_get_string_from_window: jb,
+ _rational_resampler_ff: vb,
+ _convert_f_i16: Tb,
+ _logpower_cf: Pb,
+ _shift_addition_cc_test: Wb,
+ _malloc: bc,
+ _memcpy: dc,
+ _deemphasis_nfm_ff: Ib,
+ _apply_window_c: Nb,
+ _shift_table_deinit: sb,
+ _apply_window_f: Ob,
+ _firdes_bandpass_c: ob,
+ runPostSets: gb,
+ stackAlloc: Sa,
+ stackSave: Ta,
+ stackRestore: Ua,
+ setThrew: Va,
+ setTempRet0: Ya,
+ setTempRet1: Za,
+ setTempRet2: _a,
+ setTempRet3: $a,
+ setTempRet4: ab,
+ setTempRet5: bb,
+ setTempRet6: cb,
+ setTempRet7: db,
+ setTempRet8: eb,
+ setTempRet9: fb,
+ dynCall_vi: gc,
+ dynCall_vii: hc,
+ dynCall_ii: ic,
+ dynCall_ff: jc,
+ dynCall_v: kc,
+ dynCall_iii: lc
+ }
+})
+
+
+// EMSCRIPTEN_END_ASM
+({
+ "Math": Math,
+ "Int8Array": Int8Array,
+ "Int16Array": Int16Array,
+ "Int32Array": Int32Array,
+ "Uint8Array": Uint8Array,
+ "Uint16Array": Uint16Array,
+ "Uint32Array": Uint32Array,
+ "Float32Array": Float32Array,
+ "Float64Array": Float64Array
+}, {
+ "abort": abort,
+ "assert": assert,
+ "asmPrintInt": asmPrintInt,
+ "asmPrintFloat": asmPrintFloat,
+ "min": Math_min,
+ "invoke_vi": invoke_vi,
+ "invoke_vii": invoke_vii,
+ "invoke_ii": invoke_ii,
+ "invoke_ff": invoke_ff,
+ "invoke_v": invoke_v,
+ "invoke_iii": invoke_iii,
+ "_strncmp": _strncmp,
+ "_fabsf": _fabsf,
+ "_sysconf": _sysconf,
+ "_abort": _abort,
+ "_fprintf": _fprintf,
+ "_printf": _printf,
+ "_fflush": _fflush,
+ "__reallyNegative": __reallyNegative,
+ "_sqrtf": _sqrtf,
+ "_fputc": _fputc,
+ "_fabs": _fabs,
+ "___setErrNo": ___setErrNo,
+ "_fwrite": _fwrite,
+ "_send": _send,
+ "_write": _write,
+ "_fputs": _fputs,
+ "_log10": _log10,
+ "_sin": _sin,
+ "_ceilf": _ceilf,
+ "__formatString": __formatString,
+ "_cos": _cos,
+ "_pwrite": _pwrite,
+ "_puts": _puts,
+ "_sbrk": _sbrk,
+ "___errno_location": ___errno_location,
+ "_atan2": _atan2,
+ "_time": _time,
+ "_strcmp": _strcmp,
+ "STACKTOP": STACKTOP,
+ "STACK_MAX": STACK_MAX,
+ "tempDoublePtr": tempDoublePtr,
+ "ABORT": ABORT,
+ "NaN": NaN,
+ "Infinity": Infinity
+}, buffer);
+var _firdes_get_window_from_string = Module["_firdes_get_window_from_string"] = asm["_firdes_get_window_from_string"];
+var _strlen = Module["_strlen"] = asm["_strlen"];
+var _firdes_lowpass_f = Module["_firdes_lowpass_f"] = asm["_firdes_lowpass_f"];
+var _next_pow2 = Module["_next_pow2"] = asm["_next_pow2"];
+var _gain_ff = Module["_gain_ff"] = asm["_gain_ff"];
+var _shift_table_cc = Module["_shift_table_cc"] = asm["_shift_table_cc"];
+var _firdes_wkernel_hamming = Module["_firdes_wkernel_hamming"] = asm["_firdes_wkernel_hamming"];
+var _fir_decimate_cc = Module["_fir_decimate_cc"] = asm["_fir_decimate_cc"];
+var _encode_ima_adpcm_i16_u8 = Module["_encode_ima_adpcm_i16_u8"] = asm["_encode_ima_adpcm_i16_u8"];
+var _convert_i16_f = Module["_convert_i16_f"] = asm["_convert_i16_f"];
+var _shift_addition_init = Module["_shift_addition_init"] = asm["_shift_addition_init"];
+var _decimating_shift_addition_cc = Module["_decimating_shift_addition_cc"] = asm["_decimating_shift_addition_cc"];
+var _decimating_shift_addition_init = Module["_decimating_shift_addition_init"] = asm["_decimating_shift_addition_init"];
+var _shift_table_init = Module["_shift_table_init"] = asm["_shift_table_init"];
+var _convert_u8_f = Module["_convert_u8_f"] = asm["_convert_u8_f"];
+var _fastagc_ff = Module["_fastagc_ff"] = asm["_fastagc_ff"];
+var _memset = Module["_memset"] = asm["_memset"];
+var _fmdemod_quadri_cf = Module["_fmdemod_quadri_cf"] = asm["_fmdemod_quadri_cf"];
+var _amdemod_cf = Module["_amdemod_cf"] = asm["_amdemod_cf"];
+var _log2n = Module["_log2n"] = asm["_log2n"];
+var _convert_f_u8 = Module["_convert_f_u8"] = asm["_convert_f_u8"];
+var _rational_resampler_get_lowpass_f = Module["_rational_resampler_get_lowpass_f"] = asm["_rational_resampler_get_lowpass_f"];
+var _apply_fir_fft_cc = Module["_apply_fir_fft_cc"] = asm["_apply_fir_fft_cc"];
+var _fractional_decimator_ff = Module["_fractional_decimator_ff"] = asm["_fractional_decimator_ff"];
+var _amdemod_estimator_cf = Module["_amdemod_estimator_cf"] = asm["_amdemod_estimator_cf"];
+var _limit_ff = Module["_limit_ff"] = asm["_limit_ff"];
+var _fmdemod_atan_cf = Module["_fmdemod_atan_cf"] = asm["_fmdemod_atan_cf"];
+var _fmdemod_quadri_novect_cf = Module["_fmdemod_quadri_novect_cf"] = asm["_fmdemod_quadri_novect_cf"];
+var _shift_addition_cc = Module["_shift_addition_cc"] = asm["_shift_addition_cc"];
+var _firdes_wkernel_blackman = Module["_firdes_wkernel_blackman"] = asm["_firdes_wkernel_blackman"];
+var _deemphasis_wfm_ff = Module["_deemphasis_wfm_ff"] = asm["_deemphasis_wfm_ff"];
+var _firdes_filter_len = Module["_firdes_filter_len"] = asm["_firdes_filter_len"];
+var _decode_ima_adpcm_u8_i16 = Module["_decode_ima_adpcm_u8_i16"] = asm["_decode_ima_adpcm_u8_i16"];
+var _firdes_wkernel_boxcar = Module["_firdes_wkernel_boxcar"] = asm["_firdes_wkernel_boxcar"];
+var _shift_math_cc = Module["_shift_math_cc"] = asm["_shift_math_cc"];
+var _agc_ff = Module["_agc_ff"] = asm["_agc_ff"];
+var _dcblock_ff = Module["_dcblock_ff"] = asm["_dcblock_ff"];
+var _free = Module["_free"] = asm["_free"];
+var _fastdcblock_ff = Module["_fastdcblock_ff"] = asm["_fastdcblock_ff"];
+var _firdes_get_string_from_window = Module["_firdes_get_string_from_window"] = asm["_firdes_get_string_from_window"];
+var _rational_resampler_ff = Module["_rational_resampler_ff"] = asm["_rational_resampler_ff"];
+var _convert_f_i16 = Module["_convert_f_i16"] = asm["_convert_f_i16"];
+var _logpower_cf = Module["_logpower_cf"] = asm["_logpower_cf"];
+var _shift_addition_cc_test = Module["_shift_addition_cc_test"] = asm["_shift_addition_cc_test"];
+var _malloc = Module["_malloc"] = asm["_malloc"];
+var _memcpy = Module["_memcpy"] = asm["_memcpy"];
+var _deemphasis_nfm_ff = Module["_deemphasis_nfm_ff"] = asm["_deemphasis_nfm_ff"];
+var _apply_window_c = Module["_apply_window_c"] = asm["_apply_window_c"];
+var _shift_table_deinit = Module["_shift_table_deinit"] = asm["_shift_table_deinit"];
+var _apply_window_f = Module["_apply_window_f"] = asm["_apply_window_f"];
+var _firdes_bandpass_c = Module["_firdes_bandpass_c"] = asm["_firdes_bandpass_c"];
+var runPostSets = Module["runPostSets"] = asm["runPostSets"];
+var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
+var dynCall_vii = Module["dynCall_vii"] = asm["dynCall_vii"];
+var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
+var dynCall_ff = Module["dynCall_ff"] = asm["dynCall_ff"];
+var dynCall_v = Module["dynCall_v"] = asm["dynCall_v"];
+var dynCall_iii = Module["dynCall_iii"] = asm["dynCall_iii"];
+
+Runtime.stackAlloc = function(size) {
+ return asm['stackAlloc'](size)
+};
+Runtime.stackSave = function() {
+ return asm['stackSave']()
+};
+Runtime.stackRestore = function(top) {
+ asm['stackRestore'](top)
+};
+
+// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
+var i64Math = null;
+
+// === Auto-generated postamble setup entry stuff ===
+
+if (memoryInitializer) {
+ function applyData(data) {
+ HEAPU8.set(data, STATIC_BASE);
+ }
+ if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
+ applyData(Module['readBinary'](memoryInitializer));
+ } else {
+ addRunDependency('memory initializer');
+ Browser.asyncLoad(memoryInitializer, function(data) {
+ applyData(data);
+ removeRunDependency('memory initializer');
+ }, function(data) {
+ throw 'could not load memory initializer ' + memoryInitializer;
+ });
+ }
+}
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+};
+ExitStatus.prototype = new Error();
+ExitStatus.prototype.constructor = ExitStatus;
+
+var initialStackTop;
+var preloadStartTime = null;
+var calledMain = false;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!Module['calledRun'] && shouldRunNow) run();
+ if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+}
+
+Module['callMain'] = Module.callMain = function callMain(args) {
+ assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
+ assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');
+
+ args = args || [];
+
+ if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
+ Module.printErr('preload time: ' + (Date.now() - preloadStartTime) + ' ms');
+ }
+
+ ensureInitRuntime();
+
+ var argc = args.length + 1;
+
+ function pad() {
+ for (var i = 0; i < 4 - 1; i++) {
+ argv.push(0);
+ }
+ }
+ var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_NORMAL)];
+ pad();
+ for (var i = 0; i < argc - 1; i = i + 1) {
+ argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
+ pad();
+ }
+ argv.push(0);
+ argv = allocate(argv, 'i32', ALLOC_NORMAL);
+
+ initialStackTop = STACKTOP;
+
+ try {
+
+ var ret = Module['_main'](argc, argv, 0);
+
+
+ // if we're not running an evented main loop, it's time to exit
+ if (!Module['noExitRuntime']) {
+ exit(ret);
+ }
+ } catch (e) {
+ if (e instanceof ExitStatus) {
+ // exit() throws this once it's done to make sure execution
+ // has been stopped completely
+ return;
+ } else if (e == 'SimulateInfiniteLoop') {
+ // running an evented main loop, don't immediately exit
+ Module['noExitRuntime'] = true;
+ return;
+ } else {
+ if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
+ throw e;
+ }
+ } finally {
+ calledMain = true;
+ }
+}
+
+
+
+
+function run(args) {
+ args = args || Module['arguments'];
+
+ if (preloadStartTime === null) preloadStartTime = Date.now();
+
+ if (runDependencies > 0) {
+ Module.printErr('run() called, but dependencies remain, so not running');
+ return;
+ }
+
+ preRun();
+
+ if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
+ if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame
+
+ function doRun() {
+ if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
+ Module['calledRun'] = true;
+
+ ensureInitRuntime();
+
+ preMain();
+
+ if (Module['_main'] && shouldRunNow) {
+ Module['callMain'](args);
+ }
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function() {
+ setTimeout(function() {
+ Module['setStatus']('');
+ }, 1);
+ if (!ABORT) doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+}
+Module['run'] = Module.run = run;
+
+function exit(status) {
+ ABORT = true;
+ EXITSTATUS = status;
+ STACKTOP = initialStackTop;
+
+ // exit the runtime
+ exitRuntime();
+
+ // TODO We should handle this differently based on environment.
+ // In the browser, the best we can do is throw an exception
+ // to halt execution, but in node we could process.exit and
+ // I'd imagine SM shell would have something equivalent.
+ // This would let us set a proper exit status (which
+ // would be great for checking test exit statuses).
+ // https://github.com/kripken/emscripten/issues/1371
+
+ // throw an exception to halt the current execution
+ throw new ExitStatus(status);
+}
+Module['exit'] = Module.exit = exit;
+
+function abort(text) {
+ if (text) {
+ Module.print(text);
+ Module.printErr(text);
+ }
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ throw 'abort() at ' + stackTrace();
+}
+Module['abort'] = Module.abort = abort;
+
+// {{PRE_RUN_ADDITIONS}}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+if (Module['noInitialRun']) {
+ shouldRunNow = false;
+}
+
+run();
+
+// {{POST_RUN_ADDITIONS}}
+
+
+
+
+
+
+// {{MODULE_ADDITIONS}}
+
+
+
+
+
+
+// ==========================================================
+// ========= / THE CODE COMPILED BY EMCC ENDS HERE ==========
+// ==========================================================
+
+asm$ = {
+ malloc: function(type, size) {
+ real_size = size * type.BYTES_PER_ELEMENT;
+ pointer = Module._malloc(real_size);
+ heap = new Uint8Array(Module.HEAPU8.buffer, pointer, real_size);
+ return {
+ asm$: true,
+ ptr: heap.byteOffset,
+ free: function() {
+ Module._free(this.ptr);
+ },
+ arr: new type(heap.buffer, heap.byteOffset, size),
+ size: size
+ };
+ },
+ cpy: function(dst, dst_offset, src, src_offset, size) {
+ if (typeof dst.asm$ != 'undefined') dst = dst.arr;
+ if (typeof src.asm$ != 'undefined') src = src.arr;
+ for (var i = 0; i < size; i++)
+ dst[dst_offset + i] = src[src_offset + i];
+ }
+};
+
+// void firdes_lowpass_f(float *output, int length, float cutoff_rate, window_t window)
+firdes_lowpass_f = Module.cwrap('firdes_lowpass_f', null, ['number', 'number', 'number', 'number']);
+
+// rational_resampler_ff_t rational_resampler_ff(float *input, float *output, int input_size, int interpolation, int decimation, float *taps, int taps_length, int last_taps_delay)
+rational_resampler_ff = Module.cwrap('rational_resampler_ff', 'struct', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']);
+
+
+rational_resampler_ff = function(pinput, poutput, input_length, interpolation, decimation, ptaps, taps_length, last_taps_delay) {
+ stackbase = STACKTOP;
+ STACKTOP += 4 * 3;
+ _rational_resampler_ff(stackbase, pinput, poutput, input_length, interpolation, decimation, ptaps, taps_length, last_taps_delay);
+ returnstruct = {
+ input_processed: getValue(stackbase, 'i32'),
+ output_size: getValue(stackbase + 4, 'i32'),
+ last_taps_delay: getValue(stackbase + 8, 'i32')
+ };
+ STACKTOP = stackbase;
+ return returnstruct;
+}
+
+sdrjs = {};
+
+sdrjs.WINDOW_BOXCAR = 0;
+sdrjs.WINDOW_BLACKMAN = 1;
+sdrjs.WINDOW_HAMMING = 2;
+
+//this will be impportant whil converting arrays
+//http://stackoverflow.com/questions/25839216/convert-float32array-to-int16array
+
+/*sdrjs.prototype.FirdesLowpassF=function(taps_length,transition_bw,window)
+{
+ this.calculate=function(){}
+ this.get_output=function(){}
+ this.get_output_heap=function(){}
+};*/
+
+
+sdrjs.ConvertI16_F = function(i16data) {
+ var f32data = new Float32Array(i16data.length);
+ for (var i = 0; i < i16data.length; i++) f32data[i] = i16data[i] / 32768;
+ return f32data;
+}
+
+ima_adpcm_codec = function(encode, pinput, poutput, input_length, state) {
+ myfunc = (encode) ? _encode_ima_adpcm_i16_u8 : _decode_ima_adpcm_u8_i16;
+ stackbase = STACKTOP;
+ STACKTOP += 4 * 2; //sizeof(int)*2
+ myfunc(stackbase, pinput, poutput, input_length, state.ptr);
+ state.arr[0] = getValue(stackbase + 0, 'i32');
+ state.arr[1] = getValue(stackbase + 4, 'i32');
+ STACKTOP = stackbase;
+};
+
+sdrjs.ImaAdpcm = function() {
+ this.BUFSIZE = 1024 * 64;
+ this.ima_adpcm_state = asm$.malloc(Int32Array, 2);
+ this.i16_buffer = asm$.malloc(Int16Array, this.BUFSIZE * 2);
+ this.u8_buffer = asm$.malloc(Uint8Array, this.BUFSIZE);
+ this.ima_adpcm_state.arr[0] = 0;
+ this.ima_adpcm_state.arr[1] = 0;
+
+ this.encode = function(data) {
+ //not_tested_yet
+ asm$.cpy(this.i16_buffer.arr, 0, data, 0, data.length);
+ ima_adpcm_codec(true, this.i16_buffer.ptr, this.u8_buffer.ptr, data.length, this.ima_adpcm_state);
+ out = new Uint8Array(data.length / 2);
+ asm$.cpy(out, 0, this.u8_buffer, 0, data.length / 2);
+ return out;
+ };
+
+ this.decode = function(data) {
+ asm$.cpy(this.u8_buffer.arr, 0, data, 0, data.length);
+ ima_adpcm_codec(false, this.u8_buffer.ptr, this.i16_buffer.ptr, data.length, this.ima_adpcm_state);
+ out = new Int16Array(data.length * 2);
+ asm$.cpy(out, 0, this.i16_buffer.arr, 0, data.length * 2);
+ return out;
+ };
+ this.reset = function() {
+ this.ima_adpcm_state.arr[0] = this.ima_adpcm_state.arr[1] = 0 | 0;
+ }
+};
+
+sdrjs.REBUFFER_FIXED = 0; //rebuffer should return arrays of fixed size
+sdrjs.REBUFFER_MAX = 1; //rebuffer should return arrays with a maximal size of the parameter size
+
+sdrjs.Rebuffer = function(size, mode) {
+ this.mode = mode;
+ this.size = size;
+ this.total_size = 0;
+ this.arrays = [];
+ this.last_arr = [];
+ this.last_arr_offset = 0;
+ this.push = function(data) {
+ this.total_size += data.length;
+ this.arrays.push(data);
+ };
+ this.remaining = function() {
+ var fixed_bufs_num = Math.floor(this.total_size / this.size);
+ if (!this.mode) return fixed_bufs_num;
+ else return fixed_bufs_num + (!!(this.total_size - fixed_bufs_num * this.size)); //if REBUFFER_MAX, add one if we could return one more buffer (smaller than the fixed size)
+ };
+ this.take = function() {
+ var a = this._take(); /*console.log(a);*/
+ return a;
+ };
+ this._take = function() {
+ var remain = this.size;
+ var offset = 0;
+ var obuf = new Float32Array(size);
+ //console.log("==== get new obuf ====", size);
+ while (remain) {
+ if (this.last_arr_offset == this.last_arr.length) {
+ if (this.arrays.length == 0) {
+ //console.log("this should not happen");
+ if (this.mode) //REBUFFER_MAX
+ {
+ this.total_size = 0;
+ return obuf.subarray(0, offset);
+ } else return new Float32Array(0); //REBUFFER_FIXED
+ }
+ //console.log("pick new last_arr");
+ this.last_arr = this.arrays.shift();
+ this.last_arr_offset = 0;
+ }
+ var rwithin = this.last_arr.length - this.last_arr_offset;
+ //console.log("b :: ","remain", remain, "rwithin",rwithin,"last_arr.length",this.last_arr.length,"larroffset",this.last_arr_offset,"offset",offset);
+ if (remain < rwithin) {
+ //console.log("remain < rwithin"); //seems problematic @Andris
+ for (var i = 0; i < remain; i++) obuf[offset++] = this.last_arr[this.last_arr_offset++];
+ remain = 0;
+ } else {
+ //console.log("remain > rwithin");
+ for (var i = 0; i < rwithin; i++) obuf[offset++] = this.last_arr[this.last_arr_offset++];
+ remain -= rwithin;
+ }
+ //console.log("e :: ","remain", remain, "rwithin",rwithin,"last_arr.length",this.last_arr.length,"larroffset",this.last_arr_offset,"offset",offset);
+ }
+
+ this.total_size -= obuf.length;
+ //console.log("return _take");
+ return obuf;
+ };
+};
+
+sdrjs.RationalResamplerFF = function(interpolation, decimation, transition_bw, window) {
+ this.interpolation = interpolation;
+ this.decimation = decimation;
+ this.transition_bw = (typeof transition_bw == 'undefined') ? 0.05 : transition_bw;
+ this.window = (typeof window == 'undefined') ? 1 : window;
+ this.buffer_size = 1024 * 512;
+ this.output_buffer_size = Math.floor((this.buffer_size * interpolation) / decimation);
+ this.input_buffer = asm$.malloc(Float32Array, this.buffer_size);
+ this.output_buffer = asm$.malloc(Float32Array, this.output_buffer_size);
+ //Calculate filter
+ this.taps_length = Math.floor(4 / this.transition_bw);
+ this.taps = asm$.malloc(Float32Array, this.taps_length);
+ var cutoff_for_interpolation = 1.0 / interpolation;
+ var cutoff_for_decimation = 1.0 / decimation;
+ var cutoff = (cutoff_for_interpolation < cutoff_for_decimation) ? cutoff_for_interpolation : cutoff_for_decimation; //get the lower
+ firdes_lowpass_f(this.taps.ptr, this.taps_length, cutoff / 2, window);
+
+ this.remain = 0;
+ this.remain_offset = 0;
+ this.last_taps_delay = 0;
+
+ this.process = function(input) {
+
+ if (input.length + this.remain > this.buffer_size) {
+ return new Float32Array(0);
+ console.log("sdrjs.RationalResamplerFF: critical audio buffering error"); //This should not happen...
+ /* console.log("RationalResamplerFF: splitting..."); //TODO: this branch has not been checked
+ output_buffers=Array();
+ new_buffer_size=this.buffer_size/2;
+ i=0;
+ //process the input in chunks of new_buffer_size, and add the output product Float32Array-s to output_buffers.
+ while((i++)*new_buffer_size<=input.length)
+ {
+ output_buffers.push(this._process_noheapcheck(input.subarray(i*new_buffer_size,(i+1)*new_buffer_size)));
+ }
+ //add up the sizes of the output_buffer-s.
+ total_output_length=0;
+ output_buffers.forEach(function(a){total_output_length+=a.length;});
+ //create one big buffer from concatenating the output_buffer-s
+ output=new Float32Array(total_output_length);
+ output_pos=0;
+ output_buffers.forEach(function(a){
+ asm$.cpy(output,output_pos,a,0,a.length);
+ output_pos+=a.length;
+ });
+ return output;*/
+ } else return this._process_noheapcheck(input);
+ };
+ this._process_noheapcheck = function(input) //if we are sure we have enough space in the buffers
+ {
+ asm$.cpy(this.input_buffer.arr, 0, this.input_buffer.arr, this.remain_offset, this.remain);
+ asm$.cpy(this.input_buffer.arr, this.remain, input, 0, input.length);
+ var total_input_size = input.length + this.remain;
+ d = rational_resampler_ff(this.input_buffer.ptr, this.output_buffer.ptr, total_input_size, this.interpolation, this.decimation, this.taps.ptr, this.taps_length, this.last_taps_delay);
+ this.last_taps_delay = d.last_taps_delay;
+ this.remain = total_input_size - d.input_processed;
+ this.remain_offset = d.input_processed;
+ var output_copy_arr = new Float32Array(d.output_size);
+ asm$.cpy(output_copy_arr, 0, this.output_buffer.arr, 0, d.output_size);
+ return output_copy_arr;
+ };
+};
+
+
+_sdrjs_logb = function(what) {
+ document.body.innerHTML += what + "
"; +} + + +function test_firdes_lowpass_f_original() { + //Original method explained over here: + //http://kapadia.github.io/emscripten/2013/09/13/emscripten-pointers-and-pointers.html + _sdrjs_logb("test_firdes_lowpass_f_original():"); + _sdrjs_logb("Now designing FIR filter with firdes_lowpass_f in sdr.js..."); + _sdrjs_logb("output should be the same as: csdr firdes_lowpass_f 0.1 101 HAMMING"); + + var outputSize = 101 * 4; + var outputPtr = Module._malloc(outputSize); + var outputHeap = new Uint8Array(Module.HEAPU8.buffer, outputPtr, outputSize); + firdes_lowpass_f(outputHeap.byteOffset, 101, 0.1, 2); + var output = new Float32Array(outputHeap.buffer, outputHeap.byteOffset, 101); + outputStr = String(); + for (i = 0; i < output.length; i++) outputStr += output[i].toFixed(6) + ", "; + Module._free(outputHeap.byteOffset); + _sdrjs_logb(outputStr); +} + + +function test_firdes_lowpass_f_new() { + //This is much simpler, using asm$ + _sdrjs_logb("test_firdes_lowpass_f_new():"); + _sdrjs_logb("Now designing FIR filter with firdes_lowpass_f in sdr.js..."); + _sdrjs_logb("output should be the same as: csdr firdes_lowpass_f 0.1 101 HAMMING"); + + output = asm$.malloc(Float32Array, 101); + firdes_lowpass_f(output.ptr, 101, 0.1, 2); + outputStr = String(); + for (i = 0; i < output.arr.length; i++) outputStr += (output.arr[i]).toFixed(6) + ", "; + output.free(); + _sdrjs_logb(outputStr); +} + +function test_struct_return_value() { + v = STACKTOP; + STACKTOP += 4 * 3; + _shift_addition_init(v, 0.2); + console.log( + "sinval=", getValue(v, 'float'), + "cosval=", getValue(v + 4, 'float'), + "rate=", getValue(v + 8, 'float') + ); + STACKTOP = v; +} \ No newline at end of file diff --git a/htdocs/upgrade.html b/htdocs/upgrade.html index b9a498d..09b5aab 100644 --- a/htdocs/upgrade.html +++ b/htdocs/upgrade.html @@ -1,21 +1,23 @@OpenWebRX
We're working on the code right now, so the application might fail. diff --git a/htdocs/openwebrx.css b/htdocs/openwebrx.css old mode 100755 new mode 100644 index 15993fc..b3dc9b4 --- a/htdocs/openwebrx.css +++ b/htdocs/openwebrx.css @@ -1,20 +1,22 @@ /* -OpenWebRX (c) Copyright 2013-2014 Andras Retzler
"; + var wls=e("openwebrx-log-scroll"); + wls.scrollTop=wls.scrollHeight; //scroll to bottom } var audio_context; @@ -1065,54 +1122,105 @@ var audio_initialized=0; var audio_received = Array(); var audio_buffer_index = 0; -var audio_resampler; +var audio_resampler=new sdrjs.RationalResamplerFF(4,1); +var audio_codec=new sdrjs.ImaAdpcm(); +var audio_compression="unknown"; var audio_node; //var audio_received_sample_rate = 48000; var audio_input_buffer_size; // Optimalise these if audio lags or is choppy: -var audio_buffer_size = 8192;//2048 was choppy -var audio_buffer_maximal_length_sec=1.7; //actual number of samples are calculated from sample rate -var audio_flush_interval_ms=250; //the interval in which audio_flush() is called +var audio_buffer_size = 4096;//2048 was choppy +var audio_buffer_maximal_length_sec=3; //actual number of samples are calculated from sample rate +var audio_buffer_decrease_to_on_overrun_sec=2.2; +var audio_flush_interval_ms=500; //the interval in which audio_flush() is called var audio_prepared_buffers = Array(); +var audio_rebuffer = new sdrjs.Rebuffer(audio_buffer_size,sdrjs.REBUFFER_FIXED); var audio_last_output_buffer = new Float32Array(audio_buffer_size); var audio_last_output_offset = 0; var audio_buffering = false; -var audio_buffering_fill_to=10; //on audio underrun we wait until this n*audio_buffer_size samples are present +//var audio_buffering_fill_to=4; //on audio underrun we wait until this n*audio_buffer_size samples are present + //tnx to the hint from HA3FLT, now we have about half the response time! (original value: 10) + +function gain_ff(gain_value,data) //great! solved clicking! will have to move to sdr.js +{ + for(var i=0;i
"+(audio_buffer_current_size_debug*kbps_mult/audio_debug_time_since_last_call).toFixed(0)+" kbps ("+ + // (audio_buffer_all_size_debug*kbps_mult/audio_debug_time_taken).toFixed(1)+" kbps avg.), feed at "+ + // ((audio_buffer_current_count_debug*audio_buffer_size)/audio_debug_time_taken).toFixed(1)+" sps output"; + + var audio_speed_value=audio_buffer_current_size_debug*kbps_mult/audio_debug_time_since_last_call; + progressbar_set(e("openwebrx-bar-audio-speed"),audio_speed_value/500000,"Audio stream ["+(audio_speed_value/1000).toFixed(0)+" kbps]",false); + + var audio_output_value=(audio_buffer_current_count_debug*audio_buffer_size)/audio_debug_time_taken; + progressbar_set(e("openwebrx-bar-audio-output"),audio_output_value/55000,"Audio output ["+(audio_output_value/1000).toFixed(1)+" ksps]",audio_output_value>55000||audio_output_value<10000); + + audio_buffer_progressbar_update(); + + var network_speed_value=debug_ws_data_received/audio_debug_time_taken; + progressbar_set(e("openwebrx-bar-network-speed"),network_speed_value*8/2000,"Network usage ["+(network_speed_value*8).toFixed(1)+" kbps]",false); + audio_buffer_current_size_debug=0; + + if(waterfall_measure_minmax) waterfall_measure_minmax_print(); } // ======================================================== // ======================= PANELS ======================= // ======================================================== -panel_margin=10; +panel_margin=5.9; function pop_bottommost_panel(from) { @@ -1608,8 +1776,19 @@ function pop_bottommost_panel(from) return to_return; } +function toggle_panel(what) +{ + var item=e(what); + if(item.openwebrxDisableClick) return; + item.openwebrxHidden=!item.openwebrxHidden; + place_panels(); + item.openwebrxDisableClick=true; + window.setTimeout(function(){item.openwebrxDisableClick=false;},100); +} + function place_panels() { + var hoffset=0; //added this because the first panel should not have such great gap below var left_col=[]; var right_col=[]; var plist=e("openwebrx-panels-container").children; @@ -1618,33 +1797,61 @@ function place_panels() c=plist[i]; if(c.className=="openwebrx-panel") { + if(c.openwebrxHidden) + { + c.style.display="none"; + continue; + } + c.style.display="block"; + c.openwebrxPanelTransparent=(!!c.dataset.panelTransparent); newSize=c.dataset.panelSize.split(","); if (c.dataset.panelPos=="left") { left_col.push(c); } else if(c.dataset.panelPos=="right") { right_col.push(c); } c.style.width=newSize[0]+"px"; c.style.height=newSize[1]+"px"; - c.style.margin=panel_margin.toString()+"px"; + if(!c.openwebrxPanelTransparent) c.style.margin=panel_margin.toString()+"px"; + else c.style.marginLeft=panel_margin.toString()+"px"; c.openwebrxPanelWidth=parseInt(newSize[0]); c.openwebrxPanelHeight=parseInt(newSize[1]); } } - y=0; + y=hoffset; //was y=0 before hoffset while(left_col.length>0) { p=pop_bottommost_panel(left_col); p.style.left="0px"; p.style.bottom=y.toString()+"px"; p.style.visibility="visible"; - y+=p.openwebrxPanelHeight+3*panel_margin; + y+=p.openwebrxPanelHeight+((p.openwebrxPanelTransparent)?0:3)*panel_margin; } - y=0; + y=hoffset; while(right_col.length>0) { p=pop_bottommost_panel(right_col); - p.style.right="10px"; + p.style.right=(e("webrx-canvas-container").offsetWidth-e("webrx-canvas-container").clientWidth).toString()+"px"; //get scrollbar width p.style.bottom=y.toString()+"px"; p.style.visibility="visible"; - y+=p.openwebrxPanelHeight+3*panel_margin; + y+=p.openwebrxPanelHeight+((p.openwebrxPanelTransparent)?0:3)*panel_margin; } } +function progressbar_set(obj,val,text,over) +{ + if (val<0.05) val=0; + if (val>1) val=1; + var innerBar=null; + var innerText=null; + for(var i=0;i
+ 
+
+
+
+
diff --git a/htdocs/sdr.js b/htdocs/sdr.js
new file mode 100644
index 0000000..dcc9229
--- /dev/null
+++ b/htdocs/sdr.js
@@ -0,0 +1,11683 @@
+/*
+This file is part of libcsdr.
+
+ Copyright (c) Andras Retzler, HA7ILM
+
+ There are no client slots left on this server.
+
+
+ Please wait until a client disconnects.
We will try to reconnect in 30 seconds... +
+ We will try to reconnect in 30 seconds... +
"; +} + + +function test_firdes_lowpass_f_original() { + //Original method explained over here: + //http://kapadia.github.io/emscripten/2013/09/13/emscripten-pointers-and-pointers.html + _sdrjs_logb("test_firdes_lowpass_f_original():"); + _sdrjs_logb("Now designing FIR filter with firdes_lowpass_f in sdr.js..."); + _sdrjs_logb("output should be the same as: csdr firdes_lowpass_f 0.1 101 HAMMING"); + + var outputSize = 101 * 4; + var outputPtr = Module._malloc(outputSize); + var outputHeap = new Uint8Array(Module.HEAPU8.buffer, outputPtr, outputSize); + firdes_lowpass_f(outputHeap.byteOffset, 101, 0.1, 2); + var output = new Float32Array(outputHeap.buffer, outputHeap.byteOffset, 101); + outputStr = String(); + for (i = 0; i < output.length; i++) outputStr += output[i].toFixed(6) + ", "; + Module._free(outputHeap.byteOffset); + _sdrjs_logb(outputStr); +} + + +function test_firdes_lowpass_f_new() { + //This is much simpler, using asm$ + _sdrjs_logb("test_firdes_lowpass_f_new():"); + _sdrjs_logb("Now designing FIR filter with firdes_lowpass_f in sdr.js..."); + _sdrjs_logb("output should be the same as: csdr firdes_lowpass_f 0.1 101 HAMMING"); + + output = asm$.malloc(Float32Array, 101); + firdes_lowpass_f(output.ptr, 101, 0.1, 2); + outputStr = String(); + for (i = 0; i < output.arr.length; i++) outputStr += (output.arr[i]).toFixed(6) + ", "; + output.free(); + _sdrjs_logb(outputStr); +} + +function test_struct_return_value() { + v = STACKTOP; + STACKTOP += 4 * 3; + _shift_addition_init(v, 0.2); + console.log( + "sinval=", getValue(v, 'float'), + "cosval=", getValue(v + 4, 'float'), + "rate=", getValue(v + 8, 'float') + ); + STACKTOP = v; +} \ No newline at end of file diff --git a/htdocs/upgrade.html b/htdocs/upgrade.html index b9a498d..09b5aab 100644 --- a/htdocs/upgrade.html +++ b/htdocs/upgrade.html @@ -1,21 +1,23 @@