Greetings, Risk Five friends. So today, we are going to be talking about formally verifying what I've written for the Risk Five CPU. I'm building a Risk Five processor, not on an FPGA. Now, the Risk Five CPU is not yet complete. One of the things that I left out was interrupts, and interrupts are going to be pretty important, something that I'm going to want, because otherwise, I'm just going to have to, like, you know, if I'm reading a keyboard, I just have to pull it. And then what is the main program going to be doing? Well, the main program has to allow the poll to happen. And that's just a big waste. So I definitely want to have interrupts. So the keyboard would send an interrupt to the processor, and then the processor would jump to some address, handle the interrupt, and then jump back to the main program. So that's something that I'll tackle on the next video, because it does involve adding more stuff, probably adding more cards. And if you know about CSRs, it's going to involve CSRs. But what I've done is I've formally verified whatever I've currently written for the Risk 5 CPU, which means the instructions, minus all the CSR instructions, and eBreak and eCall, which all pretty much require CSRs. Now, this is the first time that I'll be using ProveMode for YOSUS, or Symbiosis, in formal verification. Whereas before, all I've been doing is BMC, Bounded Model Checking. So let me see if I can try to explain what the difference is, and why ProveMode is so much more rigorous than Bounded Model Checking alone. So here's an example of a state diagram. So let's suppose it's a counter, it's a 3-bit counter, and I've written it so that it goes from 0 to 1 to 2, and then back to 0 again. And if I were to set the counter up to 3, it would go 3, 4, 5, 6, 7, and then, you know, maybe it would, I don't know, get stuck at 7, just as an example. Now, the red arrow is going to be a bug that I introduce. So obviously for a counter, you know, that wouldn't happen because it would go to some state, but let's suppose that it were a lot more complicated than a counter. You know, let's suppose that I output the value of a 3-bit register, and then it takes in a thousand other signals, and it determines what the next state is supposed to be, and the next state from 2 is supposed to be 0. But for whatever reason, I have a bug in my huge complex combinatorial logic that sometimes makes state 2 go to state 3. Okay, so let's suppose I were to set up Bounded Model Checking on this model, and I say, okay, well, you know, I know that my counter is going to go from 0 to 1 to 2, and then back to 0 again. So really, all I need to do is check for 4 states, you know, the initial state, and then 3 transitions after that. So the idea is that this would be state 1, this would be state 2, this would be the 3rd transition, and then for the 4th transition with Bounded Model Checking, we would go here and here, and because we didn't hit any assertions that this was an illegal state, Bounded Model Checking would say, hey, everything works. Now, let's suppose that I wanted to say, well, state 7 here is invalid. So I'm just going to circle this in red, basically saying that I'm asserting that we're never going to get into state 7. And again, you can see that Bounded Model Checking up to 4 states is going to work. In fact, I would have to do Bounded Model Checking up to 7 states or, you know, 8 states or whatever in order to hit that assertion. Now, you know, you would look at this and you would say, well, sure, I mean, that's a simple counter, but imagine that it weren't a counter, but instead, you know, each one of these states expanded into a huge state diagram. So, you know, maybe I would say, oh, well, I know that all of these states over here represented by this one state 7 are all invalid. And I did a simple check that said, oh, I can never do this at the same time that I'm doing that. And that's what, you know, this one state represents. So, you know, I obviously don't know enough about the rest of the states in order to properly say, well, you know, I need to assert that I will never get into state 3 and also never get into state 4 and also never get into state 5 and also never get into state 6 and also never get into state 7. So, this is a case where Bounded Model Checking can sort of fool you if you don't go far enough that your circuit is correct. And the problem is that maybe with Bounded Model Checking, if you do go that far ahead, it will just take forever to check, you know, just because the circuit is so complex. So, this is where Prove Mode comes in. And this is where Induction comes in. So, in Mathematics, let's suppose you have some function f that has one integer parameter k, say, or let's just call it n, where n is 0, 1, 2, or so on. And I'm sorry that I'm bringing math into here, but bear with me, I'm going to have a little pictorial analogy here. So, what you want to do is prove that some property holds for f of n for all n, no matter what that n is.  Now I'm going to prove my assertion for f of 1. Now I'm going to prove my assertion for f of 2. And, you know, keep doing that for all infinity numbers. So, sometimes it's just way too complicated than that. So, what Mathematical Induction is, is you just take one case, and that's called the base case. And, you know, typically if you're dealing with n going from 0 and n on, you would start with your base case being proving f of 0 is true. So, now what you say is, well, if f of k is true, then what you do is you prove that f of k plus 1 is true. So, if you can do that without actually having to say whether f of k is true or not, you just assume that it's true, and then you prove that if it's true, then f of k plus 1 is true. If you do that, then you can say, well, here's my base case, f of 0. And I also have this thing that says, if k is true, then k plus 1 is true. So, what I can do, let me see if I can sort of animate this. So, what I can do is I can take this and move it over here and say, oh, wow, because of this tool that I have, I've now proven that because 0 is true, and if 0 is true, then 1 is true. So, 1 must be true. So, now I can just take my tool, which I've proven, copy and paste. Yeah, that works. And take that and say, and apply it again. So, 0 is true, now I know that 1 is true, and of course, if 1 is true, then 2 is true. And then I just keep building on. And because of this, I can prove that f of n is true for any number. And that's what mathematical induction is. So, how does this relate to formal verification? Okay, so here I've written up on the left side what mathematical induction is. You have a base case, and then you prove that if 1 thing is true, then the next thing is true, and therefore your assertion works for any number. So, for formal induction, the way it works is like this. Let's suppose you do a bounded model check, and you say, okay, I'm going to do a bounded model check for four states, right? So, there's 1, 2, 3, and 4, and 4. And that's your base case. So, what you're saying is, I know that four steps starting from my initial condition will not hit any assertions. Great. So, now the induction step is, I need to prove that there are no sequences of k plus 1 steps that fail, regardless of where they start. So, that regardless of where they start thing is the equivalent of f of k.  So, what I want to do is, let me choose a different color.  So, what we'll do is we'll start from an assert that will fail. Here's 1. So, k plus 1 would be 5, right? So, that's my k plus 1 state. And that's where I'm going to start. So, now I just go 4. Now, because there's this transition here, this is also 4, right? Because I'm sort of working backwards, and I'm looking at all the different transitions where 7 can come from, and 7 can come from itself. However, in this case, what I'm going to say is, oh, well, I mean, if I hit an assertion over here, then I'm just going to take that away because that is actually not a valid series of steps that don't fail. So, 5, 4, right? 3, 2, 1. And that's the end. So, because I hit one case where a sequence of 5 steps can fail, I'll say that induction fails. So, let me show you an example of a sequence that doesn't fail. So, let's suppose I start from here, 5. Well, it can come from 4, and then that can come from either, no, it can't come from there. It can come from here, 2, 1, and that's it. So, that's an example of a path that doesn't fail. But the point is that I need to make sure that all such paths don't fail. And here, formal verification in the induction phase has shown that there is actually a sequence where there is a failure. So, how would you solve this? So, this is induction. And this basically, and the conclusion for the induction is that, well, if it fails for one of these cases, then you haven't proven that your circuit works, right? And the reason that I haven't proven that my circuit works is because I have this buggy transition over here. And really, the problematic state is this state right over here, 3. Because if that were also covered by an assertion, if I were to make this invalid, then A, bounded model checking would have found it, right? But B, because this path here during induction failed, then that is not a sequence that I can consider. I could only start from state 3. Okay. So, that's one way of actually sort of fixing the problem. If I say, if I look at the trace that induction gave me, and its trace is going to show me 3 to 4 to 5 to 6 to 7 where the assertion fails. So, I'm going to look at this, and I'm going to say, well, why did it get into that state? So, here is 3, and I'm going to say, well, that should never happen either. So, I'm just going to say, I'm just going to put in an assertion that 3 can never happen. And then I'm going to run induction again. Well, in that case, the base case is going to fail because we have, in the base case, let me just get rid of all these little annotations here. So, in the base case, we were looking at 1, 2, 3, 4, and 4, and we would hit this assertion. So, now formal verification is going to throw up this trace, 0, 1, 2, 3. And then I'm going to look and say, well, wait a minute, there's no way that 2 should have been able to get to 3. So, therefore, that's where the bug is. When I'm in state 2, some condition causes my circuit to go into state 3. So, that's why induction is more powerful than just bounded model checking alone. So, in EOSIS terms, or symbiosis terms, there are two modes. There's BMC mode and there's Prove mode. What Prove mode is, is the bounded model checking in order to establish the base case followed by the induction step. So, by running in Prove mode, I have a more rigorous check on my circuits. Okay. So, here we go, the formal verification of the processor. So, the first thing I need to do is basically create the buses and hook up all the cards together. So, that's what formal CPU is. So, here are the signals. These here are all the signals. We have the cards over here. We have the X, Y, and Z bus. And now we're going to hook up the buses. So, some of the cards get input from the buses. Some of the cards output to the buses. So, I just basically hook that all up. And this is what you do when there's sort of like a bi-directional bus where you can have multiple cards actually sending out data. Remember, I said that when a card is disabled from sending data, it actually sends out zero in the, in my gen. It would be tri-stated in the actual circuitry, of course. But because it outputs zero, we can or the outputs together. And that has basically the same effect. Okay. So, the next thing that I do is just hook up the control lines to each of the cards. That's fairly straightforward. There's the M-cycle end line as well. There's a memory bus now. The formal CPU has these as sort of like the external signals. So, these are the things that it will use to communicate with the outside world. And right now, the outside world just consists of the memory. So, that's what I'm hooking up right over here. And then, there is the illegal signal and the instruction complete signal that I also essentially route to the outside world so that I can see them. Okay. So, then there is a function that I'm using to decode the immediate value. And this is slightly different from the equivalent in the sequencer card. So, if we go to the sequencer card, and if I can find, decode immediate. So, here's decode immediate. And the way it works is that we take the immediate format of the instruction that we're decoding. And then depending on, you know, maybe it's an I format instruction, what we do is we create a temporary signal and then put the various instruction bits into that temporary signal. What I've done for the decode immediate in the formal CPU is I've taken a slightly different tack. And that is the immediate is always a 32-bit signal. So, we're not using a temporary. And then based on the opcode, we're not actually going to look at the format of the opcode or of the instruction. We're just going to look at the opcode itself. And then we are going to set the bits. And this is actually taken straight from the risk five spec. So, it tells us how to format an immediate value based on what bits we need to take out of the instruction. So, it's a slightly different way of writing the same code. And this is sort of a good check. You know, if I need the same functions in the verifier that I'm actually verifying, it's a good idea to switch things up and write the code in a different way so that at least, you know, you can be sure that things are consistent with themselves. So, that's what that is. And now, here comes the strategy for how we are going to formally verify the processor. So, the idea is that, let's suppose we wanted to formally verify one of the instructions. So, what we do is A, we assume that that instruction has completed, that that specific instruction has completed. So, I know we have an instruction complete signal. We also know what instruction we are currently executing. So, what we do is we just write an assume statement that says the instruction completes and this is the instruction that we're looking at. So, that way we don't have to run essentially all of the instructions in parallel when formally verifying things which can sort of slow things down. So, the idea is that, before the instruction executes, we take a snapshot of all the registers and the program counter. And then after the instruction executes, we also take a snapshot of the registers and the program counter. And during the instruction, we also keep track if there were any external memory reads or writes. So, that's what all of this is. This is collected. And inside collected, we have an array of the registers before the instruction and after the instruction. The program counter before and after, the instruction that was being executed, and then opcode RS1, RS2, and all the way down to ALU op. Those are just, you know, combinatorially taking the values from the instruction. Same thing with the immediate value. We also have some bits that allow us to keep track of whether a memory read happened or a memory write happened. Because aside from reading the instruction itself, you don't do any external memory read or memory write at the same time. It's either going to be a read or a write. So, that's why we only have one 32-bit register for the address that we accessed. And then what data we read, what data we wrote, and the right mask. Okay, so this is just, you know, the same thing, decoding the instruction into its various fields. This is decoding the immediate out of the instruction, and that's that. So, then I have a bunch of utility functions, which I'll get to later. What I want to do now is go to the main function, which is right here. So, this is my main function for formal verification. So, I set up an empty module and I add my CPU. And the CPU is the formal CPU, which is the, all the cards connected to each other. And then there's a clock that I make, which, you know, basically generates phase one and phase two. And I'm also going to pull out the M-cycle end out of the, out of the clock. Okay, so we create this data structure. And now what we're going to do is we're going to count machine cycles. So, we start at zero. And then, you know, as the instruction proceeds, we just count the number of machine cycles that happen. And just like in testing memory, we are going to set the registers to some random value and the program counter to some random value. So, that we're not always starting from all zeros. So, this way we can check that things are, you know, more generally working. So, the next thing that we do is we initialize the CPU's register and program counter with those random values. Now, they're not exactly random.  Formal verification actually assumes any value. And if it finds a case where an assertion is violated, it will say, oh, it was violated. And by the way, these were the values that, you know, made it violate. Maybe they're a direct cause of the violation or maybe it doesn't matter. But the point is that, you know, at least it tells you. So, initially, what we do is we set the registers, the program counter here. And what we're also going to do is we're going to assume that the random value for the program counter is 32-bit aligned. So, that's what this assumption does. And here, what we're doing is we're making sure that our collected data will be the initial registers. And also that the X bank for the registers is also set to the initial register. Now, later on somewhere, I also have an assumption where the, I think I have an assumption, where the X bank and the Y bank are the same. So, of course, right here, all I'm doing is I'm making sure that the X bank is the same. But I say nothing about the Y bank. So, later on that will come into play. The next thing is let's go all the way down to the bottom where I return the module that I create and the signals that formal verification is allowed to monkey with. Now, if you think about it, really the only input into the CPU at this point is the external memory. It's the source of the instructions and it's also the source of any memory reads. And that's it. Everything else is an output signal. So, really the only thing that formal verification has available to it to exercise the CPU is the memory data that we're reading. So, that's why this has only one element, just the memory data that is supposed to be read by the CPU. Let's go back to the beginning again. And what we're going to say is that past the first phase, the memory has to be stable. So, remember that in the first phase we set up the address that we want to read and then we, and then during, so that's phase zero and then during phase one, we actually go ahead and latch the value that we read in. So, that's why after that, we just assume that the data is going to be stable. And let's see. The next thing is taking the actual snapshot. So, here it is. So, if we're at the very beginning of the instruction, so M cycle is zero and also phase count is one because remember with zero we're just going to read the instruction. So, with one and of course as long as there was no illegal instruction, which basically halts the processor, what we do is on phase two, which is the positive edge at the very end of phase one, we load the memory data that formal verification gave us into our collected instruction. So, this is the instruction that we're supposed to be executing. What we do is we take the program counter out of the CPU and store it away. We take the registers out of the register card and store those away. And then we initialize whether we read or wrote memory to zero because we haven't done anything yet. Now, all the time what we do is we're just going to copy the register data out of the X bank and put them in the after registers. So, we're not actually storing them, we're just sort of keeping track of them. And then when the instruction finally completes, those registers should tell us what the end result was. Same thing with PC after. So, we're not storing it, we're just sort of copying it over continuously. Okay, so here's really our first assertion of the day. So, this basically says that at no point ever should an instruction read memory and write memory at the same time, again with the exception of the instruction being read. So, that's did memory and did memory out of the collected data. All right, so we've got another bunch of assertions. So, the first thing is collecting any data that we read outside again of the instruction. So, if we are past the first cycle, right, and remember that all the load instructions and the store instructions are actually three cycles long. So, if we're past the first instruction and the CPU says we are now reading memory and we're on phase one and we haven't executed anything illegal yet, which means again that the processor would be halted, then first of all, we make sure that we haven't yet registered a memory read or a memory write. Because we also don't want an instruction to perform two memory reads or a memory read and a memory write or two memory writes. So, that's what that assertion does. And then we just store away what happened. So, we say yes, we did read whatever the the CPU was outputting on the memory address register. That's what we store in memory address access. And the data that is being read, well, we store it in our collected data. We can use this later on to make sure that the instruction did what it said it was supposed to do. So, for example, in a load instruction, this data that we read should be stored in the destination register, unless the destination register is zero, of course. Okay, the next thing is doing a memory write. So, it's basically the same thing, except we also store away the memory, the write mask. So, we know which bytes were actually written out of the 32-bit address, out of the 32-bit memory location. Okay, this is an assertion not on the collected data, but on the CPU itself. So, while the CPU is executing, we want to make sure that we never try to execute a memory read or a memory write at the same time. Okay, the next thing is, this is just a simple assertion, we know that during the first cycle you cannot do a write. You would only be reading the instruction and memory writes are just for the store instruction, and those are way more than one cycle long. So, that's that. This was just a cover to make sure that we actually did complete an instruction. This is just for debugging in the beginning, just to make sure that the whole mechanism actually works and that we got to a point where we can complete one instruction, any instruction. It doesn't matter. Okay, so these assertions, I set aside on their own, because these are assertions that I didn't have in the beginning, and I added them as a result of running prove mode. So, the idea is that I set up all the asserts that I think should be, and then I run prove mode, and it says, oh yeah, this one state that you thought you would never hit, okay, you probably will never hit it, but nevertheless, I need it marked as a bad state. So, because of those, I added these assertions and we'll go over them in a moment. But the meat of the formal verification that I'm doing is formally verifying each instruction separately. So, this is when I said we take an instruction and we formally verify it by assuming that an instruction completed, and that was the instruction that completed. So, here what I'm doing is I'm just writing down how many cycles I expect an instruction to take, and what the op codes are, and the widths of various loads and stores, and then, okay, so mode, what is mode? Well, this is, if we go to the bottom, this is basically just a flag that I'm passing to the main program. So, when I compile my code into IL, the Register Transfer Language Intermediate Language, I think that's what that stands for, I can say which instruction I'm actually expecting. So, for example, let's suppose I'm expecting op that I know that there is one cycle, that I have to run for one cycle, and that the op code is this value, which is a define. So, if the thing that I'm testing is actually an instruction, then what I'm going to assume is that on the very last phase of the very last cycle, instruction is complete. Otherwise, instruction complete is zero from that, from, for everything else. The other thing that I'm going to assert is that I never run into a case where the number of machine cycles is more than the number of cycles that the instruction is supposed to take. So, this is just a little quick check. For widths, these are for loads and stores, then what I want to make sure is that what I'm going to be doing is I'm going to assume that the width in the instruction is the same as the width that I'm testing. So, for example, if I want to test LB, then I want to make sure that font three in the instruction is set to that width. And for the op codes themselves, the first thing that I'm going to do is that I'm going to assume that at no point does the illegal signal ever go high. So, in other words, I'm only interested in formally verifying legal instructions. So, an illegal instruction would be something like the bottom 16 bits are all zero. That's defined as an illegal instruction. Or all 32 bits are one. That's an illegal instruction for an RV 32. Another example of an illegal instruction could be a misaligned memory load. Like, for example, let's suppose I'm loading a word and it's not 16-bit aligned. Well, that would be an illegal instruction in my implementation. So, what I'm basically saying is the only instructions that you can test are the legal instructions. The next thing that I do is I make sure that the op code in the instruction is the op code that I want to test. So, again, that's another assumption. And finally, this is the actual formal verification machinery. So, if in the past, by one phase, the instruction complete signal went off, then I'm going to verify the instruction. And that's going to depend on the instruction that I'm looking at. There's an extra mode here where I'm actually testing the illegal part, the illegal signal. So, what I'm doing is for illegal instructions, I'm assuming that an instruction never completes. So, I can only execute incomplete instructions. And if the illegal signal goes high, and it always goes high during phase two, then I run some checks on the illegal state that we ended up in. And finally, if we hit an illegal condition, then nothing changes. So, the idea is that if the illegal signal goes high, I can look at the data lines to try to figure out what exactly happened. So, for example, if I'm doing a... So, for example, memory address, I can look at that. I can look at the memory data that we're trying to write and the mask, and whether we're doing a write or a read, that sort of thing. And I want to make sure that when the illegal signal goes high, nothing changes. It's just, you know, constant. Okay. So, let's take a look at verify instruction. Actually, what I want to do is look at that section in the middle. So, this is what happened when I ran in prove mode. So, these are some of the things that prove mode made me assert, essentially. So, for example, one of the things is that if we're past phase zero, then the program counter doesn't change. Because at some point, it said, oh, hey, you know, your program counter changed. So, I want to make sure that it cannot start that induction step when in one of the states, the program counter changes in the middle of an instruction. Because it's allowed to do that. So, what we're doing is we're saying, no, during induction, we're not going to have any states where the program counter changes. And of course, if you do, it would fail. One of the other things is that if we're past the first memory cycle, the instruction never changes. Again, once I did induction, and it started changing the instruction on me. And I said, no, no, no, the instruction doesn't change. I wanted to make sure that the instruction didn't change past phase one of any machine cycle, and the ALU outputs don't change. Here's another assertion where, let's see, if we're on the first memory cycle, and we are on anything but phase zero, then the instruction is the same as what we're reading out of the memory. So, that's another thing. We also want to make sure that we're asserting that the memory cycle, there is never more, there are never more than three machine cycles. And this is one of the assertions where I can say that the Y bank must always be equal to the X bank. Let's see, here's another assertion that says that the machine cycle that I'm keeping track of is the same as the instruction phase that the CPU is keeping track of. Okay, so that's all that. So, let's take a look at some of the instructions that we're formally verifying. So, we can start with maybe op. So, in verify instruction right over here, so based on the op code, we're going to run verify op code op. So, let's go there. Okay. So, obviously, if the mode is not op, this is not an instruction that we're interested in, so we just don't assert anything. And what this does is for the argument, what we're going to do is we are going to get the contents of RS2 before the instruction executed. And then, based on the ALU op code, we're going to do some verification. So, let's look at verify add. So, first of all, we're going to make sure that we've bumped the program counter by four at the end of the instruction. We're going to make sure that all of the registers are the same with the exception of the destination register, which we don't check because we kind of assume that that's going to change. And then, we're going to take a result that we expect. And we're going to say that, remember, this is an add. So, as long as the destination register is not zero, the result is supposed to be whatever RS1 was before the instruction, plus the argument, which is whatever RS2 was before the instruction. The reason I use argument is because there's also the immediate version of this instruction. And I can just reuse the same code. So, that's the result. And then, we just assert that the contents of the destination register after the instruction has executed is the same as the result that we calculated it should be. And that's basically how all of the verifications work, at least for the single cycle instructions. So, we can take a look at, let's see. Okay, so those are all the op. And the op M is basically just the same, except the argument is just the immediate value that we collected. So, here's LUI. Again, it's just the same thing. AUIPC is the same thing. JAL is interesting because now, unlike all the other instructions, we can jump to a different instruction. So, what we do is we determine what we expect the new program counter to be. And this is basically the program counter before the instruction executed, plus the immediate value. And what we're going to do is assert that the program counter after the instruction is indeed what we expected. Again, we verify that the registers are the same, with the exception of the destination register, which could be zero. And what we're going to assert is that we didn't do a memory read or a memory write. I guess I don't really need that, do I? Okay, because that assertion is actually down below. Okay, so as long as the destination register is not zero, what we do is we take the program counter before the instruction, add four, and that's what we expect the contents of the destination register to be. Now, this is where I found a bug in JAL and JALR. I wrote this code and what actually happened was when the destination register was zero, we didn't jump to the correct address. And that's because I was using the destination register as a sort of temporary value to store. So, if you go back and rewatch the last video, you'll see my nice table of what an instruction actually does and what it puts on the buses. And one of the things that it did was I think it put the program counter before plus the immediate value and it stored that in the destination register. And then it took it out of the destination register, put that in the program counter, and then put the PC plus four back into the destination register. And I said that I had to do that because I didn't have enough buses available to do the calculations at the same time. So I broke it up into two cycles. Unfortunately, the temporary that I used could have been register zero, which you can't write to. So that was a problem and that showed up during formal verification. So I fixed that bug. Now, instead of using the destination register as a temporary, I'm just using the memory address that I'm outputting as the temporary. So because I'm going to be jumping to that address anyway and reading the instruction at that address, I said, well, okay, well, why don't we just output that address during, you know, during the first phase. We're allowed to do that. So that's what I did for JAL and JALR. Then there was branch. So for branch, what we're doing is we're just going to get RS1 and RS2. We're going to get the target program counter if the condition is true, the target program counter if the condition is false. And we're basically going to be doing the same thing. So depending on the comparison that we're doing, we're checking to make sure that the program counter is as expected. And that's that's kind of a lot of what I do here. I'm not going to go through everything. You can look at the code yourself. Let's see if there's anything else that is interesting. Well, here's verify illegal. Okay, so basically what we're doing is we're making sure that we can generate illegal instructions. And when we do generate illegal instructions, that it's one of these conditions. So the zero instruction is where the bottom 16 bits of the instruction are all zero. Again, that's defined by the specification as an illegal instruction. Then there is all ones. Now, if this were RV64, then it would be all 64 bits or ones. Since this is RV32, it would be all 32 bits or ones. If we try to do a misaligned load or a misaligned store or the program counter is misaligned, which can happen if you do a jump relative JAL or JALR. Let me, well, okay. One of those instructions. Then the program counter is misaligned and that should raise an illegal flag. So that's basically what I'm doing here is I'm just making sure that if the illegal signal goes high, then one of these conditions is actually true. And that's what this assertion is. And that's really that. So here I can show you, I think, an example of running prove mode on illegal instructions. So again, for prove mode, we can see that there is this base case right over here. And there is induction and they sort of run at the same time. So what it's trying to do is run bounded model checking for let me see how many steps. So for illegal prove mode runs for 18 steps. So this is the SBY file which sort of configures formal verification. And I found out that you can actually put some Python fragments in here. So now instead of having to write multiple SBY files, I can just write one and basically say if there's a particular target that I'm working on, I can set the depths of formal verification differently. So for example, all the one cycle instructions, well, you don't need to go anywhere. You don't need to go past seven cycles for BMC or six cycles for prove because that's one instruction. Same thing with the two cycle instructions and the three cycle instructions. Illegal, I count as a three cycle instruction because you can have a one cycle instruction being illegal or a two cycle instruction being illegal in the case of a misaligned program counter or a three cycle instruction being illegal in the case of loads and stores. So that's what all this stuff is. So yeah, the number I was interested in was 18. So if we look at the base case here, we can see that it starts from step zero right here and it continues all the way down to step 17. So that's 18 steps. And if we look at the induction part of it, so again, this is where we're starting from an illegal state and we want to make sure that we find a chain of legal states of 18 legal states and then make sure that nothing overlaps. So in other words, we never fall into that chain. So we start induction in step 18. So it's sort of working backwards from the invalid state and we go down, down, down until induction is successful. In that case, we found all of the chains of bad. So we found all of the bad chains, essentially, and then we've determined that bounded model checking and those things never encounter each other. So in other words, a successful induction happened. And that's basically that. So yeah, I guess I'm going to end it on this note. So one of the things that I wanted to talk about, let's just bring up the code again, in the sequencer card. So everything is great. The CPU works. It's just that it's not very useful because I don't have interrupts. So I looked a little closer at the risk five specification for interrupts and it starts talking about traps and CSRs, which are these these other registers, they're a completely separate address space. And basically, there's something in risk five called machine mode. And machine mode is the highest privilege mode. And in machine mode, you are required to have certain CSRs.  The type of exception that happened. And one of the types of exceptions that can happen is a misaligned memory address. So I'm actually going to have to implement CSRs. And if we look at the if we look at the sequencer, I put this line in here saying there's an external interrupt. And then and then I was like, how exactly does this work? Because I wasn't really sure how the processor was supposed to handle an external interrupt. And it turns out that the privileged section of the specification tells us exactly how interrupts are supposed to be handled. And it's through CSRs. Now, the other interesting thing is that when an interrupt happens, the interrupt is handled as pretty much all processors handle it. There's a vector table of jump locations. And depending on the type of interrupt that happened, and it could also be a fatal interrupt, well, not a fatal interrupt, but it could also be a trap, which is an exception, which is not an external interrupt. Or it could be a timer goes off, maybe in any case, you look up that table, and then you've got an address to jump to. Typically, what you do is you store away the program counter of the instruction that you're going to execute next, you store that somewhere. And that was one of the things that was like, Well, where do you store that? And it turns out you store it in the CSR. The next thing that you do is you store away all of your registers because the interrupt routine is going to start using registers. So now you have to store your registers somewhere. And usually the way that works is that you push the registers onto the stack. Now, risk five doesn't define a stack. Well, it does define a stack, but only if you're using a certain application binary interface. And then the stack pointer is specifically one of the registers. And I got to thinking, there was a comment on one of the videos. It was a very interesting comment. It was intriguing to me. It said that I've got way more memory in my register card than I have registers. And basically what I've been doing is I've been setting all those extra address bits to zero because I didn't need any of them. Well, to save all the registers, all I really need to do is change one of those address bits. And immediately I've got a fresh set of registers. And then when I want to restore the registers, I just set the address bits back to zero. So when I do an external interrupt or any sort of trap, all I have to do is save the program counter in the CSR and then switch the register page. And then I'm done. And I can do that for multiple tasks. So if I have multiple threads that I want to execute and I want to switch between them, you know, like every 10 milliseconds or whatever, all I have to do is save the program counter, swap the registers, and I'm done. So however much memory I have, however many copies of the registers I can have, I can set aside one for the main program, one for interrupts, and the rest are for, you know, other threads, other tasks. So that's kind of neat. And that's what I'm going to have to do on the next video. I'm going to have to start implementing the CSRs. Now CSRs are special beasts. They have special powers. They're not just stores of data. They actually affect the execution of the machine. So for example, one of the CSRs is a counter that counts up the number of instructions that you've executed. So obviously in order to implement that in hardware, well, I would have to have a counter.  And every time it sees that it has to increment the counter. Of course, it's a 64-bit counter. So now I need a 64-bit counter on a card and then some, you know, decoding circuitry that says, oh, this is, this is the specific CSR that you want to access. Well, now I'm going to dump my data. Maybe it's the high 32 bits. Maybe it's the low 32 bits on one of the buses, probably the Z bus, because then you can store that in a destination register. So I'm going to have to go through all of the CSRs that I need. Some of the CSRs I think are optional. And then I'm just going to have to go through that list and, you know, write the code for those CSRs. And a lot of those are going to be, are going to end up as single cards, which is kind of depressing because there are kind of a lot of CSRs, which is why I want to just, you know, get down to the bare minimum. I mean, do I really need an instruction counter? Do I really need a machine cycle counter? I don't really think so. So, you know, maybe I can, I can, you know, set aside space on the bus so that I could have a CSR card for that if I wanted to, but it's not absolutely needed. What is absolutely needed are the CSRs that handle interrupts and traps. So that's going to be the subject of the next video. So I hope to see you then. Hit the like button, or don't hit the like button, and hit the subscribe button if you want to see more videos. So thanks for watching. Bye.


This is a great video. Thank you. I hope you enjoyed it. I'll see you in the next video. Bye. Bye. Bye. Bye.


Why is the narcissist no longer interested in you? When the narcissist first met you They showed curiosity and concern for you. They had a strong desire to learn more about you They were interested in you. They were attentive and focused They attended to your comfort and wishes It seemed like they really cared about you They idealize you in the beginning. In that moment, you are perfect You are everything they have been looking for They put you on a pedestal They think of you as a perfect person with no faults They believe that you are better than everyone And that is why they are so eager to get involved with you That is why they may even talk about getting married or having children with you early on in the relationship Because in that moment, you are perfect to the narcissist They assume that they're never going to find anyone better than you Which is why they're willing to put all their cars on the table They're willing to do anything to secure you because in their minds This is it You are everything that they could want They're not going to find anyone better than you But they're not so eager to learn about your faults or mistakes in the beginning They don't want to learn about your flaws or imperfections They want to continue seeing you as this perfect person They want the fantasy So even if you do try to be vulnerable with the narcissist They're not going to show much interest in anything you have to say They will continue seeing you as this perfect person Who is everything that they could want and they will do whatever it takes to secure you They will throw everything on the back burner just to be with you Because in that moment you are perfect to the narcissist It doesn't get any better because they have this idealized image of you in their minds The more familiar the narcissist becomes with you The more they begin to lose interest in you they don't see you the same way as they did before They get used to you They get comfortable And you just don't do it for them like you used to But this has nothing to do with you It's not that you've changed It's just that the supply has lost its potency Every supply has an expiry date It no longer gives them the same effect as it once did It's like when you see a luxury car in a magazine or on a TV commercial You fantasize about it. I did that moment. It looks perfect But when you buy the car and you become familiar with it It's not the same as when you first had it The buzz wears off and then that car might even become an inconvenience to you when you have to maintain it Because it's no longer as fun and exciting as it was in the beginning and this is exactly How narcissists experience people when they first meet you You're new You're unfamiliar They're still trying to figure you out But the more time they spend with you The more they begin to lose interest in you They begin to think that you're not all that It becomes boring and tiresome as a result of repetition and over familiarity They become contemptuous towards you They begin to see you as though you're worthless or beneath their consideration Because they're used to you now When the narcissists first met you They idealized you in their minds you were perfect They overlooked your flaws in the perfections But as time went by They became more and more sensitive to any mistakes that you made Until it was like you couldn't do anything right Everything you did was wrong Even though you may not have changed at all They just see you differently now Because now they're more familiar with you The newness has worn off So even though you may have been vulnerable with them in the beginning And opened up to them about things you thought were significant or important for them to know And at the time there was no issue with what you could find in them Now they're blowing it up out of proportion Now it's become a big deal because the more time they spend around you The more they lose interest in you The more sensitive they become to your flaws or imperfections They can only idealize you As long as you reflect back to them everything they need you to be As long as you do what they want you to do Which is an unrealistic expectation of them to have of you They expect you to live for them They expect you to sustain their false reality And when you inevitably fail to do that It all falls apart That is when they begin to devalue you That is when you go from being this perfect person To being completely flawed But rather than realising that this is a flaw in their own perception They begin to see it as though you tricked them As though you presented yourself as this perfect person As though they were deceived by you When the reality is that from the moment they met you They idealized you They overlooked anything that they didn't like about you Because they wanted to project this idealized image onto you They wanted to live in a fantasy And when you struggle to sustain this fantasy for them That is when they blame you That is when they start to see it as though something is wrong with you When you get involved with a narcissist It's only a matter of time until they lose interest in you They look at it like If you are so great Why would you want to be around them Why would you be interested in them Because underneath the arrogance and grandiosity They're actually very insecure They lack confidence in themselves They don't think they're as great as they lead people to believe So whenever you're around them They assume there must be something wrong with you They think you must be crazy But at the same time They will also be very controlling over you They will want to spend every second of the day with you While they are devaluing you While they're trying to make you feel like you're nothing They're like addicts It's like they're looking at a line of cocaine Knowing that it's not going to do them any good But because they're addicted They can't help themselves They think that by increasing the dosage It's going to make them feel better But it just makes things worse They just need to take a step back They need to focus on something else But they can't help themselves Because they're addicted to you And when they look at you with contempt It makes them feel better about themselves There's really no greater high to a narcissist Than reducing a happy successful person To a miserable wreck It makes them feel like they're better than you It makes them feel something Which is all a narcissist really wants So even though the supply may have lost its potency They still get a kicker of beating you down And putting you beneath them When really They're just trying to distract themselves From the thought of why they can't appreciate you Especially if they see that other people value you It makes them feel like something is wrong with them Which is why they always have to put you down They have to make you feel like something is wrong with you Or something is wrong with anyone who values you They will tell you that those people Don't know what you're really like Because in the narcissist's mind You tricked them You weren't who you said you were When the reality is That they idealized you And the more time they spend around you The more they begin to lose interest in you The more sensitive they become to your flaws and imperfections They have to see it as though something is wrong with you Or anyone who values you They have to see it as though it's because they don't really know you Because otherwise that would mean there's something wrong with them When the narcissist loses interest in you They assume that it's because of something you did There are small windows Where they do recognize that they have a faulty perception of you Where they do realize that they just can't get the same fulfillment From you as other people do But they always fight against it They always find a way to justify the negative perception of you And that is why nothing ever changes That is why they're not going to appreciate you Unless they spend some time away from you And even then They're just going to re-idealize you again The cycle always repeats itself They cannot see you as a real separate human being Because they're not real And only a real person can recognize another real person Which is why they may see you But they don't really see you They just see a reflection of themselves Everything they hate about themselves is what they project onto you And yet they think they know you so well They think they're so familiar with you When the reality is That you don't even exist in their world The narcissist lives in a world with a population of one Where there is nothing more Than reflections of everything they either idealize or hate about themselves Thank you for watching I hope this video resonates with you Please like, comment, share and subscribe If you would like to donate My PayPal link is in the video description Coaching Inquiries You can email me at coaching.narchsurvivor.co.uk Thank you for watching and I'll talk to you soon


Chapter No. 39 of the Border Bandits This is a LibriVox recording. All LibriVox recordings are in the public domain. For more information or to volunteer, please visit LibriVox.org. Recording by Shashank Jagmola. The Border Bandits by J. W. Buell. Passams Confession of the Glendale Robbery The robbery of the Chicago and Alton train at Glendale, Missouri, as already described, has been surrounded with considerable mystery concerning the identity of all those engaged in the outrage. The large rewards offered for the apprehension of the robber band amounting to $75,000 caused a very active search which resulted, at last, in the capture of Daniel, better known as Tucker, Bassam, under circumstances already related on page 99. The writer visited Bassam at the county jail in Kansas City in October 1880 for the purpose of interviewing him with the hope of obtaining some interesting facts concerning the robbery but though he had made a written confession he refused to talk on the subject saying that he had already told too much for his own good. On the 6th day of November, Bassam was brought into court for trial having entered a plea of not guilty despite his confession but this plea was changed to that of guilty and he then threw himself upon the mercy of the court. The following summary of his confession appeared in the Kansas City Journal of November 7th. On Monday night preceding the robbery, said Bassam in his confession, two neighbors of mine came to me and said they had put up a job to rob a train and wanted me to go in with them. I told them I didn't want nothing to do with robber no train and wouldn't have nothing to do with it know how but they kept on persuading and finally went away saying they would come back in the morning and that I must go with them. They said a very rich train was coming down on the CNA and that we could make a big haul, perhaps $100,000. Well, that kind of half persuaded me but still I didn't like to go. They finally told me that Jesse James was arranging the thing and that it was sure to be a success. Well, then they left. My wife kept pestering me to know what was going on and what they wanted but I didn't like to let on. I kept thinking about it all night. Of course I'd heard often of Jesse James and kinder had confidence in him. Then I was pretty poor. There wasn't much crops on my place, a winter coming on and I tell you it looked pretty nice to get a little money just then no matter where it come from. Besides, I thought to myself if I don't go it'll be done just the same anyhow. They'll be down on me and tend to one I'll be more likely to get arrested if I ain't there as if I am. Well, I kept kinder thinking it over and in the morning they came to the house early and ate breakfast and then went out and left around in the timber and in the cornfield all day so nobody wouldn't see them.  We soon met another man on the road and when we got to Sieber's school house about a mile and a half away from my house they give a kind of a whistle for a signal and two men came out of timber and rode up. I was introduced to one of them as Jesse James. This was first time I'd ever seen Jesse James in my life. And who was the other demanded the prosecutor. The other was Ed Miller of Clay County. Bassem said that Jesse James then gave him a shotgun and furnished each man with a mask and that they all then rode on in silence toward Glendale. No instructions were given to any one man. When they arrived at Glendale they noticed the light in the store and Bassem was ordered by Jesse James to go in, capture the inmates and bring them over to the station. On looking in the windows he found the usual crowd of loiterers had left the store and launched over to the depot to wait for the train to come in. He then went on over to the depot and found the crowd in the waiting room guarded by one of the men. Jesse James then told him to walk up and down the platform as the train approached and fired off his shotgun in the air as fast as he could. The telegraph operator was forced at the point of the pistol to lower the green light and thus signal the train to stop. Jesse James then asked him if there were any loose ties there that they could lay across the track and he said he didn't know of any. The men then went and got logs and laid them across the track to obstruct the train if it should take the alarm and not stop for the green light. Meanwhile the train approached. Bassem walked up and down the platform firing off his gun. Jesse James and one of the men jumped into the express car and Miller jumped on the engine in the manner already described and with which all are familiar. The train was not stopped for more than five or six minutes. As soon as it was over Jesse James fired off his pistol which was the signal for all to leave and they jumped on their horses and rode rapidly for about half a mile till they came to a deserted log cabin. Here they alighted and entered. Somebody produced a small pocket lantern and somebody else struck a match. Jesse James threw the booty down on a root table in the middle of the compartment, divided it out and shoved each man a pile as they stood around the table. Bassem's share was between $800 and $900. Jesse then said, now each one of you fellows go home and stay there.  This country will be full of men in the morning hunting for me and you. It will be observed that in the confession as reported only the names of Jesse James and Ed Miller appear when it is now positively known that the gang comprised not less than six persons. The confession implicated two of the most respectable farmers in Jackson County, Kit Rose and Dick Talley. One a brother-in-law and the other a cousin of the younger brothers both of whom were arrested but soon afterwards released as not a scintilla of evidence could be discovered corroborating Bassem's disjointed statements. The other party, who Bassem swears was connected with the robbery and in this he certainly guessed rightly was Jim Cummings who shot George Shepherd in the affair at Short Creek. In November last, 1880, Bassem was brought into court with the plea of not guilty, notwithstanding his confession but he had so completely convicted himself that the plea was withdrawn and he threw himself upon the mercy of the court. He was then sentenced to the pen-intentionary for a period of ten years. Since his confinement at Jefferson City there has been a considerable change of opinion and respecting his guilt and there is no doubt but that now a large majority of persons believe Bassem's innocent of any complicity with the trained robbery and that his so-called confession was the result of influences which the writer does not wish to assume the responsibility of naming. LibriVox recordings are in the public domain. For more information or to volunteer, please visit LibriVox.org Recording by Adrian Stevens. The James Boys Heard From Again The Border Bandits by J. W. Buell The Train Robbery at Winston, Missouri July 15th, 1881 $50,000 reward offered for the arrest of the guilty parties.  Many of the old band, it is true, have been pulsed by death, dying, belted, and armed by a fate anticipated. But like the excision of a cancer, the germs have remained from which new growth has constantly developed to harass the state and disorder society. The James Boys, aside from their reckless courage, are possessed of extraordinary capabilities, cunning resource, domineering resolution, craft, and dash. As if by a thorough consideration of the beneficial result to be secured thereby, they first terrorized the people of western Missouri and then heroised themselves in the eyes of those whose political sympathies were in consonance with their own. Thus upon the one side the people were afraid to attempt any punishment of the outlaws or give information of their rendezvous, while upon the other they were protected and encouraged without concealment. It is for these reasons that the James Boys and their confrairs have eluded every pursuit and have been able to give free license to their empire's passions. There were peculiar features, however, connected with every outrage perpetuated by the James Gang, which readily manifest them in the deed. Among these several distinguishing features are their appearance in the vicinity where the robbery occurs two days before its accomplishment, the thorough maturity of their plans, the wearing of long linen dusters, unhesitating disposition to commit murder, a splendid mount, the invariable sack carried in which to deposit the plunder, the line of retreat always southward when the robbery has been committed north of Clay County and vice versa, masks of red handkerchiefs, and the ease with which pursuit is eluded. In addition to these unmistakable peculiarities, another fact is particularly noticeable. Viz, within twenty-four hours after the James Boys commit a robbery, Mrs. Samuels, their mother, never fails to make her appearance in Kansas City. The purpose of these visits being undoubtedly to discover what means are employed looking to the apprehension of the gang, and gather up any and all such information as might prove serviceable in aiding the escape of her sons. Considering well all these points of evidence, any shrewd analyser of human nature can readily determine whether or not either of the James Boys was connected with any robbery reported. On the night of July 15th, 1881, an outward going passenger train from Kansas City over the Chicago, Rock Island and Pacific Railroad was robbed at Winston Station, Davis County, Missouri, under the following circumstances. The train left Kansas City at six-thirty p.m. in charge of William Westfall, the conductor, Wilkut, the engineer, and Charlie Murray, express messenger. The train consisted of six coaches and a sleeper, all of which were well filled with passengers. Reaching Cameron, a stop was made for supper, and when the train started off, two men were observed to jump on, each of whom wore a large red bandana handkerchief around his neck, partly concealing his features. Nothing indicative of the robber's intentions, however, transpired until the train reached Winston at nine-thirty p.m. at which station four men took passage, each having his face covered with a handkerchief, identical with those worn by the two that got on at Cameron, and all wearing long linen dusters. Getting under headway again, the train had proceeded nearly one mile from Winston, when suddenly, as conductor Westfall appeared in the second car to collect tickets, the passengers were startled by the largest of the robbers rising from his seat and shouting out in a loud voice, All aboard! which was the signal fraction. The large man heavily masked with the red handkerchief, as were all the others, seven in number, thrust out a large pistol, and saying to Westfall, You are the man I want, fired. The ball struck Westfall in the arm, producing only a flesh wound, but as the wounded man turned to run out of the car, two more shots were fired by the same robber, without effect. This bad shooting seemed to exasperate another of the outlaws, who gave an exhibition of his skill by shooting Westfall in the brain, killing him instantly, the body falling off the platform onto the ground. While this unprovoked murder was being perpetuated, three others of the outlaw gang rushed through the cars toward the engine. Wild confusion followed, and a stonemason named J. McCulloch from Iowa, who had been working near Winston, attempted to get out of the baggage car as the robbers entered it, suspecting that he was either the engineer or intent upon raising an alarm, one of the outlaws shot him dead and pushed his body off the train, which had now come to a stop. The robbers then went about their business of robbing, two mounting the engine, three were left to guard the passengers, while the remaining two made for the express car. Mr. Murray, the express agent, hearing firing and suspecting the real cause, made a hasty attempt to close and lock the doors of his car, which had been left open due to the oppressively warm weather.  Looking into the muzzles of two large pistols, Murray was forced to comply and delivered up the safe keys. The treasure box was quickly opened, and its contents extracted, consisting of coin and currency to the amount of $8,000 or $10,000, which was thrown into a sack the outlaws carried for the purpose. The train then started up by one of the robbers, but after proceeding a few hundred yards, stopped again, and the bold freebooters jumped off, running for their horses, which were tied in a clump of trees, less than one hundred yards from the track. They did not take the time to untie their horses, but cut the reins, and mounting, rode in a half-circuit around Cameron, then took a course almost due south. They crossed the Missouri River near Sibley's Landing in couples, having divided up immediately after the robbery was consummated. On the morning following the robbery, an examination of the immediate vicinity about where the train was stopped resulted in finding where the robbers had tied their horses, and there, lying on the ground, was found the following letter. Kansas City, July 12th Charlie, I got your letter today, and was glad to hear that you had got everything ready in time for the 15th. We will be on hand at the time. Bill will be with us. We will be on the train, don't fear. We will be in the smoker at Winston. Have the horses and boys in good fix for fast work. We will make this point again on the night of the 16th. All is right here. Frank will meet us at Cameron. Look sharp, and be well fixed. Have the horses well gaunted, for we may have some running to do. Don't get excited, but keep cool till right time. Wilcox or Walcott will be on the engine. I think best to send this to Kidder. Yours, time and through death, slick. After receiving the first particulars of the robbery by Telegraph, I went to Kansas City, and from thence to various points in the vicinity, for the purpose of prosecuting an investigation, with the view of discovering, if possible, who the outlaws were, where they came from, wither they went, and how the authorities prosecuted the pursuit. From these efforts I am prepared to state, with circumstantial positiveness, that Frank James and Jim Cummings were the parties who planned, and with the aid of their confrars, executed the robbery at Winston, and that the proof may not be wanting, the following several facts are recited. A few weeks ago I received a letter from Frank James, acknowledging the receipt of a copy of Border Outlaws, which I sent to him by a relative. Shortly after its receipt, this same relative, who is known to be in communication with Frank James, visited St. Louis and confidentially conferred with my publisher, upon the advantages which we might mutually reap, by sudden stimulation in the sale of Border Outlaws, for which he was then acting as agent. His proposition embraced a statement that Frank James and Jim Cummings were at that time in Missouri planning a campaign, that a large robbery would soon be consummated, attending with some startling results. All these facts he agreed to furnish us, the very moment the robbery should be completed, comprising the names of those engaged, how they had organised, where assembled, cause for their acts, etc. Provided my publisher would give him a certain sum of money. The incentive on our part to comply with his proposition was in securing this reliable information, which might be added as an appendix to a new edition of Border Outlaws, and issued contemporaneously with the first newspaper reports, therefore creating a largely increased demand for the book. Of course there appeared so much doubt involved in this singular proffer, and the proposition within itself being of such questionable character that it was rejected with little consideration of the probability of a robbery such as was declared about to take place. At this time, however, the assertions then made assume an interest which throws much light upon the problem, who committed the robbery. But this is not all the evidence I am in possession of, respecting this latest adventure of the old gang. In pursuing my investigations, I visited Olath, Kansas, twenty miles south of Kansas City, and there found a gentleman well known in that town who had met Frank James walking on the south side of Olath's public square, well armed, on the tenth instant, or only five days before the robbery occurred. It was not a mistaken identity, for the gentleman in question was raised within four miles of the present residence of the James Boy's parents, and was for years upon terms the greatest social intimacy with them, attending the same school, participating in the same sports, and in later years meeting with them as old acquaintances. Being well acquainted with myself in Olath, I can positively state that this information regarding the presence of Frank James in the town referred to is true beyond all doubt. But what his business was, or when he left, I could not ascertain. Within eighteen hours after the robbery, Mrs. Samuels appeared in Kansas City, evidently for the purpose of collecting such information as might be useful to Frank James and his confederates. She talked freely of the robbery, but protested with repeated declarations that both Frank and Jesse were dead, going so far in her assertions as to say that Frank died three years ago of consumption in Texas. What she hoped to gain by a claim so easily disproved it is difficult to conjecture. From the best evidence attainable, the gang who robbed the Rock Island and Pacific Trame, among whom were Frank James, Ed Miller, Jim Cummings, and Dick Little, after leaving the train, mounted their horses and rode south-westwardly until they reached the outskirts of Cameron, when they turned and took to the brush again, making directly for the Missouri River, which they crossed near Sibley's Landing, and on the following evening, the sixteenth, they certainly passed through Sneeter Bar Township of Jackson County, taking a south-westwardly course, continued on to the Indian Territory. The party, however, did not remain intact, but divided into couples, so as to destroy the trail, which so large a number of sudden riders would have made conspicuous. They were at no time so far apart, though, but that a pre-arranged signal would have concentrated the outlaws. It is a singular fact that with all the atrocious crimes credited to the James boys and their Confederates, there was not so much as one dollar of reward offered at the time of the Winston robbery, although at one time the rewards offered by the State and Railroad and express companies aggregated seventy-five thousand dollars. During Governor Hardin's administration, nearly all the rewards offered by the State were withdrawn. Then the private corporations that had suffered so seriously at the hands of the bold knights of the road withdrew the incentives they had advertised, after which Governor Phelps wiped out the few figures remaining. On the 26th of July, eleven days after the train robbery at Winston, Governor Crittenden visited St. Louis and called a meeting of the leading railroad officials in the Gentleman's Parlor of the Southern Hotel. The call was responded to by representatives from nearly all the principal roads running into Kansas City and St. Louis, and upon assembling plans were thoroughly discussed for the apprehension of the notorious outlaws who have wrought such injury to Missouri's reputation. The session lasted for nearly four hours, though there was the greatest unanimity of feeling and disposition, and at its conclusion the Governor expressed much gratification at the results. The power of the executive is limited by law so that he could not offer a State reward sufficiently large to accomplish the arrest of such notorious desperados as the James boys and their gang were known to be, so he conceived the excellent idea of calling upon the interested railroad corporations for needful assistance. The result of this conference was the immediate issuance of a proclamation by Governor Crittenden in which an aggregate reward of $55,000 was offered for the capture of seven train robbers or $5,000 for the arrest and conviction of each one of the robber gang. This proclamation was supplemented by the offer of an additional reward of $5,000 each for the arrest of Jesse and Frank James and delivery of their bodies to the sheriff of Davis County and a further reward of $5,000 each for their conviction. The public, which generally speaking believed that Jesse James was never shot by Jeffrey Shepard credit the assertion made by many that both Frank and Jesse were engaged in the Winston robbery, but whatever the impression this belief is undoubtedly without foundation. The most intimate acquaintances of Jesse James those who have seen him many times during the past year are ready to make oath that he is a paralytic from the effects of Jeffrey Shepard shot in fact in a demented, helpless condition. At one time arrangements were about perfected through the outlaws cousin by which I was to have a personal interview with Frank James each of us to be accompanied by a friend but owing to some engagement which was never explained to me that meeting never occurred. Frank after receiving a copy of border outlaws expressed a desire to make a statement with the understanding that I would embody it in all subsequent editions of the book. This I agreed to do but I am now convinced that the intended interview was not granted because of the engagement which was kept at Winston.