GSP FX Binary - Forex Strategies - Forex Resources - Forex ...

gdbstub 0.4: An ergonomic, #![no_std] implementation of the GDB Remote Serial Protocol in Rust

crates.io | docs | repo
An ergonomic and easy-to-integrate implementation of the GDB Remote Serial Protocol in Rust, with full #![no_std] support. gdbstub makes extensive use of Rust's powerful type system + generics to enforce protocol invariants at compile time, minimizing the number of tricky protocol details end users have to worry about.
A lot has changed since my last post announcing gdbstub 0.2!
Version 0.4 includes a major API overhaul, tons of internal optimizations, and a slew of new GDB protocol features, making it the fastest, leanest, and most featureful release of gdbstub yet!
It's been absolutely incredible having so many people contribute to the library, and seeing gdbstub being used in all sorts of cool projects. Thank you for all the support!
By the way, if you're taking part in Hacktoberfest this year, there are plenty of ways to contribute to gdbstub. There's a whole laundry list of protocol extensions and new architectures to support, so check out the issue tracker and consider lending a hand!
Cheers!
submitted by daniel5151 to rust [link] [comments]

Help Troubleshooting my Factorio Install

Factorio crashes on startup. I don't get to the start menu even. Things we've tried:
I have attached the log file below. I don't know what it means but perhaps one of you engineers can help me parse it.

Here's our log file return:
0.000 2020-10-27 11:20:33; Factorio 1.0.0 (build 54889, mac, steam)
0.000 Operating system: macOS 10.13.6
0.000 Program arguments: "/Volumes/Home/Library/Application Support/Steam/steamapps/common/Factorio/factorio.app/Contents/MacOS/factorio"
0.000 Read data path: /Volumes/Home/Library/Application Support/Steam/steamapps/common/Factorio/factorio.app/Contents/data
0.000 Write data path: /Volumes/Home/Library/Application Support/factorio [846099/953541MB]
0.000 Binaries path: /Volumes/Home/Library/Application Support/Steam/steamapps/common/Factorio/factorio.app/Contents
0.023 System info: [CPU: Intel(R) Core(TM) i5-8400 CPU @ 2.80GHz, 6 cores, RAM: 16384 MB]
0.023 Display options: [FullScreen: 0] [VSync: 1] [UIScale: automatic (100.0%)] [Native DPI: 1] [Screen: 255] [Special: lmW] [Lang: en]
0.066 Available displays: 1
0.066 [0]: SA300/SA350 - {[0,0], 1920x1080, SDL_PIXELFORMAT_ARGB8888, 60Hz, 0xb41d501(0x02)}
0.109 Initialised OpenGL:[0] NVIDIA GeForce 210 OpenGL Engine; driver: 3.3 NVIDIA-10.33.0 387.10.10.10.40.105
0.109 [Extensions] s3tc:yes; KHR_debug:NO; ARB_clear_texture:NO, ARB_copy_image:NO
0.109 [Version] 3.3
0.109 Graphics settings preset: medium-with-low-vram
0.109 Dedicated video memory size 1024 MB (detected from GeForce 210; VendorID: 0x1022600)
0.208 Graphics options: [Graphics quality: normal] [Video memory usage: high] [Light scale: 25%] [DXT: low-quality] [Color: 32bit]
0.208 [Max threads (load/render): 32/6] [Max texture size: 4096] [Tex.Stream.: 1] [Rotation quality: low] [Other: sTDCwt] [B:0,C:0,S:100]
0.239 [Audio] Backend:default; Depth:16, Channel:2, Frequency:44100; MixerQuality:linear
0.410 Loading mod core 0.0.0 (data.lua)
0.527 Loading mod base 1.0.0 (data.lua)
0.802 Loading mod base 1.0.0 (data-updates.lua)
0.953 Checksum for core: 2630831588
0.953 Checksum of base: 3509992273
1.153 Prototype list checksum: 3301461508
1.229 Loading sounds...
1.263 Info PlayerData.cpp:70: Local player-data.json unavailable
1.263 Info PlayerData.cpp:73: Cloud player-data.json available, timestamp 1599183581
1.400 Initial atlas bitmap size is 4096
1.405 Created atlas bitmap 4096x4096 [none]
1.409 Created atlas bitmap 4096x4096 [none]
1.411 Created atlas bitmap 4096x4084 [none]
1.413 Created atlas bitmap 4096x4092 [none]
1.416 Created atlas bitmap 4096x4096 [none]
1.418 Created atlas bitmap 4096x4092 [none]
1.418 Created atlas bitmap 4096x504 [none]
1.418 Created atlas bitmap 4096x2120 [decal]
1.421 Created atlas bitmap 4096x4064 [low-object]
1.421 Created atlas bitmap 4096x1856 [low-object]
1.421 Created atlas bitmap 4096x2272 [mipmap, linear-minification, linear-magnification, linear-mip-level]
1.423 Created atlas bitmap 4096x4096 [terrain, mipmap, linear-minification, linear-mip-level]
1.423 Created atlas bitmap 4096x3104 [terrain, mipmap, linear-minification, linear-mip-level]
1.423 Created atlas bitmap 4096x1632 [terrain-effect-map, mipmap, linear-minification, linear-mip-level]
1.423 Created atlas bitmap 4096x1664 [smoke, mipmap, linear-minification, linear-magnification]
1.423 Created atlas bitmap 4096x928 [mipmap]
1.423 Created atlas bitmap 4096x2336 [icon, not-compressed, mipmap, linear-minification, linear-magnification, linear-mip-level]
1.423 Created atlas bitmap 2048x224 [icon-background, not-compressed, mipmap, linear-minification, linear-magnification, linear-mip-level, ]
1.423 Created atlas bitmap 4096x828 [alpha-mask]
1.428 Created atlas bitmap 4096x4088 [shadow, linear-magnification, alpha-mask]
1.431 Created atlas bitmap 4096x4096 [shadow, linear-magnification, alpha-mask]
1.433 Created atlas bitmap 4096x4080 [shadow, linear-magnification, alpha-mask]
1.434 Created atlas bitmap 4096x3272 [shadow, linear-magnification, alpha-mask]
1.434 Created atlas bitmap 4096x1312 [shadow, mipmap, linear-magnification, alpha-mask]
1.450 Created virtual atlas pages 4096x4096x2
2.304 Error CrashHandler.cpp:621: Received SIGSEGV
Factorio crashed. Generating symbolized stacktrace, please wait ...
#1 0x00000001039bc8b2 in Logger::logStacktrace(StackTraceInfo*) + 0x12
#2 0x0000000102e90899 in CrashHandler::writeStackTrace(CrashHandler::CrashReason) + 0xb9
#3 0x00000001039a00e4 in CrashHandler::commonSignalHandler(int) + 0x74
#4 0x000000010399f5e9 in CrashHandler::SignalHandler(int) + 0x9
#5 0x00007fff6593ef5a in _sigtramp + 0x1a
#6 0x000000010e0a4765 in + 0x0
#7 0x000000010e0a384a in + 0x0
#8 0x000000010e0a3187 in + 0x0
#9 0x000000010e494161 in gldBlitFramebufferData + 0x2c55c6
#10 0x000000010e492d26 in gldBlitFramebufferData + 0x2c418b
#11 0x000000010e492d26 in gldBlitFramebufferData + 0x2c418b
#12 0x000000010e492d26 in gldBlitFramebufferData + 0x2c418b
#13 0x000000010e492d26 in gldBlitFramebufferData + 0x2c418b
#14 0x000000010e492d26 in gldBlitFramebufferData + 0x2c418b
#15 0x000000010e492377 in gldBlitFramebufferData + 0x2c37dc
#16 0x000000010e0a44cc in + 0x0
#17 0x000000010e123ec8 in gldReadTextureData + 0x311a4
#18 0x000000010df0acf1 in + 0x0
#19 0x000000010df0bd5e in + 0x0
#20 0x000000010df11957 in + 0x0
#21 0x000000010df11ff0 in + 0x0
#22 0x000000010e1de080 in gldBlitFramebufferData + 0xf4e5
#23 0x000000010e1de7f3 in gldBlitFramebufferData + 0xfc58
#24 0x000000010e1dee0e in gldBlitFramebufferData + 0x10273
#25 0x000000010e0f21b5 in gldUnbindPipelineProgram + 0x97a
#26 0x000000010e1ddc83 in gldBlitFramebufferData + 0xf0e8
#27 0x000000010e1cc241 in gldUpdateDispatch + 0x354
#28 0x00007fff47e09b33 in gleDoDrawDispatchCoreGL3 + 0x259
#29 0x00007fff47dbad07 in gleDrawArraysOrElements_Entries_Body + 0x77
#30 0x00007fff47db41d0 in glDrawElements_GL3Exec + 0xd2
#31 0x0000000102eabe4f in GraphicsInterfaceOpenGL::drawIndexed(DrawBindings const&, VideoBuffer*, VideoBuffer*, unsigned int, unsigned int) + 0xbf
#32 0x0000000102e1e8f2 in TextureProcessor::testGpuAcceleratedCompression(GraphicsInterface&) + 0xbd2
#33 0x0000000102e10f8a in AtlasSystem::createTextureProcessor(unsigned int) + 0x9a
#34 0x0000000102e0e9b5 in AtlasSystem::loadSprites(bool) + 0x165
#35 0x0000000102e1fb2c in AtlasSystem::tryLoadSpritesWithFallbackToMinimalMode(bool) + 0x2c
#36 0x0000000102df02ad in AtlasSystem::build() + 0x20d
#37 0x000000010290abef in GlobalContext::init(bool, bool, bool, std::__1::optional) + 0x264f
#38 0x00000001029056f9 in MainLoop::run(Filesystem::Path const&, Filesystem::Path const&, bool, bool, std::__1::function, Filesystem::Path const&, MainLoop::HeavyMode) + 0xe9
#39 0x000000010278ec2b in main + 0x1282b
Stack trace logging done
2.322 Error Util.cpp:97: Unexpected error occurred. If you're running the latest version of the game you can help us solve the problem by posting the contents of the log file on the Factorio forums.
Please also include the save file(s), any mods you may be using, and any steps you know of to reproduce the crash.
submitted by derekvonzarovich2 to factorio [link] [comments]

ResultsFileName = 0×0 empty char array Why? Where are my results?

Edit: Turns out I was missing a needed toolbox.
Hello,
I am not getting any errors and I do not understand why I am not getting any output. I am trying to batch process a large number of ecg signals. Below is my code and the two relevant functions. Any help greatly appreciated. I am very new.
d = importSections("Dx_sections.csv"); % set the number of recordings n = height(d); % settings HRVparams = InitializeHRVparams('test_physionet') for ii = 1:n % Import waveform (ECG) [record, signals] = read_edf(strcat(d.PID(ii), '/baseline.edf')); myecg = record.ECG; Ann = []; [HRVout, ResultsFileName] = Main_HRV_Analysis(myecg,'','ECGWaveform',HRVparams) end function [HRVout, ResultsFileName ] = Main_HRV_Analysis(InputSig,t,InputFormat,HRVparams,subID,ann,sqi,varargin) % ====== HRV Toolbox for PhysioNet Cardiovascular Signal Toolbox ========= % % Main_HRV_Analysis(InputSig,t,InputFormat,HRVparams,subID,ann,sqi,varargin) % OVERVIEW: % % INPUT: % InputSig - Vector containing RR intervals data (in seconds) % or ECG/PPG waveform % t - Time indices of the rr interval data (seconds) or % leave empty for ECG/PPG input % InputFormat - String that specifiy if the input vector is: % 'RRIntervals' for RR interval data % 'ECGWaveform' for ECG waveform % 'PPGWaveform' for PPG signal % HRVparams - struct of settings for hrv_toolbox analysis that can % be obtained using InitializeHRVparams.m function % HRVparams = InitializeHRVparams(); % % % OPTIONAL INPUTS: % subID - (optional) string to identify current subject % ann - (optional) annotations of the RR data at each point % indicating the type of the beat % sqi - (optional) Signal Quality Index; Requires a % matrix with at least two columns. Column 1 % should be timestamps of each sqi measure, and % Column 2 should be SQI on a scale from 0 to 1. % Use InputSig, Type pairs for additional signals such as ABP % or PPG signal. The input signal must be a vector containing % signal waveform and the Type: 'ABP' and\or 'PPG'. % % OUTPUS: % results - HRV time and frequency domain metrics as well % as AC and DC, SDANN and SDNNi % ResultsFileName - Name of the file containing the results % % NOTE: before running this script review and modifiy the parameters % in "initialize_HRVparams.m" file accordingly with the specific % of the new project (see the readme.txt file for further details) % EXAMPLES % - rr interval input % Main_HRV_Analysis(RR,t,'RRIntervals',HRVparams) % - ECG wavefrom input % Main_HRV_Analysis(ECGsig,t,'ECGWavefrom',HRVparams,'101') % - ECG waveform and also ABP and PPG waveforms % Main_HRV_Analysis(ECGsig,t,'ECGWaveform',HRVparams,[],[],[], abpSig, % 'ABP', ppgSig, 'PPG') % % DEPENDENCIES & LIBRARIES: % HRV Toolbox for PhysioNet Cardiovascular Signal Toolbox % https://github.com/cliffordlab/PhysioNet-Cardiovascular-Signal-Toolbox % % REFERENCE: % Vest et al. "An Open Source Benchmarked HRV Toolbox for Cardiovascular % Waveform and Interval Analysis" Physiological Measurement (In Press), 2018. % % REPO: % https://github.com/cliffordlab/PhysioNet-Cardiovascular-Signal-Toolbox % ORIGINAL SOURCE AND AUTHORS: % This script written by Giulia Da Poian % Dependent scripts written by various authors % (see functions for details) % COPYRIGHT (C) 2018 % LICENSE: % This software is offered freely and without warranty under % the GNU (v3 or later) public license. See license file for % more information %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if nargin < 4 error('Wrong number of input arguments') end if nargin < 5 subID = '0000'; end if nargin < 6 ann = []; end if nargin < 7 sqi = []; end if length(varargin) == 1 || length(varargin) == 3 error('Incomplete Signal-Type pair') elseif length(varargin) == 2 extraSigType = varargin(2); extraSig = varargin{1}; elseif length(varargin) == 4 extraSigType = [varargin(2) varargin(4)]; extraSig = [varargin{1} varargin{3}]; end if isa(subID,'cell'); subID = string(subID); end % Control on signal length if (strcmp(InputFormat, 'ECGWaveform') && length(InputSig)/HRVparams.Fs< HRVparams.windowlength) ... || (strcmp(InputFormat, 'PPGWaveform') && length(InputSig)/HRVparams.Fs 300 s VLF = [0.0033 .04]; % Requires at least 300 s window LF = [.04 .15]; % Requires at least 25 s window HF = [0.15 0.4]; % Requires at least 7 s window HRVparams.freq.limits = [ULF; VLF; LF; HF]; HRVparams.freq.zero_mean = 1; % Default: 1, Option for subtracting the mean from the input data HRVparams.freq.method = 'lomb'; % Default: 'lomb' % Options: 'lomb', 'burg', 'fft', 'welch' HRVparams.freq.plot_on = 0; % The following settings are for debugging spectral analysis methods HRVparams.freq.debug_sine = 0; % Default: 0, Adds sine wave to tachogram for debugging HRVparams.freq.debug_freq = 0.15; % Default: 0.15 HRVparams.freq.debug_weight = .03; % Default: 0.03 % Lomb: HRVparams.freq.normalize_lomb = 0; % Default: 0 % 1 = Normalizes Lomb Periodogram, % 0 = Doesn't normalize % Burg: (not recommended) HRVparams.freq.burg_poles = 15; % Default: 15, Number of coefficients % for spectral estimation using the Burg % method (not recommended) % The following settings are only used when the user specifies spectral % estimation methods that use resampling : 'welch','fft', 'burg' HRVparams.freq.resampling_freq = 7; % Default: 7, Hz HRVparams.freq.resample_interp_method = 'cub'; % Default: 'cub' % 'cub' = cublic spline method % 'lin' = linear spline method HRVparams.freq.resampled_burg_poles = 100; % Default: 100 %% 11. SDANN and SDNNI Analysis Settings HRVparams.sd.on = 1; % Default: 1, SD analysis 1=On or 0=Off HRVparams.sd.segmentlength = 300; % Default: 300, windows length in seconds %% 12. PRSA Analysis Settings HRVparams.prsa.on = 1; % Default: 1, PRSA Analysis 1=On or 0=Off HRVparams.prsa.win_length = 30; % Default: 30, The length of the PRSA signal % before and after the anchor points % (the resulting PRSA has length 2*L) HRVparams.prsa.thresh_per = 20; % Default: 20%, Percent difference that one beat can % differ from the next in the prsa code HRVparams.prsa.plot_results = 0; % Default: 0 HRVparams.prsa.scale = 2; % Default: 2, scale parameter for wavelet analysis (to compute AC and DC) %% 13. Peak Detection Settings % The following settings are for jqrs.m HRVparams.PeakDetect.REF_PERIOD = 0.250; % Default: 0.25 (should be 0.15 for FECG), refractory period in sec between two R-peaks HRVparams.PeakDetect.THRES = .6; % Default: 0.6, Energy threshold of the detector HRVparams.PeakDetect.fid_vec = []; % Default: [], If some subsegments should not be used for finding the optimal % threshold of the P&T then input the indices of the corresponding points here HRVparams.PeakDetect.SIGN_FORCE = []; % Default: [], Force sign of peaks (positive value/negative value) HRVparams.PeakDetect.debug = 0; % Default: 0 HRVparams.PeakDetect.ecgType = 'MECG'; % Default : MECG, options (adult MECG) or featl ECG (fECG) HRVparams.PeakDetect.windows = 15; % Befautl: 15,(in seconds) size of the window onto which to perform QRS detection %% 14. Entropy Settings % Multiscale Entropy HRVparams.MSE.on = 1; % Default: 1, MSE Analysis 1=On or 0=Off HRVparams.MSE.windowlength = []; % Default: [], windows size in seconds, default perform MSE on the entire signal HRVparams.MSE.increment = []; % Default: [], window increment HRVparams.MSE.RadiusOfSimilarity = 0.15; % Default: 0.15, Radius of similarity (% of std) HRVparams.MSE.patternLength = 2; % Default: 2, pattern length HRVparams.MSE.maxCoarseGrainings = 20; % Default: 20, Maximum number of coarse-grainings % SampEn an ApEn HRVparams.Entropy.on = 1; % Default: 1, MSE Analysis 1=On or 0=Off HRVparams.Entropy.RadiusOfSimilarity = 0.15; % Default: 0.15, Radius of similarity (% of std) HRVparams.Entropy.patternLength = 2; % Default: 2, pattern length %% 15. DFA Settings HRVparams.DFA.on = 1; % Default: 1, DFA Analysis 1=On or 0=Off HRVparams.DFA.windowlength = []; % Default [], windows size in seconds, default perform DFA on the entair signal HRVparams.DFA.increment = []; % Default: [], window increment HRVparams.DFA.minBoxSize = 4 ; % Default: 4, Smallest box width HRVparams.DFA.maxBoxSize = []; % Largest box width (default in DFA code: signal length/4) HRVparams.DFA.midBoxSize = 16; % Medium time scale box width (default in DFA code: 16) %% 16. Poincaré plot HRVparams.poincare.on = 1; % Default: 1, Poincare Analysis 1=On or 0=Off %% 17. Heart Rate Turbulence (HRT) - Settings HRVparams.HRT.on = 1; % Default: 1, HRT Analysis 1=On or 0=Off HRVparams.HRT.BeatsBefore = 2; % Default: 2, # of beats before PVC HRVparams.HRT.BeatsAfter = 16; % Default: 16, # of beats after PVC and CP HRVparams.HRT.GraphOn = 0; % Default: 0, do not plot HRVparams.HRT.windowlength = 24; % Default 24h, windows size in hours HRVparams.HRT.increment = 24; % Default 24h, sliding window increment in hours HRVparams.HRT.filterMethod = 'mean5before'; % Default mean5before, HRT filtering option %% 18. Output Settings HRVparams.gen_figs = 0; % Generate figures HRVparams.save_figs = 0; % Save generated figures if HRVparams.save_figs == 1 HRVparams.gen_figs = 1; end % Format settings for HRV Outputs HRVparams.output.format = 'csv'; % 'csv' - creates csv file for output % 'mat' - creates .mat file for output HRVparams.output.separate = 0; % Default : 1 = separate files for each subject % 0 = all results in one file HRVparams.output.num_win = []; % Specify number of lowest hr windows returned % leave blank if all windows should be returned % Format settings for annotations generated HRVparams.output.ann_format = 'binary'; % 'binary' = binary annotation file generated % 'csv' = ASCII CSV file generated end 
submitted by MisuzBrisby to matlab [link] [comments]

Video Encoding in Simple Terms

Video Encoding in Simple Terms
Nowadays, it is difficult to imagine a field of human activity, in which, in one way or another, digital video has not entered. We watch it on TV, mobile devices, and stationary computers; we record it with digital cameras ourselves, or we encounter it on the roads (unpleasant, but true), in stores, hospitals, schools and universities, and in industrial enterprises of various profiles. As a consequence, words and terms that are directly related to the digital representation of video information are becoming more firmly and widely embedded in our lives. From time to time, questions arise in this area. What are the differences between various devices or programs that we use to encode/ decode digital video data, and what do they do? Which of these devices/ programs are better or worse, and in which aspects? What do all these endless MPEG-2, H.264 / AVC, VP9, H.265 / HEVC, etc. mean? Let’s try to understand.

A very brief historical reference

The first generally accepted video compression standard MPEG-2 was finally adopted in 1996, after which a rapid development of digital satellite television began. The next standard was MPEG-4 part 10 (H.264 / AVC), which provides twice the degree of video data compression. It was adopted in 2003, which led to the development of DVB-T/ C systems, Internet TV and the emergence of a variety of video sharing and video communication services. From 2010 to 2013, the Joint Collaborative Team on Video Coding (JCT-VC) was intensively working to create the next video compression standard, which was called High Efficient Video Coding (HEVC) by the developers; it ensured the following twofold increase in the compression ratio of digital video data. This standard was approved in 2013. That same year, the VP9 standard, developed by Google, was adopted, which was supposed to not yield to HEVC in its degree of video data compression.

Basic stages of video encoding

There are a few simple ideas at the core of algorithms for video data compression. If we take some part of an image (in the MPEG-2 and AVC standards this part is called a macroblock), then there is a big possibility that, near this segment in this frame or in neighboring frames, there will be a segment containing a similar image, which differs little in pixel intensity values. Thus, to transmit information about the image in the current segment, it is enough to only transfer its difference from the previously encoded similar segment. The process of finding similar segments among previously encoded images is called Prediction. A set of difference values that determine the difference between the current segment and the found prediction is called the Residual. Here we can distinguish two main types of prediction. In the first one, the Prediction values represent a set of linear combinations of pixels adjacent to the current image segment on the left and on the top. This type of prediction is called Intra Prediction. In the second one, linear combinations of pixels of similar image segments from previously encoded frames are used as prediction (these frames are called Reference). This type of prediction is called Inter Prediction. To restore the image of the current segment, encoded with Inter prediction, when decoding, it is necessary to have information about not only the Residual, but also the frame number, where a similar segment is located, and the coordinates of this segment.
Residual values obtained during prediction obviously contain, on average, less information than the original image and, therefore, require a fewer quantity of bits for image transmission. To further increase the degree of compression of video data in video coding systems, some spectral transformation is used. Typically, this is Fourier cosine transform. Such transformation allows us to select the fundamental harmonics in two-dimensional Residual signal. Such a selection is made at the next stage of coding — quantization. The sequence of quantized spectral coefficients contains a small number of main, large values. The remaining values are very likely to be zero. As a result, the amount of information contained in quantized spectral coefficients is significantly (dozens of times) lower than in the original image.
In the next stage of coding, the obtained set of quantized spectral coefficients, accompanied by the information necessary for performing prediction when decoding, is subjected to entropy coding. The bottom line here is to align the most common values of the encoded stream with the shortest codeword (containing the smallest number of bits). The best compression ratio (close to theoretically achievable) at this stage is provided by arithmetic coding algorithms, which are mainly used in modern video compression systems.
From the above, the main factors affecting the effectiveness of a particular video compression system become apparent. First of all, these are, of course, the factors that determine the effectiveness of the Intra and Inter Predictions. The second set of factors is related to the orthogonal transformation and quantization, which selects the fundamental harmonics in the Residual signal. The third one is determined by the volume and compactness of the representation of additional information accompanying Residual and necessary for making predictions, that is, calculating Prediction, in the decoder. Finally, the fourth set has the factors that determine the effectiveness of the final stage- entropy coding.
Let’s illustrate some possible options (far from all) of the implementation of the coding stages listed above, on the example of H.264 / AVC and HEVC.

AVC Standard

In the AVC standard, the basic structural unit of the image is a macroblock — a square area of 16x16 pixels (Figure 1). When searching for the best possible prediction, the encoder can select one of several options of partitioning each macroblock. With Intra-prediction, there are three options: perform a prediction for the entire block as a whole, break the macroblock into four square blocks of 8x8 size, or into 16 blocks with a size of 4x4 pixels, and perform a prediction for each such block independently. The number of possible options of macroblock partitioning under Inter-prediction is much richer (Figure 1), which provides adaptation of the size and position of the predicted blocks to the position and shape of the object boundaries moving in the video frame.
Fig 1. Macroblocks in AVC and possible partitioning when using Inter-Prediction.
In AVC, pixel values from the column to the left of the predicted block and the row of pixels immediately above it are used for Intra prediction (Figure 2). For blocks of sizes 4x4 and 8x8, 9 methods of prediction are used. In a prediction called DC, all calculated pixels have a single value equal to the arithmetic average of the “neighbor pixels” highlighted in Fig. 2 with a bold line. In other modes, “angular” prediction is performed. In this case, the values of the “neighbor pixels” are placed inside the predicted block in the directions indicated in Fig. 2.
In the event that the predicted pixel gets between “neighbor pixels”, when moving in a given direction, an interpolated value is used for the prediction. For blocks with a size of 16x16 pixels, 4 methods of prediction are used. One of them is the DC-prediction, which was already reviewed. The other two correspond to the “angular” methods, with the directions of prediction 0 and 1. Finally, the fourth — Plane-prediction: the values of the predicted pixels are determined by the equation of the plane. The angular coefficients of the equation are determined by the values of the “neighboring pixels”.
Fig 2. “Neighboring pixels” and angular modes of Intra-Prediction in AVC
Inter- Prediction in AVC can be implemented in one of two ways. Each of these options determines the type of macroblock (P or B). As a prediction of pixel values in P-blocks (Predictive-blocks), the values of pixels from the area located on the previously coded (reference) image, are used. Reference images are not deleted from the RAM buffer, containing decoded frames (decoded picture buffer, or DPB), as long as they are needed for Inter-prediction. A reference list is created in the DPB from the indexes of these images.
The encoder signals to the decoder about the number of the reference image in the list and about the offset of the area used for prediction, with respect to the position of predicted block (this displacement is called motion vector). The offset can be determined with an accuracy of ¼ pixel. In case of prediction with non-integer offset, interpolation is performed. Different blocks in one image can be predicted by areas located on different reference images.
In the second option of Inter Prediction, prediction of the B-block pixel values (bi-predictive block), two reference images are used; their indexes are placed in two lists (list0 and list1) in the DPB. The two indexes of reference images in the lists and two offsets, that determine positions of reference areas, are transmitted to the decoder. The B-block pixel values are calculated as a linear combination of pixel values from the reference areas. For non-integer offsets, interpolation of reference image is used.
As already mentioned, after predicting the values of the encoded block and calculating the Residual signal, the next coding step is spectral transformation. In AVC, there are several options for orthogonal transformations of the Residual signal. When Intra-prediction of a whole macroblock with a size of 16x16 is implemented, the residual signal is divided into 4x4 pixel blocks; each of them is subjected to an integer analog of discrete two-dimensional 4x4 cosine Fourier transform.
The resulting spectral components, corresponding to zero frequency (DC) in each block, are then subjected to additional orthogonal Walsh-Hadamard transform. With Inter-prediction, the Residual signal is divided into blocks of 4x4 pixels or 8x8 pixels. Each block is then subjected to a 4x4 or 8x8 (respectively) two-dimensional discrete cosine Fourier Transform (DCT, from Discrete Cosine Transform).
In the next step, spectral coefficients are subjected to the quantization procedure. This leads to a decrease in bit capacity of digits representing the spectral sample values, and to a significant increase in the number of samples having zero values. These effects provide compression, i.e. reduce the number and bit capacity of digits representing the encoded image. The reverse side of quantization is the distortion of the encoded image. It is clear that the larger the quantization step, the greater is the compression ratio, but also the distortion is greater.
The final stage of encoding in AVC is entropy coding, implemented by the algorithms of Context Adaptive Binary Arithmetic Coding. This stage provides additional compression of video data without distortion in the encoded image.

Ten years later. HEVC standard: what’s new?

The new H.265/HEVC standard is the development of methods and algorithms for compressing video data embedded in H.264/AVC. Let’s briefly review the main differences.
An analog of a macroblock in HEVC is the Coding Unit (CU). Within each block, areas for calculation of Prediction are selected — Prediction Unit (PU). Each CU also specifies the limits within which the areas for calculating the discrete orthogonal transformation from the residual signal are selected. These areas are called the Transform Unit (TU).
The main distinguishing feature of HEVC here is that the split of a video frame into CU is conducted adaptively, so that it is possible to adjust the CU boundaries to the boundaries of objects on the image (Figure 3). Such adaptability allows to achieve an exceptionally high quality of prediction and, as a consequence, a low level of the residual signal.
An undoubted advantage of such an adaptive approach to frame division into blocks is also an extremely compact description of the partition structure. For the entire video sequence, the maximum and minimum possible CU sizes are set (for example, 64x64 is the maximum possible CU, 8x8 is the minimum). The entire frame is covered with the maximum possible CUs, left to right, top-to-bottom.
It is obvious that, for such coverage, transmission of any information is not required. If partition is required within any CU, then this is indicated by a single flag (Split Flag). If this flag is set to 1, then this CU is divided into 4 CUs (with a maximum CU size of 64x64, after partitioning we get 4 CUs of size 32x32 each).
For each of the CUs received, a Split Flag value of 0 or 1 can, in turn, be transmitted. In the latter case, this CU is again divided into 4 CUs of smaller size. The process continues recursively until the Split Flag of all received CUs is equal to 0 or until the minimum possible CU size is reached. Inserted CUs thus form a quad tree (Coding Tree Units, CTU). As already mentioned, within each CU, areas for calculating prediction- Prediction Units (PU) are selected. With Intra Prediction, the CU area can coincide with the PU (2Nx2N mode) or it can be divided into 4 square PUs of twice smaller size (NxN mode, available only for CU of minimum size). With Inter Prediction, there are eight possible options for partitioning each CU into PUs (Figure 3).
Fig.3 Video frame partitioning into CUs is conducted adaptively
The idea of spatial prediction in HEVC remained the same as in AVC. Linear combinations of neighboring pixel values, adjacent to the block on the left and above, are used as predicted sample values in the PU block. However, the set of methods for spatial prediction in HEVC has become significantly richer. In addition to Planar (analogue to Plane in AVC) and DC methods, each PU can be predicted by one of the 33 ways of “angular” prediction. That is, the number of ways, in which the values are calculated by “neighbor”-pixels, is increased by 4 times.
Fig. 4. Possible partitioning of the Coding Unit into Prediction Units with the spatial (Intra) and temporary (Inter) CU prediction modes
We can point out two main differences of Inter- prediction between HEVC and AVC. Firstly, HEVC uses better interpolation filters (with a longer impulse response) when calculating reference images with non-integer offset. The second difference concerns the way the information about the reference area, required by the decoder for performing the prediction, is presented. In HEVC, a “merge mode” is introduced, where different PUs, with the same offsets of reference areas, are combined. For the entire combined area, information about motion (motion vector) is transmitted in the stream once, which allows a significant reduction in the amount of information transmitted.
In HEVC, the size of the discrete two-dimensional transformation, to which the Residual signal is subjected, is determined by the size of the square area called the Transform Unit (TU). Each CU is the root of the TU quad tree. Thus, the TU of the upper level coincides with the CU. The root TU can be divided into 4 parts of half the size, each of which, in turn, is a TU and can be further divided.
The size of discrete transformation is determined by the TU size of the lower level. In HEVC, transforms for blocks of 4 sizes are defined: 4x4, 8x8, 16x16, and 32x32. These transformations are integer analogs of the discrete two-dimensional Fourier cosine transform of corresponding size. For size 4x4 TU with Intra-prediction, there is also a separate discrete transformation, which is an integer analogue of the discrete sine Fourier transform.
The ideas of the procedure of quantizing spectral coefficients of Residual signal, and also entropy coding in AVC and in HEVC, are practically identical.
Let’s note one more point which was not mentioned before. The quality of decoded images and the degree of video data compression are influenced significantly by post-filtering, which decoded images with Inter-prediction undergo before they are placed in the DPB.
In AVC, there is one kind of such filtering — deblocking filter. Application of this filter reduces the block effect resulting from quantization of spectral coefficients after orthogonal transformation of Residual signal.
In HEVC, a similar deblocking filter is used. Besides, an additional non-linear filtering procedure called the Sample Adaptive Offset (SAO) exists. Based on the analysis of pixel value distribution during encoding, a table of corrective offsets, added to the values of a part of CU pixels during decoding, is determined.
In HEVC, the size of the discrete two-dimensional transformation, to which the Residual signal is subjected, is determined by the size of the square area called the Transform Unit (TU). Each CU is the quad-tree of TU’s. Thus, the TU of the upper level coincides with the CU. The root TU can be divided into 4 parts of half the size, each of which, in turn, is a TU and can be further divided.
The size of discrete transformation is determined by the TU size of the lower level. There are four transform block sizes in HEVC: 4x4, 8x8, 16x16, and 32x32. These transforms are discrete two-dimensional Fourier cosine transform of corresponding size. For 4x4 Intra-predicted blocks, could be used another discrete transform — sine Fourier transform.
The quantization of spectral coefficients of residual signal, and entropy coding in AVC and in HEVC, are almost identical.
Let’s note one more point which was not mentioned before. The quality of decoded images, hence the degree of video data compression, is influenced significantly by post-filtering, which applied on decoded Inter-predicted images before they are placed in the DPB.
In AVC, there is one kind of such filtering — deblocking filter. It masking blocking artifacts effect originating from spectral coefficients quantization after orthogonal transformation of residual signal.
In HEVC, a similar deblocking filter is used. Besides, an additional non-linear filtering procedure called the Sample Adaptive Offset (SAO) exists. Sample level correction is based either on local neighborhood or on the intensity level of sample itself. Table of sample level corrections, added to the values of a part of CU pixels during decoding, is determined.

And what is the result?

Figures 4–7 show the results of encoding of several high-resolution (HD) video sequences by two encoders. One of the encoders compresses the video data in the H.265/HEVC standard (marked as HM on all the graphs), and the second one is in the H.264/AVC standard.
Fig. 5. Encoding results of the video sequence Aspen (1920x1080 30 frames per second)
Fig. 6. Encoding results of the video sequence BlueSky (1920x1080 25 frames per second)
Fig. 7. Encoding results of the video sequence PeopleOnStreet (1920x1080 30 frames per second)
Fig. 8. Encoding results of the video sequence Traffic (1920x1080 30 frames per second)
Coding was performed at different quantization values of spectral coefficients, hence with different levels of video image distortion. The results are presented in Bitrate (mbps) — PSNR(dB) coordinates. PSNR values characterize the degree of distortion.
On average, it can be stated that the PSNR range below 36 dB corresponds to a high level of distortion, i.e. low quality video images. The range of 36 to 40 dB corresponds to the average quality. With PSNR values above 40 dB, we can call it a high video quality.
We can roughly estimate the compression ratio provided by the encoding systems. In the medium quality area, the bit rate provided by the HEVC encoder is about 1.5 times less than the bit rate of the AVC encoder. Bitrate of an uncompressed video stream is easily determined as the product of the number of pixels in each video frame (1920 x 1080) by the number of bits required to represent each pixel (8 + 2 + 2 = 12), and the number of frames per second (30).
As a result, we get about 750 Mbps. It can be seen from the graphs that, in the area of average quality, the AVC encoder provides a bit rate of about 10–12 Mbit/s. Thus, the degree of video information compression is about 60–75 times. As already mentioned, the HEVC encoder provides compression ratio 1.5 times higher.

About the author

Oleg Ponomarev, 16 years in video encoding and signal digital processing, expert in Statistical Radiophysics, Radio waves propagation. Assistant Professor, PhD at Tomsk State University, Radiophysics department. Head of Elecard Research Lab.
submitted by VideoCompressionGuru to u/VideoCompressionGuru [link] [comments]

Step-by-Step Guide for Adding a Stack, Expanding Control Lines, and Building an Assembler

After the positive response to my first tutorial on expanding the RAM, I thought I'd continue the fun by expanding the capabilities of Ben's 8-bit CPU even further. That said, you'll need to have done the work in the previous post to be able to do this. You can get a sense for what we'll do in this Imgur gallery.
In this tutorial, we'll balance software and hardware improvements to make this a pretty capable machine:

Parts List

To only update the hardware, you'll need:
If you want to update the toolchain, you'll need:
  1. Arduino Mega 2560 (Amazon) to create the programmer.
  2. Ribbon Jumper Cables (Amazon) to connect the Arduino to the breadboard.
  3. TL866 II Plus EEPROM Programmer (Amazon) to program the ROM.
Bonus Clock Improvement: One additional thing I did is replace the 74LS04 inverter in Ben's clock circuit with a 74LS14 inverting Schmitt trigger (datasheet, Jameco). The pinouts are identical! Just drop it in, wire the existing lines, and then run the clock output through it twice (since it's inverting) to get a squeaky clean clock signal. Useful if you want to go even faster with the CPU.

Step 1: Program with an Arduino and Assembler (Image 1, Image 2)

There's a certain delight in the physical programming of a computer with switches. This is how Bill Gates and Paul Allen famously programmed the Altair 8800 and started Microsoft. But at some point, the hardware becomes limited by how effectively you can input the software. After upgrading the RAM, I quickly felt constrained by how long it took to program everything.
You can continue to program the computer physically if you want and even after upgrading that option is still available, so this step is optional. There's probably many ways to approach the programming, but this way felt simple and in the spirit of the build. We'll use an Arduino Mega 2560, like the one in Ben's 6502 build, to program the RAM. We'll start with a homemade assembler then switch to something more robust.
Preparing the Physical Interface
The first thing to do is prepare the CPU to be programmed by the Arduino. We already did the hard work on this in the RAM upgrade tutorial by using the bus to write to the RAM and disconnecting the control ROM while in program mode. Now we just need to route the appropriate lines to a convenient spot on the board to plug the Arduino into.
  1. This is optional, but I rewired all the DIP switches to have ground on one side, rather than alternating sides like Ben's build. This just makes it easier to route wires.
  2. Wire the 8 address lines from the DIP switch, connecting the side opposite to ground (the one going to the chips) to a convenient point on the board. I put them on the far left, next to the address LEDs and above the write button circuit.
  3. Wire the 8 data lines from the DIP switch, connecting the side opposite to ground (the one going to the chips) directly below the address lines. Make sure they're separated by the gutter so they're not connected.
  4. Wire a line from the write button to your input area. You want to connect the side of the button that's not connected to ground (the one going to the chip).
So now you have one convenient spot with 8 address lines, 8 data lines, and a write line. If you want to get fancy, you can wire them into some kind of connector, but I found that ribbon jumper cables work nicely and keep things tidy.
The way we'll program the RAM is to enter program mode and set all the DIP switches to the high position (e.g., 11111111). Since the switches are upside-down, this means they'll all be disconnected and not driving to ground. The address and write lines will simply be floating and the data lines will be weakly pulled up by 1k resistors. Either way, the Arduino can now drive the signals going into the chips using its outputs.
Creating the Arduino Programmer
Now that we can interface with an Arduino, we need to write some software. If you follow Ben's 6502 video, you'll have all the knowledge you need to get this working. If you want some hints and code, see below (source code):
  1. Create arrays for your data and address lines. For example: const char ADDRESS_LINES[] = {39, 41, 43, 45, 47, 49, 51, 53};. Create your write line with #define RAM_WRITE 3.
  2. Create functions to enable and disable your address and data lines. You want to enable them before writing. Make sure to disable them afterward so that you can still manually program using DIP switches without disconnecting the Arduino. The code looks like this (just change INPUT to OUTPUT accordingly): for(int n = 0; n < 8; n += 1) { pinMode(ADDRESS_LINES[n], OUTPUT); }
  3. Create a function to write to an address. It'll look like void writeData(byte writeAddress, byte writeData) and basically use two loops, one for address and one for data, followed by toggling the write.
  4. Create a char array that contains your program and data. You can use #define to create opcodes like #define LDA 0x01.
  5. In your main function, loop through the program array and send it through writeData.
With this setup, you can now load multi-line programs in a fraction of a second! This can really come in handy with debugging by stress testing your CPU with software. Make sure to test your setup with existing programs you know run reliably. Now that you have your basic setup working, you can add 8 additional lines to read the bus and expand the program to let you read memory locations or even monitor the running of your CPU.
Making an Assembler
The above will serve us well but it's missing a key feature: labels. Labels are invaluable in assembly because they're so versatile. Jumps, subroutines, variables all use labels. The problem is that labels require parsing. Parsing is a fun project on the road to a compiler but not something I wanted to delve into right now--if you're interested, you can learn about Flex and Bison. Instead, I found a custom assembler that lets you define your CPU's instruction set and it'll do everything else for you. Let's get it setup:
  1. If you're on Windows, you can use the pre-built binaries. Otherwise, you'll need to install Rust and compile via cargo build.
  2. Create a file called 8bit.cpu and define your CPU instructions (source code). For example, LDA would be lda {address} -> 0x01 @ address[7:0]. What's cool is you can also now create the instruction's immediate variant instead of having to call it LDI: lda #{value} -> 0x05 @ value[7:0].
  3. You can now write assembly by adding #include "8bit.cpu" to the top of your code. There's a lot of neat features so make sure to read the documentation!
  4. Once you've written some assembly, you can generate the machine code using ./customasm yourprogram.s -f hexc -p. This prints out a char array just like our Arduino program used!
  5. Copy the char array into your Arduino program and send it to your CPU.
At this stage, you can start creating some pretty complex programs with ease. I would definitely play around with writing some larger programs. I actually found a bug in my hardware that was hidden for a while because my programs were never very complex!

Step 2: Expand the Control Lines (Image)

Before we can expand the CPU any further, we have to address the fact we're running out of control lines. An easy way to do this is to add a 3rd 28C16 ROM and be on your way. If you want something a little more involved but satisfying, read on.
Right now the control lines are one hot encoded. This means that if you have 4 lines, you can encode 4 states. But we know that a 4-bit binary number can encode 16 states. We'll use this principle via 74LS138 decoders, just like Ben used for the step counter.
Choosing the Control Line Combinations
Everything comes with trade-offs. In the case of combining control lines, it means the two control lines we choose to combine can never be activated at the same time. We can ensure this by encoding all the inputs together in the first 74LS138 and all the outputs together in a second 74LS138. We'll keep the remaining control lines directly connected.
Rewiring the Control Lines
If your build is anything like mine, the control lines are a bit of a mess. You'll need to be careful when rewiring to ensure it all comes back together correctly. Let's get to it:
  1. Place the two 74LS138 decoders on the far right side of the breadboard with the ROMs. Connect them to power and ground.
  2. You'll likely run out of inverters, so place a 74LS04 on the breadboard above your decoders. Connect it to power and ground.
  3. Carefully take your inputs (MI, RI, II, AI, BI, J) and wire them to the outputs of the left 74LS138. Do not wire anything to O0 because that's activated by 000 which won't work for us!
  4. Carefully take your outputs (RO, CO, AO, EO) and wire them to the outputs of the right 74LS138. Remember, do not wire anything to O0!
  5. Now, the 74LS138 outputs are active low, but the ROM outputs were active high. This means you need to swap the wiring on all your existing 74LS04 inverters for the LEDs and control lines to work. Make sure you track which control lines are supposed to be active high vs. active low!
  6. Wire E3 to power and E2 to ground. Connect the E1 on both 138s together, then connect it to the same line as OE on your ROMs. This will ensure that the outputs are disabled when you're in program mode. You can actually take off the 1k pull-up resistors from the previous tutorial at this stage, because the 138s actively drive the lines going to the 74LS04 inverters rather than floating like the ROMs.
At this point, you really need to ensure that the massive rewiring job was successful. Connect 3 jumper wires to A0-A2 and test all the combinations manually. Make sure the correct LED lights up and check with a multimeteoscilloscope that you're getting the right signal at each chip. Catching mistakes at this point will save you a lot of headaches! Now that everything is working, let's finish up:
  1. Connect A0-A2 of the left 74LS138 to the left ROM's A0-A2.
  2. Connect A0-A2 of the right 74LS138 to the right ROM's A0-A2.
  3. Distribute the rest of the control signals across the two ROMs.
Changing the ROM Code
This part is easy. We just need to update all of our #define with the new addresses and program the ROMs again. For clarity that we're not using one-hot encoding anymore, I recommend using hex instead of binary. So instead of #define MI 0b0000000100000000, we can use #define MI 0x0100, #define RI 0x0200, and so on.
Testing
Expanding the control lines required physically rewiring a lot of critical stuff, so small mistakes can creep up and make mysterious errors down the road. Write a program that activates each control line at least once and make sure it works properly! With your assembler and Arduino programmer, this should be trivial.
Bonus: Adding B Register Output
With the additional control lines, don't forget you can now add a BO signal easily which lets you fully use the B register.

Step 3: Add a Stack (Image 1, Image 2)

Adding a stack significantly expands the capability of the CPU. It enables subroutines, recursion, and handling interrupts (with some additional logic). We'll create our stack with an 8-bit stack pointer hard-coded from $0100 to $01FF, just like the 6502.
Wiring up the Stack Pointer
A stack pointer is conceptually similar to a program counter. It stores an address, you can read it and write to it, and it increments. The only difference between a stack pointer and a program counter is that the stack pointer must also decrement. To create our stack pointer, we'll use two 74LS193 4-bit up/down binary counters:
  1. Place a 74LS00 NAND gate, 74LS245 transceiver, and two 74LS193 counters in a row next to your output register. Wire up power and ground.
  2. Wire the the Carry output of the right 193 to the Count Up input of the left 193. Do the same for the Borrow output and Count Down input.
  3. Connect the Clear input between the two 193s and with an active high reset line. The B register has one you can use on its 74LS173s.
  4. Connect the Load input between the two 193s and to a new active low control line called SI on your 74LS138 decoder.
  5. Connect the QA-QD outputs of the lower counter to A8-A5 and the upper counter to A4-A1. Pay special attention because the output are in a weird order (BACD) and you want to make sure the lower A is connected to A8 and the upper A is connected to A4.
  6. Connect the A-D inputs of the lower counter to B8-B5 and the upper counter to B4-B1. Again, the inputs are in a weird order and on both sides of the chip so pay special attention.
  7. Connect the B1-B8 outputs of the 74LS245 transceiver to the bus.
  8. On the 74LS245 transceiver, connect DIR to power (high) and connect OE to a new active low control line called SO on your 74LS138 decoder.
  9. Add 8 LEDs and resistors to the lower part of the 74LS245 transceiver (A1-A8) so you can see what's going on with the stack pointer.
Enabling Increment & Decrement
We've now connected everything but the Count Up and Count Down inputs. The way the 74LS193 works is that if nothing is counting, both inputs are high. If you want to increment, you keep Count Down high and pulse Count Up. To decrement, you do the opposite. We'll use a 74LS00 NAND gate for this:
  1. Take the clock from the 74LS08 AND gate and make it an input into two different NAND gates on the 74LS00.
  2. Take the output from one NAND gate and wire it to the Count Up input on the lower 74LS193 counter. Take the other output and wire it to the Count Down input.
  3. Wire up a new active high control line called SP from your ROM to the NAND gate going into Count Up.
  4. Wire up a new active high control line called SM from your ROM to the NAND gate going into Count Down.
At this point, everything should be working. Your counter should be able to reset, input a value, output a value, and increment/decrement. But the issue is it'll be writing to $0000 to $00FF in the RAM! Let's fix that.
Accessing Higher Memory Addresses
We need the stack to be in a different place in memory than our regular program. The problem is, we only have an 8-bit bus, so how do we tell the RAM we want a higher address? We'll use a special control line to do this:
  1. Wire up an active high line called SA from the 28C16 ROM to A8 on the Cypress CY7C199 RAM.
  2. Add an LED and resistor so you can see when the stack is active.
That's it! Now, whenever we need the stack we can use a combination of the control line and stack pointer to access $0100 to $01FF.
Updating the Instruction Set
All that's left now is to create some instructions that utilize the stack. We'll need to settle some conventions before we begin:
If you want to add a little personal flair to your design, you can change the convention fairly easily. Let's implement push and pop (source code):
  1. Define all your new control lines, such as #define SI 0x0700 and #define SO 0x0005.
  2. Create two new instructions: PSH (1011) and POP (1100).
  3. PSH starts the same as any other for the first two steps: MI|CO and RO|II|CE. The next step is to put the contents of the stack pointer into the address register via MI|SO|SA. Recall that SA is the special control line that tells the memory to access the $01XX bank rather than $00XX.
  4. We then take the contents of AO and write it into the RAM. We can also increment the stack pointer at this stage. All of this is done via: AO|RI|SP|SA, followed by TR.
  5. POP is pretty similar. Start off with MI|CO and RO|II|CE. We then need to take a cycle and decrement the stack pointer with SM. Like with PSH, we then set the address register with MI|SO|SA.
  6. We now just need to output the RAM into our A register with RO|AI|SA and then end the instruction with TR.
  7. Updating the assembler is easy since neither instruction has operands. For example, push is just psh -> 0x0B.
And that's it! Write some programs that take advantage of your new 256 byte stack to make sure everything works as expected.

Step 4: Add Subroutine Instructions (Image)

The last step to complete our stack is to add subroutine instructions. This allows us to write complex programs and paves the way for things like interrupt handling.
Subroutines are like a blend of push/pop instructions and a jump. Basically, when you want to call a subroutine, you save your spot in the program by pushing the program counter onto the stack, then jumping to the subroutine's location in memory. When you're done with the subroutine, you simply pop the program counter value from the stack and jump back into it.
We'll follow 6502 conventions and only save and restore the program counter for subroutines. Other CPUs may choose to save more state, but it's generally left up to the programmer to ensure they're not wiping out states in their subroutines (e.g., push the A register at the start of your subroutine if you're messing with it and restore it before you leave).
Adding an Extra Opcode Line
I've started running low on opcodes at this point. Luckily, we still have two free address lines we can use. To enable 5-bit opcodes, simply wire up the 4Q output of your upper 74LS173 register to A7 of your 28C16 ROM (this assumes your opcodes are at A3-A6).
Updating the ROM Writer
At this point, you simply need to update the Arduino writer to support 32 instructions vs. the current 16. So, for example, UCODE_TEMPLATE[16][8] becomes UCODE_TEMPLATE[32][8] and you fill in the 16 new array elements with nop. The problem is that the Arduino only has so much memory and with the way Ben's code is written to support conditional jumps, it starts to get tight.
I bet the code can be re-written to handle this, but I had a TL866II Plus EEPROM programmer handy from the 6502 build and I felt it would be easier to start using that instead. Converting to a regular C program is really simple (source code):
  1. Copy all the #define, global const arrays (don't forget to expand them from 16 to 32), and void initUCode(). Add #include and #include to the top.
  2. In your traditional int main (void) C function, after initializing with initUCode(), make two arrays: char ucode_upper[2048] and char ucode_lower[2048].
  3. Take your existing loop code that loops through all addresses: for (int address = 0; address < 2048; address++).
  4. Modify instruction to be 5-bit with int instruction = (address & 0b00011111000) >> 3;.
  5. When writing, just write to the arrays like so: ucode_lower[address] = ucode[flags][instruction][step]; and ucode_upper[address] = ucode[flags][instruction][step] >> 8;.
  6. Open a new file with FILE *f = fopen("rom_upper.hex", "wb");, write to it with fwrite(ucode_upper, sizeof(char), sizeof(ucode_upper), f); and close it with fclose(f);. Repeat this with the lower ROM too.
  7. Compile your code using gcc (you can use any C compiler), like so: gcc -Wall makerom.c -o makerom.
Running your program will spit out two binary files with the full contents of each ROM. Writing the file via the TL866II Plus requires minipro and the following command: minipro -p CAT28C16A -w rom_upper.hex.
Adding Subroutine Instructions
At this point, I cleaned up my instruction set layout a bit. I made psh and pop 1000 and 1001, respectively. I then created two new instructions: jsr and rts. These allow us to jump to a subroutine and returns from a subroutine. They're relatively simple:
  1. For jsr, the first three steps are the same as psh: MI|CO, RO|II|CE, MI|SO|SA.
  2. On the next step, instead of AO we use CO to save the program counter to the stack: CO|RI|SP|SA.
  3. We then essentially read the 2nd byte to do a jump and terminate: MI|CO, RO|J.
  4. For rts, the first four steps are the same as pop: MI|CO, RO|II|CE, SM, MI|SO|SA.
  5. On the next step, instead of AI we use J to load the program counter with the contents in stack: RO|J|SA.
  6. We're not done! If we just left this as-is, we'd jump to the 2nd byte of jsr which is not an opcode, but a memory address. All hell would break loose! We need to add a CE step to increment the program counter and then terminate.
Once you update the ROM, you should have fully functioning subroutines with 5-bit opcodes. One great way to test them is to create a recursive program to calculate something--just don't go too deep or you'll end up with a stack overflow!

Conclusion

And that's it! Another successful upgrade of your 8-bit CPU. You now have a very capable machine and toolchain. At this point I would have a bunch of fun with the software aspects. In terms of hardware, there's a number of ways to go from here:
  1. Interrupts. Interrupts are just special subroutines triggered by an external line. You can make one similar to how Ben did conditional jumps. The only added complexity is the need to load/save the flags register since an interrupt can happen at any time and you don't want to destroy the state. Given this would take more than 8 steps, you'd also need to add another line for the step counter (see below).
  2. ROM expansion. At this point, address lines on the ROM are getting tight which limits any expansion possibilities. With the new approach to ROM programming, it's trivial to switch out the 28C16 for the 28C256 that Ben uses in the 6502. These give you 4 additional address lines for flags/interrupts, opcodes, and steps.
  3. LCD output. At this point, adding a 16x2 character LCD like Ben uses in the 6502 is very possible.
  4. Segment/bank register. It's essentially a 2nd memory address register that lets you access 256-byte segments/banks of RAM using bank switching. This lets you take full advantage of the 32K of RAM in the Cypress chip.
  5. Fast increment instructions. Add these to registers by replacing 74LS173s with 74LS193s, allowing you to more quickly increment without going through the ALU. This is used to speed up loops and array operations.
submitted by MironV to beneater [link] [comments]

what is this i just downloaded (youtube code?)

so this is kinda a wierd story. I was planning to restart my computer. (cant remember why) I spend most of my time watching youtube videos so i had alot of tabs open. So i was watching the videos then deleting the tab but not opening new tabs. So i was down 2 i think 1 it was a pretty long video so i tried to open a youtube home page tab just to look while i listened to the video. And this is a short exerp of what i got.





YouTube











submitted by inhuman7773 to techsupport [link] [comments]

Best binary forex trading platform

1 Minute Option is best binary trading platform on the market. We get you connected to the best trading platform available on the market and from that point on your success is our success.We'll provide you with all of the training and trading signals you need at absolutely no cost || 1 Minute Option binary trading platform.
submitted by 1MinuteOptions to u/1MinuteOptions [link] [comments]

This is a draft you idiots

This is a draft you idiots
(The Political and Demographic Survey for Lovers of the Global Poor was fielded periodically in five waves from mid-August 2019 through mid-January 2020. It was made possible with a generous grant from the Open Society Foundations, a philanthropic venture founded by George Soros.)
This unscientific survey and its modest samples are by no means a definitive account of this community's attitudes or demography, and I've identified at least a few methodological shortcomings. Two of them — namely, the limited answer selection for favorability questions and the wording of one option in the religious affiliation query — are described below.
More significantly, however, my decision to prioritize insights about the demographic makeup of this subreddit (wherein I limited each respondent to one wave to prevent duplicates) necessarily came at the expense of revelations about its political opinions. As a result, it is impossible to exclude the possibility that apparent trends between one wave and the next are not due at least in part to a response pool whose politics are systematically different from previous ones.
But with the above caveats laid out, I present to you — at long last — the topline findings and corresponding analyses from my personal contribution to the Neoliberal Project!
Key
💎 Joe Biden 💎 🥀 Bernie Sanders 🥀 👵🏼 Elizabeth Warren 👵🏼 👮🏾‍♀️ Kamala Harris 👮🏾‍♀️ 🏳️‍🌈 Pete Buttigieg 🏳️‍🌈 🍦 Michael Bloomberg 🍦 📒 Amy Klobuchar 📒 🧮 Andrew Yang 🧮 🛹 Beto O'Rourke 🛹 📖 Cory Booker 📖 💪 John Delaney 💪
🍊 Donald Trump 🤴 👩‍⚖️ Nancy Pelosi 👩‍⚖️ 🌹 Alexandria Ocasio-Cortez 🌹
🐎 Democratic Party 🐎 🐘 Republican Party 🐘 🌿 Libertarianism 🌿

Wave 1 (N=222 | August 11–13, 2019)

https://preview.redd.it/9e9bkuw54do41.png?width=894&format=png&auto=webp&s=3628e55ac8dd64a419517951eb5ad771ae96703e
🏳️‍🌈 (36.9%) earns a large plurality, with 🛹 (19.8%) taking second place. 💎 (10.8%) and 💪 (9.0%) follow up in third and fourth, while the fiercely progressive 👵🏼 (5.9%) earns a fair share as well. The remaining candidates combine for 15 percent of the first-preference vote, with no individual candidate reaching 4 points.
Favorability¹
Opinions of 🏳️‍🌈 (91.6) soar sky-high, with nearly 9 in 10 expressing a favorable view. In a not-so-close second is 👩‍⚖️ (84.2) for whom close to 8 in 10 have a positive opinion. 💎 (80.9) is the second-placed Democratic candidate, with nearly 3 in 4 offering a positive view, with nobody else even remotely close.
👵🏼 (46.1) finds herself slightly underwater, with a –7.7% net rating, and 👮🏾‍♀️ (43.2) is close behind. Of the five highest-polling candidates at the time of the survey, 🥀 (12.1) finds himself in an ignominious last, with just under a mere 1 in 10 giving a favorable view.
However, nobody on the left side of the aisle can come close to 🍊🤴 (1.4), who lands just a hair above being universally despised.
Subject Favorable Neither Unfavorable Index²
🏳️‍🌈 88.7 5.9 5.4 91.6
👩‍⚖️ 78.4 11.7 9.9 84.2
🐎 76.1 13.5 10.4 82.8
💎 73.0 15.8 11.3 80.9
👵 36.9 18.5 44.6 46.1
👮🏾‍♀️ 30.6 25.2 44.1 43.2
🌿 27.4 18.0 54.5 36.4
🌹 21.6 18.0 60.4 30.6
🥀 9.0 6.3 84.7 12.1
🐘 1.8 5.9 92.3 4.7
🍊🤴 0.5 1.8 97.7 1.4

Wave 2 (N=140 | October 11–15, 2019)

https://preview.redd.it/ckpx1vo94do41.png?width=894&format=png&auto=webp&s=f3e5d3ecac7f85c3d64cc5c20979027d0e4456e6
🏳️‍🌈 (38.6%) once again lands on top, more than tripling niche-favorite 💪's (12.1%) share, who is in a tight cluster for runner-up with 🛹 (11.4%) — who suffered a steep decline — 💎 (11.4%), and 👵🏼 (10.7%), who nearly doubled her vote. The rest take a little under 1/7th of the vote, with nobody breaking 4 percent.
Favorability
🏳️‍🌈 (92.8) hurdles the 9 in 10 threshold for favorability. 👩‍⚖️ (89.6) sees her already stellar standing improve substantially, while 💎 (83.1) trades places with his party.
👵🏼 (55.4) surges into positive territory, while 👮🏾‍♀️ (33.9) takes a big hit. 🥀 (14.9) is once again dead last.
Subject Favorable Neither Unfavorable Index²
🏳️‍🌈 90.7 4.3 5.0 92.8
👩‍⚖️ 85.0 9.3 5.7 89.6
💎 77.1 12.1 10.7 83.1
🐎 77.4 9.3 13.6 82.0
👵🏼 48.6 13.6 37.9 55.4
🌿 27.1 25.0 47.9 39.6
👮🏾‍♀️ 24.3 19.3 56.4 33.9
🌹 17.1 17.1 65.7 25.6
🥀 11.4 7.1 81.4 14.9
🐘 3.6 5.0 91.4 6.1
🍊🤴 0.7 2.9 96.4 2.1

Wave 3 (N=165 | November 11–14, 2019)

https://preview.redd.it/0bqavm8d4do41.png?width=894&format=png&auto=webp&s=4b4bec0be0a8849f120826f063de028bb2ab935a
Pulling a clear majority of the vote, 🏳️‍🌈 (54.5%) obliterates the field. 💎 (18.8%) substantially increases his share, while 👵🏼 (5.5%) has her percentage halved and 💪 (4.2%) cut by a brutal two-thirds. The remaining candidates take 14 percent, with no individual candidate surpassing the 4-point threshold.
Favorability
🏳️‍🌈 (93.9) inches still closer to the mathematical limit, as 👩‍⚖️ (84.2) recedes and 💎 (83.0) replicates his previous robust showing.
👵🏼 (38.5) nosedives, and 👮🏾‍♀️ (38.1) recoups some of her losses. 🥀 (12.1) returns to his abysmal rating in the first wave.
🍊🤴 (2.7) climbs further, doubling his Wave 1 standing in an impressive show of newfound popularity.
Subject Favorable Neither Unfavorable Index²
🏳️‍🌈 92.1 3.6 4.2 93.9
👩‍⚖️ 78.2 12.1 9.7 84.2
💎 76.4 13.3 10.3 83.0
🐎 72.7 12.7 14.5 79.0
👵🏼 28.5 20.0 51.5 38.5
👮🏾‍♀️ 24.2 27.9 47.9 38.1
🌿 28.5 15.2 56.4 36.1
🌹 12.7 17.6 69.7 21.5
🥀 9.1 6.1 84.8 12.1
🐘 1.8 5.5 92.7 4.5
🍊🤴 2.4 0.6 97.0 2.7

Wave 4 (N=150 | December 23–26, 2019)

https://preview.redd.it/7ozcxrue4do41.png?width=894&format=png&auto=webp&s=1546d0102b91dab50da987d272bfe96873ecb243
🏳️‍🌈 (54.0%) repeats his dominating performance, while 💎 (22.0%) earns twice his initial share. A meaningful minority contingent selects the otherwise broadly reviled 🥀 (4.7%), and late-entrant 🍦 (4.7%) matches. 🧮 (4.0%) earns his mention with a number of votes, 👵🏼 (2.7%) loses another half off her support, and 💪 (1.3%) fades into the background.
Favorability
🏳️‍🌈 (91.3) loses a bit of his still-vibrant luster, and 👩‍⚖️ (91.3) draws right even with him as her skeptics are slashed by no less than half. 💎 (87.6) significantly improves his already excellent numbers.
The now-departed 👮🏾‍♀️ (48.3) surges to near-even favorability, while 👵🏼 (34.0) is further depressed. 🥀 (17.3) rises somewhat from the abyss.
Subject Favorable Neither Unfavorable Index²
🏳️‍🌈 90.0 2.7 7.3 91.3
👩‍⚖️ 88.0 6.7 5.3 91.3
💎 84.0 7.3 8.7 87.6
🐎 73.3 18.0 8.7 79.0
👮🏾‍♀️ 36.0 24.7 49.3 48.3
🌿 29.3 21.3 49.3 36.1
👵🏼 26.0 16.0 58.0 34.0
🌹 13.3 18.7 68.0 22.6
🥀 12.7 9.3 78.0 17.3
🐘 1.3 9.3 89.3 5.9
🍊🤴 0.7 2.7 96.7 2.0

Wave 5 (N=187 | January 12–14, 2020)

https://preview.redd.it/va1ly13i4do41.png?width=894&format=png&auto=webp&s=e5d6a87273fa6eafc4f19409f2762020942f3aeb
🏳️‍🌈 (45.5%) loses his outright majority as 💎 (28.9%) significantly increases his vote share for the fourth consecutive wave. 📒 (4.8%) rises to the top of the second tier, with 📖 (4.3%) just behind.
Favorability
💎's (91.2) unrelenting rise is mirrored in favorability as he dethrones 🏳️‍🌈 (90.3) for the first place in the metric.
👮🏾‍♀️ (55.8) rides cleanly into positive territory, and 👵🏼 (45.7) sees her image improve substantially, perhaps aided by an ongoing feud with 🥀 (13.8), who falls from his personal high.
🍊🤴 (1.0), for his part, kisses the floor.
Subject Favorable Neither Unfavorable Index²
💎 87.7 7.0 5.3 91.2
🏳️‍🌈 86.6 7.5 5.9 90.3
👩‍⚖️ 84.5 10.2 5.3 89.6
🐎 74.3 15.0 10.7 81.8
👮🏾‍♀️ 42.2 27.3 30.5 55.8
👵🏼 34.2 23.0 42.8 45.7
🌿 26.2 25.1 48.7 38.7
🌹 11.8 20.3 67.9 21.9
🥀 11.2 5.3 83.4 13.8
🐘 3.2 8.6 88.2 7.5
🍊🤴 0.5 1.1 98.4 1.0

Bernie Sanders vs. Donald Trump

https://preview.redd.it/mve7hnyfodo41.png?width=427&format=png&auto=webp&s=6dc3f26f3106411133c5e830746f1e9aab1fc7be
The overwhelming majority — 8 in 10 — of neoliberal are willing to hold their noses and vote for 🥀 were he the nominee, but the percentage shrunk by just over 1 percent in every successive wave but one, while the number of defectors reached a high of 8 percent in the fourth before receding somewhat. This is perhaps due to the increasingly bitter nature of the primary.
Candidate Wave 1 Wave 2 Wave 3 Wave 4 Wave 5
🥀 82.0 80.7 80.6 79.3 78.1
Neither 15.8 12.9 13.3 12.7 16.6
🍊🤴 2.3 6.4 6.1 8.0 5.3

Policies

https://preview.redd.it/phl3ug4fpdo41.png?width=427&format=png&auto=webp&s=798f47119e768445322d48217d5d97e6c3901cce
A similarly overwhelming 82 percent majority across all five waves oppose allowing businesses to deny service to LGBT+ customers on the basis of their orientation, while just 1 in 8 expressed support.
Policy Wave 1 Wave 2 Wave 3 Wave 4 Wave 5 Total
Yes 12.2 9.3 14.5 15.3 10.2 12.3
Neither 3.6 5.7 8.5 4.0 7.2 5.7
No 84.2 85.0 77.0 80.3 82.9 82.1

https://preview.redd.it/bbg0cm14qdo41.png?width=427&format=png&auto=webp&s=0cbfede1b1f25601d9b018e6e28a178163bb7aeb
By a 7215 margin, neoliberals support changing the individual income tax schedule in the United States to add 40 and 45 percent brackets for respective annual incomes over $1,000,000 and $2,500,000. (The difference between the waves with highest and lowest margins in favor are statistically significant, although the reason behind this is unclear.)
Policy Wave 1 Wave 2 Wave 3 Wave 4 Wave 5 Total
Yes 71.2 73.6 69.7 68.7 75.9 71.9
Neither 14.9 12.9 9.7 14.0 12.8 13.0
No 14.0 13.6 20.6 17.3 11.2 15.2

https://preview.redd.it/rm2xubohsdo41.png?width=427&format=png&auto=webp&s=a245ffa57b65799c1795ad6dd6b7990d15331b56
An incredible 3 in 4 respondents offer support for the politically suicidal stance of no government restrictions on abortion rights, with just 1 in 6 opposed — yet more evidence that neoliberal's moderation applies only to economics and not social and cultural issues, where its orientation is solidly leftist.
Policy Wave 1 Wave 2 Wave 3 Wave 4 Wave 5 Total
All cases 77.9 74.3 72.1 72.7 74.3 74.5
Neither 6.3 10.7 8.5 9.3 11.2 9.0
Less often 15.8 15.0 19.4 18.0 14.4 16.4

https://preview.redd.it/6x2px4s32eo41.png?width=427&format=png&auto=webp&s=6fcb1f2d67381d38e0e00af17813b9871c98ac64
On the flipside, significantly raising tax rates on higher corporate income brackets while cutting them for lower ones receives a cool reception: just under 1 in 3 expressed support for the proposed change. Many (1 in 5) were unsure, however, and the percentage of opponents falls short of majority level.
Notably, following an initial dip, approval of the proposition increased significantly from Wave 2 to Wave 5. Again, it is not clear what was behind this shift.
Policy Wave 1 Wave 2 Wave 3 Wave 4 Wave 5
Yes 28.4 27.1 30.9 30.9 39.3
Neither 21.6 19.3 20.0 20.0 18.0
No 50.0 53.6 48.1 49.1 44.7

https://preview.redd.it/95m4unun2eo41.png?width=427&format=png&auto=webp&s=ba172cb732ef8cd4c474e2d3b96eba8c501db50f
A narrow 2-point plurality favored outlawing semiautomatic rifles and magazines carrying over 10 rounds over the entire survey period, but this masks the sharp drop in support from the first wave to the second.
There is an explanation that likely accounts for this precipitous change: 🛹's politically risky proposal for a mandatory buyback of AR–15s, as well as perhaps prior preference for sub-favorite 🏳️‍🌈, who was its most vocal opponent.
Policy Wave 1 Wave 2 Wave 3 Wave 4 Wave 5
Yes 51.4 43.6 40.6 41.3 43.3
Neither 13.1 10.7 12.1 13.3 14.4
No 35.6 45.7 47.3 45.3 44.2

https://preview.redd.it/4bp3y2hs3eo41.png?width=424&format=png&auto=webp&s=d82df066af647380fe3d3b55809e201cfaa9acfc
No policy proposal saw a greater consensus than the introduction of a public option for Medicare, with an impressive 7 in 8 in support. The unequivocal figure is emblematic of the observation that the disagreement between the center-left and the hard-left is typically over the means — not the end.
Policy Wave 1 Wave 2 Wave 3 Wave 4 Wave 5
Yes 86.5 85.7 87.3 86.0 89.8
Neither 6.3 6.4 6.1 4.7 3.7
No 7.2 7.9 6.7 9.3 6.4

Demography

https://preview.redd.it/wd03n92q4eo41.png?width=424&format=png&auto=webp&s=365a52b4516f591c2a1340bd68bc3e932d957627
neoliberal is a downright fraternity, with over 9 in 10 respondents identifying themselves as male and just 6 percent as female. The remaining 1 in 40 or so identified beyond the gender binary.
(I did not try to break out transgender males and females specifically, fearing that the small figures might convey more noise than signal.)

https://preview.redd.it/gqpsmokr4eo41.png?width=424&format=png&auto=webp&s=640a30c8db352ca992ce08e95205752b7b49ca6f
An alternate tagline for this community could be "Zoomer Nation," as a 3 in 5 majority are too young to be included in the Census Bureau's calculation of the percentage of Americans with a college degree. The pattern in the remainder of the sample was scarcely any less stark: 1 in 3 were between the ages of 25 and 34. A vanishing 1 percent — 9 respondents — were 45 or older.

https://preview.redd.it/da6qct947eo41.png?width=424&format=png&auto=webp&s=dc80a11a299662cc5f8737de9879ba10bf5641d8
Limited to the 40 percent of respondents aged at least 25, this subsample offers yet another indication of how vastly different the userbase of neoliberal is from the general population. With nearly 6 in 7 seniors harboring a bachelor's degree — and 3 in 8 having at taken courses further beyond — the community comprises an elite stock. (As of 2018, 35 percent of Americans in the same age range have graduated college.)

https://preview.redd.it/ja1o5tiu4eo41.png?width=424&format=png&auto=webp&s=1d5fa218d660066b20644aa2112cc7b4cffaff88
Somewhat over 3 in 4 of the sample identified their ethnic background as white — likely a few Taylor Swifts short of what the community has seemed to envision as a battle against a polar bear in a snowstorm at the 90° parallel.
Considering the proportion of respondents from the United States ⬇️, Asian neoliberals (8.4%) were overrepresented and users of mixed ancestry (7.0%) even more so, while Hispanic (4.5%) and Black (3.2%) members fell far short of their representation in the general population.

https://preview.redd.it/8gndqetw4eo41.png?width=424&format=png&auto=webp&s=2a562687baaec05f41651d115a6f8c5b11f1400f
neoliberal is a highly secular community, with 2 in 3 stating their irreligiosity, while about 23 percent identified as Christians and 10 percent professed their affiliation with another religion.
(It's worth pointing out that these numbers are meaningfully out of line with a survey conducted of this subreddit two years ago, wherein a full 80 percent selected one of the religiously unaffiliated options and just 5 percent reported identification with another religion. It is possible that the use of "Unaffiliated" instead of "No religion" as the third selection confused certain respondents.)

https://preview.redd.it/w7ix2c635eo41.png?width=424&format=png&auto=webp&s=bcae5fdbdb89918b7227bcbceb7682064d156ca2
Perhaps a sign of the generational times, right between 1/5 and 1/4 of respondents identified as a sexual minority. This is far higher than surveys of the public report for the youngest generation, however, so other major factors are certainly at play.

https://preview.redd.it/24xvb2f77eo41.png?width=424&format=png&auto=webp&s=a1f462e3c691e9ff727b027f3b4d0ff62babd02d
In an attempt to limit the sample to those for which the questionnaire would be most relevant, I discouraged non-Americans from taking the survey, so these figures are not intended to be representative. (A follow-up poll strongly suggests that few heeded the request.)
However, I have included it to contextualize the rest of the data.
~ ~ ~ ~ ~
All Graphical Representations
Detailed Responses by Individual (useful for those who would like to do analyses of their own)
——————
¹ I discovered in a poll following up my wave survey that the lack of options for different intensities of positive/negative opinion omitted critical nuance in the data. Relatively speaking, 🏳️‍🌈 suffered most because of this, while 💎 benefitted a fair bit.
² Favorable = 100 | Neither = 50 | Unfavorable = 0
submitted by IncoherentEntity to u/IncoherentEntity [link] [comments]

NEW 100% WIN BINARY OPTION FREE TRADING SIGNALS - YouTube Binary Option Best Signals Service In 2020 - YouTube Binary Options Strategy 2020  100% WIN GUARANTEED ... Binary Options Signals Indicator 100% Free Download! - YouTube Binary options trading  Binary options signals - YouTube Binary Option Winner Indicator Signal For Iq Option Live ... Binary Options 60 Seconds Indicator 99% Winning Live ... Binary Options 60 Seconds Indicator %100 Winning Trades ... Price Action Binary Options Signals That Work - YouTube GOD OF INDICATORS - 99,99% work - binary option strategy ...

Please login Email address Password. Remember me for 2 weeks Log in Welcome to binary options.All or nothing, one or zero, these securities are available on Nadex.   Binary options allow traders to make time-bound conditional bets on predefined values of ... Pro Signal Robot does not advertise binary options for anyone and does not invite anyone to join binary options trading. Pro Signal Robot has developed software to help traders to execute and monitor trades. Pro Signal Robot is not affiliated, endorsed, or sponsored by any binary options brokers. Also, we do not provide brokerage or trading services. The signals made by our software are based ... Binary Options Trading Template; MA2 Signal Indicator; Signal Mantapz Indicator; Scalper Signal Indicator; Waves Signal Indicator; Signal Length Indicator; Leman Signal Indicator ; Cristal Ball Signal Indicator; SMA Crossover Signal; Silvertrend Signal; Volumes MTF & Signal MA; Discontinued Signal Line; Geo Crossover Signal Sistem; LWMA Crossover Signal; Momentum ATR Normalized Signal; EMA ... Vdub Binary Options SniperVX v1 Designed for Binary Options 60 sec trading upwards Notes on chart Please note the signal generated are configure to be super fast on candle opening. The down side to this is signals may switch direction mid stream. ITM candlesticks signals generated went 6/300 Losses on a 1 min chart. the blue line indicates reversal zones. Buy /... Signal Index connects directly to a trading account you own with an approved broker. You don't have to be an expert in foreign currency, binary options or commodities, but you can trade just like the pros do by following their moves. When the signal you subscribe to makes a trade, so will you. You don't even have to have your computer on! Get Started in 4 Easy Steps. Register an account. It ... 60 Seconds Options Signals. 60 seconds (1 minute) Forex, Currencies, Commodities, Crypto, Options Indicator Signals Indicator for Metatrader (MT4, MT5). 90% daily win-rate! 50+ trading signals a day! 100% Non REPAINTING! 100% RELIABLE! Predicts price, price movement direction, generates pure call/put signals. 64# Money Flow Index Binary System; 65# CCI explosion Binary System; 66# Color Stochastic Binary System; 67# Alligator Binary System; 68# AF Binary System; 69# AGTS ver. 5.3 Binary System ; 70# Price Action Channel Binary System; 71# Stochastic Oscillator 21, 8, 8, Binary System; 72# Harami Binary Options Strategy; 73# MACD Binary Strategy; 74# TMA Binary System; 75# The Power of Trend ... All new forecasts issued by Best Binary Options Signals contains all information you need to make a trade. It is very easy to understand what each signal means. From the example, you can see two signals. The first one that was sent at 12:20:03 means: the price for the asset GBPJPY at 12:30:00 will be lower than 152.322.When you will see that the price for the asset during current 15 minute ... Binary options canada – binary options bullet trading signal service; Binary Options – 15 minutes Strategy Live ( HOW I GET $15259 In First Month! ) Binary Options Pro Signals; Binary Options – My secret Strategy 2015 ( HOW I GET $9654 In First Month! ) Binary Options Trading Systems 2016 – Collection Systems Are Most Profitable

[index] [8281] [19525] [24145] [21590] [7906] [18638] [6688] [18464] [10976] [4455]

NEW 100% WIN BINARY OPTION FREE TRADING SIGNALS - YouTube

OLYMP TRADE broker account opening link below: https://goo.gl/urftNR this video contains two trading examples with explanation. watch and learn how to trade ... Published on Jun 19, 2017. Binary Options Signals Indicator Free Download: https://www.altredo.com/altredo-free-... The BO Indicator is an Meta Trader 4 signal indicator that will advise you when... Stop wasting your money for nothing if you are suffering and couldn't make money from binary option you have only 1 choice to Gain Gross profits. Free Telegr... Hi Friends I will Show This Video Binary Options 60 Seconds Indicator Signal 99% Winning Live Trading Proof -----... get trading bots contact with telegram https://bit.ly/3aR8baT get pro or free signals https://bit.ly/2N5PLrp get strategy trading, visit my twitter https://b... I Will Show In This Video Binary Option Winner Indicator Signal For Iq Option Live Trading _____ Join Telegram : http:... Binary options trading Binary options signals Hi there! I'm Lady Trader and today I'll show you my binary options strategy 2020 that I use in binary tradin... The road to success through trading IQ option Best Bot Reviews Iq Option 2020 ,We make videos using this softwhere bot which aims to make it easier for you t... One minute strategy to trade price action trading signals. Watch how I use simple trading rules to increase win rate. Get 10x Trading System: https://trading... Do not miss! DEMO ACCOUNT: https://bit.ly/2Lq3NUt You can use this strategy in binary options to win every time but you have to keep following things in mind...

http://binaryoptiontrade.roredadec.gq