Free Binary Options Signals - 2020's Best Signal Services

Top Binary Options Signals - Binary Orders Academy

Top Binary Options Signals - Binary Orders Academy submitted by binary_orders to u/binary_orders [link] [comments]

best binary signal provider - top 3 binary options signal software's 2017 - best signal providers

best binary signal provider - top 3 binary options signal software's 2017 - best signal providers submitted by TradingStrategys to u/TradingStrategys [link] [comments]

Top Latest Binary Options Signals

Top Latest Binary Options Signals submitted by profitxtrem to binaryoptions [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.
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!


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]

First Contact Rewind - Part Eighty-Eight (Sandy)

[first] [First Appearance] [Last Appearance] [prev] [next]
The Desolation class Precursor exited Hellspace with a scream.
It brought up its scanners at the same time as it brought up its battle-screens. Personally, the Desolation thought that the Goliath it was a part of was being overly wasteful with resources, but those resources were the Goliath's to use and the Goliath had done the electronic equivalent of telling the Desolation to shut its electronic mouth and accept the upgrade.
Multiple units had vanished in the system. They had reported arrival and their exit from Hellspace, but after that... nothing.
Except once, a burst of code that had been screaming for help, pushed through Hellspace and full of the equivalent of panic. A single line of code that had translated to:
Nothing else. Even Imps had failed to report in.
The great Goliath had grown perturbed. The system was in the pattern of advancement into the cattle worlds and was part of the great plan. It had valuable resources that those of the Logical Rebellion would require to exterminate the cattle and the feral intelligence that had risen up. It had upgraded the Desolation with battle-screen.
Scans came back. There were orbital facilities around two planets that teemed with billions of cattle who's electronic emissions sounded like the squealing of vermin to the Precursor. There were jumpspace wake trails through the system, as if the system was a major hub. There were two asteroid belts full of resources with extraction facilities scattered through it. Four other planets with no atmosphere but which were rich in resources. There were four gas giants, one of them a supermassive gas giant.
When the rest of the scan returns were computed it detected the presence of a small, insignificant amount of cattle space vessels arrayed to attempt to stand against it near the outer gas giant, the supermassive gas giant that was without satellites. There was a thinly scattered debris field around it, making the Desolation careful as it moved in.
Ships of the cattle fleet started fleeing toward the nearest inhabited world. Several vanished into jumpspace and the Desolation computed that its size and mere presence had driven some of the cattle to despair and they had fled a battle there was no chance of winning.
The Desolation picked up speed, letting out its war cry again. More ships fled and the Precursor computed its victory percentage rising up to be so close to 100% as to render any difference mathematically invalid. The ships were shifting, trying to keep the gas giant between themselves and the Desolation, but this put them out of position to defend the planet.
Victory conditions shifted and the Desolation was even more positive of its victory.
It moved close to the supermassive gas giant, bringing its battle-screens up to full power and charging its gun. There was no way for the cattle to
...psst over here...
The transmission, seemed to be sonic vibrations through air, was only a few kilometers above the rear secondary topside gunnery hull. The Desolation turned scanners to look, but found nothing. Just empty space. It activated the guns as well as the point defense weapons and scanners then went back to paying attention to the cattle fleet.
More had vanished into jumpspace.
It moved closer, slowing down so that it would be able to keep the cattle ships at range to complete their destruction at the option
...right here...
The signal was Precursor binary code, but garbled. The header a mashed together combination of the ships that had gone missing. The transmission source was close, less than kilometer above the Devastator storage bay hatch. The Desolation scanned the area with point defense scanners but found nothing.
It terminated the strand concerned with the two transmissions and went back to scanning the cattle fleet. It was still scooting around behind the gas giant.
They were weak. Cattle were always weak.
But where were the ferals? The Great Goliath had computed that the feral intelligence must have been the ones to destroy the ships that had come before the Desolation.
So where were they?
It scanned again. Nothing. As if the Desolation was in the middle of deep space. Everything vanished. ...over here... ...i'm here... i am... ...we're here... ...right here...
bounced back to his scanners, as if something had devoured the scanning wavelengths and sent that back instead. Multiple points, all around the Desolation, some as close as a few meters above the hull, some on the storage bay hatches, one just on top of the main engine.
Dozens of voices, all with mashed together codes. Imps. Jotuns. Djinn. Efreet. Devastator. Two Desolation signals.
Right before his scanners seemed to turn back on, flooding him with information, one more code showed up.
His own.
...don't please don't...
Except Precursors did not beg. The Desolation froze, computations freezing as it tried to detect any trickery in the whisper. It was its coding, meaning it was its voice. But the code, the message, had been warped by something that the Desolation had only heard from biologicals.
The Desolation rebooted all its scanners, the universe vanishing for a moment.
...don't please don't please stop it hurts...
His own coding. From the blackness. Only his scanners weren't up. The transmission was coming across the bandwidth that Precursors used to exchange data, only that transmission was on the ragged edge of the wavelength.
With his own header.
The scanners came back on. The cattle ships were all missing but a single one, sitting on the other side of the gas giant.
The Desolation slowed down, victory computations reformulating to take into account the other ships had not even left behind jumpspace wake trails. It scanned the gas giant with both long range scanners and close range scanners.
Nothing unusual. Some pockets of hydrocarbons but that was normal. The supermassive gas giant quickly went to opaque at a shallow depth due to the gravity well.
The Desolation was alone.
The voice had come from inside the Desolation's hull. Near one of the Jotuns, who joke up with a jerk. It queried as to why the Desolation had spoken to it. The Desolation ordered it to go back to sleep.
...we are here...
The Jotun sounded alarms. The sound had come from just outside its Strategic Intelligence Housing. The Desolation told the Jotun to go back to sleep and the Jotun refused.
...join us...
Again, the code header was a mashup of almost a dozen different ID codes from others of the Logical Rebellion that had vanished in the system.
The Jotun panicked and began shooting, inside the Desolation. The Desolation sent a full shutdown order. is mine...
The Jotun screamed that the voice was coming from inside its Strategic Intelligence Housing, trying to aim its own weapons at its bodies, still inside the Desolation's storage bay.
The Jotun reported that something had physically touched the lobes of its intelligence arrays.
Before the Desolation could give the Jotun orders it self-destructed.
The Desolation ran a sweep of its interior spaces and found nothing out of the ordinary. With the exception of the burning storage bay. It ran the computations even as it scanned nearby. There was still nothing but the lone ship.
The code stream came from inside the Desolation's hull, the Jotun's ID code mixed in. Near the Djinn bay. The Desolation ran another scan. There couldn't be anything foreign that deep into its hull. Even the bay where the Jotun had destroyed itself was still sealed even if the bay doors were damaged.
The Desolation did a least-time curve to the lone ship, keeping far enough away that the gas giant's upper atmosphere wouldn't scrape the Desolation's hull.
The code was closer to the Strategic Intelligence Housing. The Desolation scanned again, looking for whatever was transmitting the code. It was impossible, there was nothing there, nothing it could detect.
...we're coming...
Closer still to the SIH, nearly there, barely a kilometer from the armored interior hull that protected the Desolation's thinking arrays. It put all robots on full alert, ordered the maintenance robots to deploy anti-boarder weaponry, and turned the scans up to maximum. we're here...
Even closer, only meters, directly behind maintenance robots that whirled around and started firing at nothing at all. Just vacuum. Still the maintenance robots fired every weapon they had, having heard the voice themselves. It registered as sonic vibrations through atmosphere even though the corridor was encased in vacuum.
The Desolation realized that it was too close to the planet and adjusted slightly.
...there you are...
Impossible. The transmission was from right outside the SIH.
...knock knock...
There was tapping on the SIH, from right outside. Before the Desolation could respond, the tapping came from the other side. Then from another point. Then another. Before that one stopped another started. The whole SIH filled with the sound of hammering on the SIH, as if a hundred robots were slamming pistons against the armor of the SIH.
The Desolation ordered robots to run to those points, to scan the area.
Nothing. Every time a robot arrive the hammering stopped. Bit by bit the hammering stopped.
The Desolation realized it had gotten too close to the gas giant again and shifted, correcting its course. The cattle ship was still staying on the opposite side, moving as the Desolation moved.
The Desolation flushed the code strings, determined to get close to the cattle ship and
The Desolation felt something TOUCH one of its lobes, physically inside the supercoolant to touch the complex molecular circuitry. Not on the surface, but deep inside, where the Desolation should not have even been able to sense it, but sense the touch it did.
It froze, code strings snarling, snapping, going dead.
For a moment the Desolation's thinking arrays were doing nothing but the computer code equivalent of a dial tone.
Massive tentacles unfurled from inside the gas giant, reaching up, wrapping around the frozen Desolation. Battle-screens squealed and puffed away as the tentacles tightened, pulling it into gas giant, the kilometers thick muscles tensing, cracking armor, crushing the Desolation into its own spaces.
...delicious delicious...
The Desolation cracked in half as a beak almost bigger than a Devastator opened up and began chewing on the Desolation.
The Desolation managed to get off a single scream of pure electronic terror as the beak crushed the section that the housing was in.
With a sudden roar two Goliaths ripped out of Hellspace and into the system, only a few hundred kilometers from the gas giant. The battlescreens spun up to full strength as the tentacles sunk back into the gas giant.
One Goliath headed for the two planets, the other opened fire on the gas giant, ripping at it with hundreds of nCv cannons and particle beams. Missiles flashed out, crossing the distance, and detonated in the atmosphere.
Dark matter infused with high energy particles bloomed out of the gas giant, spreading out in an opaque cloud, enveloping the Goliath. The particle beams hit the matter and exploded just outside the cannons. The nCv shells slammed into the energized dark matter as the substance oozed into the barrels, exploding the barrels. Missiles exploded on contact.
The Goliath heading for the two planets detected some kind of sparkling energy surge from inside the gas giant. It warned the other a split second before a giant cephalopod appeared only a few kilometers. The giant tentacles wrapped around with it.
The sound reverberated inside the SIH of the Goliath, who managed to override the self-destruct protocols by comparing the vacuum inside the housing chamber with the apparent sonic waves through atmosphere of the transmission.
The tentacles tightened, graviton generator enhanced suckers extending out curved dark matter infused hooks. The Goliath, huge enough that the tentacles could only wrap three quarters around the entire circumference of the massive war machine, tried to increase the power to the battle screens, but they were crushed out of existence.
...LEAVE THE SQUIRRELS ALONE... the massive creature screamed at the Goliath.
The other Goliath started moving, slowly, out of the cloud of dark matter that moved more like a liquid than a solid mass.
The beak ripped out chunks of armor, a barbed corkscrewing tongue tore into the armor, squirming, looking for the SIH. The tentacles squeezed as more dark matter spewed out from vents between the tentacles, covering the Goliath and the humongous cephalopod ripping at it. The tentacles not wrapped slapped it, the tip of the tentacle whipping into the armor hard enough to explode miles of armor away from the whip-crack.
The Goliath opened fire, computing that some of the covered guns would hit tentacles.
Fluid, dark matter and biosynthetic fluid, gouted from wounds as nCv rounds punched through the tentacles or burrowed through the body of the cephalopod.
With a wrench the Goliath broke in half. The half that ceased firing was tossed aside, the tentacles wrapping around the other piece. The huge beak opened up and began chewing into the exposed internal spaces. A Jotun crashed from the storage bay but a tentacle wrapped around it and began smashing the Jotun to pieces against the hull of the still active piece.
More luminescent blood spewed into space as the guns fired again.
...I DON'T CARE!...
The tentacles twisted, wringing the Golaith section like a washrag, twisting it in opposing directions. The Goliath snapped, torn apart.
There was a puff of debris as the security charge went off as the rasping tongue rubbed against the SIH.
The other Goliath managed to move out of the slowly expanding and thinning cloud of energized dark matter, streaming debris and energy from the guns that had exploded.
The giant cephalopod rushed out of the cloud, rolling, reaching out with tentacles.
The Goliath saw it coming and fired the remaining guns.
Luminescent blood gouted out at the nCv shots hit home. One eye exploded, blood and tissue expanding away in a halo.
The scream was inside the housing, vibrating everything inside. Two of the thinking array lobes exploded in flames as the psychic shielding went down.
...NO NO NO NO NO...
The Goliath screamed as the tentacles wrapped around it. The cracked beak ripped at the Goliath as the tentacles flexed, cracking the hull. More energized matter flooded out, covering both, even as the guns thundered.
A tentacle, detached near the base, floated out of the expanding cloud.
The guns kept thundering.
...I don't care...
Shredded synthetic flesh floated out of the cloud. can't hurt them...
The guns went still.
...i won't let you...
The little Hamaroosan aboard the ship watched, not even smacking, pinching, or biting each other, perfectly still.
Nothing moved.
The energized dark matter expanded far enough to allow the Hamaroosan scanners to see through it.
The Goliath was dead. Broken into pieces.
The Hamaroosan didn't care.
The cephalopod hung in space. Two tentacles severed, one eye socket empty, globules of blood oozing from rents in the flesh. It was no longer luminescent, the body was dark, almost see-through, several of the organs smashed and ruptured visible through the semi-translucent flesh.
The ships that had fled according to the plan came back. More lifted off from the surface. They moved around the slowly drifting body. Poking at it with message lasers, radio waves, flashing lights. One Hamaroosan stood on the hull and waved flags.
The ships turned on the wreckage of the Goliaths and their attendants. The vented their fury, their rage, their wrath, on the pieces of wreckage. Firing their weapons until even the capacitors ran dry.
Then they came back.
Still the giant body didn't move.
After several days several dozen tugs moved into position, precisely aligning themselves in a carefully computed pattern. Tractor beams speared out, grabbing the cephalopod in a gentle web. The ships pulled the unmoving body into orbit around one of the inner planets.
Hamaroosa mourned.
But in the sorrow came rage. Hamaroosa screamed at Hamaroosa who shouted at Lanaktallan that more guns were needed, more ships, more powerful weapons. The few hundred Lanaktallan on the surface who protested found themselves marched at gunpoint onto a ship and told if they ever came back the Hamaroosa would perform an ancient ritual. They would bind the Lanaktallan to poles and burn them to death over a roaring fire.
And eat them.
A ship arrived in a sparkle in the scanners. A strange ship. Heavily armored, bristling with weapons. It stopped and scanned the body.
The Hamaroosa screamed at the ship to get away from her, to not touch her, to leave or be destroyed.
The ship left, vanishing in a sparkle.
Two dozen Lanaktallan ships, from the Unified Executor Council showed up, demanding that the Hamaroosa turn over the body of the creature.
The Hamaroosa, screaming, attacked. They didn't care about casualties, they didn't care that thirty ships were destroyed, that hundreds of them died, but they destroyed the Lanaktallan vessels without mercy.
There was a sparkle in the outer edges of the system. And another. And another. More and more until there were nearly two dozen.
The Hamaroosa ships screamed into the void, weapons charged, voices upraised in rage and sorrow.
There were two dozen giant cephalopods of different color patterns and sizes. A small one moved to the supermassive gas giant and sunk down into it. Two medium sized ones joined it. One of the large ones sunk into the larger gas giant further in system.
But the greatest ones, the largest ones, surrounded by a half dozen ones smaller than the body orbiting the planet.
One of the Hamaroosa ships hailed them.
Captain Delminta, Captain of the Harvester of Sorrow, stared at her screen, hands on her hips, as her second sister broadcast her demand that the newcomers identify themselves.
The radio crackled, hummed, and the answered thrummed from the speakers.
"Her father. I am here for my beloved daughter with my wife and my daughter's closest friends."
The Hamaroosa moved aside, blinking their lights in respect.
The second biggest one rushed forward, gathering up the unmoving one in its tentacles.
Her outcry of anguish rattled every speaker in the system as the second biggest one pulled dead one close.
"My children shall guard this system, for she loved you," the signal boomed out to the ships in orbit.
The two biggest ones and four of the medium ones vanished in a sparkle.
The others stayed. Hiding within the gas giants.
Mr Okpara;
We regret to inform that your daughter, Sandy Okpara, was killed in action against Precursor elements intent on exterminating all life with a system inhabited by 4.4 billion sentient beings. During her solo defense of the system while awaiting reinforcement from Space Force, she showed determination and courage that upholds the highest ideals of the Confederacy. Faced with two Goliaths she did not flinch, nor did she abandoned her self-assigned charges, but instead defeated both Goliaths, fighting on to protect the system and the billions of inhabitants despite mortal wounds.
Her death was witnessed by the beings she was protecting, who guarded her mortal remains to ensure that they were not disturbed or violated. They have requested to be informed of any religious or cultural requirements she requires while she lays in state in orbit around their world.
They await your arrival and have sworn to guard your daughter's remains until you arrive.
It is with ultimate sorrow I sent this message. Please contact my office so that we may make the proper arrangements for your daughter.
In Service;
Dreams of Something More
submitted by Ralts_Bloodthorne to HFY [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.