[00:00:49] Speaker 02:
Our final case this morning is number 141351, Oracle America 8 versus Google 8.

[00:00:59] Speaker 04:
Mr. Herrick.

[00:00:59] Speaker 04:
Good morning.

[00:01:00] Speaker 04:
May I please the court?

[00:01:01] Speaker 04:
My name is Mark Herron and I represent the appellant Oracle America.

[00:01:05] Speaker 04:
The PTO's rejection of the 205 patent claims as anticipated by the Magnuson article should be reversed.

[00:01:11] Speaker 04:
The rejection of all claims except 1 and 8 is based on a reading of the claim term overriding that is unduly broad.

[00:01:18] Speaker 01:
Do you concede that we have to disagree with the claim construction for there not to be anticipation?

[00:01:25] Speaker 04:
We have not argued that as to the claims that have the overriding limitation in it, that under the board claim construction, the overriding element is not met.

[00:01:39] Speaker 04:
There is a separate argument that we have about enablement, about whether the Magnuson article is enabling, and that is a separate reason why

[00:01:48] Speaker 04:
The magazine article doesn't anticipate any of the claims, including Plains 1 and 8.

[00:01:53] Speaker 02:
Okay.

[00:01:54] Speaker 02:
If I understand, I found the briefs difficult to follow.

[00:01:58] Speaker 02:
If I understand correctly, what you're saying is that a proper claim construction would exclude circumvention as included within an overwrite.

[00:02:11] Speaker 02:
Is that a fair statement?

[00:02:13] Speaker 02:
I'm not sure exactly what you mean by circumvention.

[00:02:16] Speaker 02:
Well, what's shown in the application with respect to three to five, that you're skipping those.

[00:02:25] Speaker 02:
So that wouldn't be covered by overriding.

[00:02:31] Speaker 04:
That's exactly correct.

[00:02:32] Speaker 04:
So the patent teaches that in figure, and this is displayed in figure five of the patent, that bytecode two is the only bytecode that gets overwritten.

[00:02:45] Speaker 04:
byte code 2 gets overwritten with an instruction that calls the native machine instructions.

[00:02:52] Speaker 02:
So you have to have that happen rather than the circumvention that occurs with respect to 3, 4, and 5?

[00:02:58] Speaker 02:
That's exactly correct.

[00:02:59] Speaker 02:
Okay, but looking at Magnuson, I'm not sure that Magnuson is showing circumvention because they're in figure 4, there are no arrows

[00:03:14] Speaker 02:
going back.

[00:03:16] Speaker 02:
So help me with that.

[00:03:22] Speaker 04:
Well, I would agree with that.

[00:03:24] Speaker 04:
Actually, Magnuson doesn't show overriding much less circumvention.

[00:03:29] Speaker 04:
So the invention of the 205 patent, and I'll contrast that with Magnuson, the 205 patent has at runtime, it has a list of virtual machine instructions, and then the interpreter decides that for a block of code,

[00:03:44] Speaker 04:
we're going to, it's going to be more efficient to run the native machine code rather than the virtual, rather than interpret the virtual machine code line by line.

[00:03:53] Speaker 04:
So they're going to take an instruction and replace the first instruction out of that block of code, the first virtual machine instruction, and that's going to point to the native machine code, and then it's going to come back to the end.

[00:04:05] Speaker 05:
Is it doing that replacement at runtime?

[00:04:07] Speaker 04:
It's doing it at run, the patent, the claim one, so claim two depends on claim one, and claim one says it's at runtime.

[00:04:13] Speaker 04:
new instruction gets generated and gets placed into, well, the claim one says instead of, but claim two says it's overwritten.

[00:04:21] Speaker 01:
Is your argument really that the board's construction reads out the virtual machine instruction portion of the claim?

[00:04:31] Speaker 04:
I don't think that's our argument.

[00:04:33] Speaker 04:
I think our argument is simply that it doesn't require that the claim

[00:04:39] Speaker 04:
that the new virtual machine instruction actually be written over the original virtual machine instruction.

[00:04:46] Speaker 04:
The board's construction simply says that the instruction is run instead or it replaces or it's run instead of the original instruction.

[00:04:55] Speaker 04:
But that's what's claimed in claim one.

[00:04:58] Speaker 04:
And we have not appealed any of the other elements in claim one because claim one doesn't have the override limitation.

[00:05:04] Speaker 02:
Okay, but I'm still, I think I need to understand figure four and Magnus in order to understand.

[00:05:11] Speaker 02:
I understand your argument that overriding doesn't include circumvention and that seems to be a pretty good argument.

[00:05:19] Speaker 02:
But you also say that figure four isn't showing circumvention.

[00:05:23] Speaker 02:
So what is figure four showing with respect?

[00:05:27] Speaker 02:
Is it, for example, in the translated box at the top, is that the same

[00:05:33] Speaker 02:
is the translated block at the bottom?

[00:05:37] Speaker 04:
So Magnuson is very difficult to follow.

[00:05:40] Speaker 04:
It's pretty incomprehensible.

[00:05:44] Speaker 04:
But the best that I can understand it is that the interpreted program part on the left of Figure 4 would correlate with the virtual machine instructions in Figure 5 of the patent.

[00:05:57] Speaker 04:
On the right, the translated would be the block of, so that the small caps translated on the right is a block of native machine code, not virtual machine code.

[00:06:08] Speaker 04:
And all figure four shows.

[00:06:12] Speaker 04:
How does that relate to the box at the bottom?

[00:06:15] Speaker 04:
Right, and the box at the bottom is this new block of, well, not necessarily new, it's a block of compiled native machine instructions.

[00:06:26] Speaker 04:
I may have spoken earlier that it's not clear that the translated on top is native machine instructions.

[00:06:31] Speaker 04:
The translated block on the bottom is a block of native machine instructions from best we can tell.

[00:06:37] Speaker 04:
So this shows that there's a pointer from the interpreted program down to this translated block.

[00:06:45] Speaker 04:
But A, it doesn't say that nothing in Magnuson discloses that this occurs at runtime and that we're going to circumvent

[00:06:53] Speaker 04:
a block of code as you pointed out, Judge Schaik.

[00:06:57] Speaker 02:
Nor does, I mean, all of it.

[00:06:58] Speaker 02:
So the problem I'm having is, and I appreciate your statement in that respect, but if we send it back and say, well, you made a mistake, the overriding doesn't include circumvention, that doesn't really help the board all that much because

[00:07:16] Speaker 02:
And they've still got to figure out whether or what's shown in Magnuson is covered by the claim.

[00:07:22] Speaker 02:
And since we seem to agree that Magnuson doesn't show circumvention, what are they supposed to do?

[00:07:27] Speaker 04:
Well, I think the board thought that Magnuson does show circumvention.

[00:07:32] Speaker 04:
And I think that the only way that the board was able to affirm the examiner's rejection was by coming up with this new claim construction that simply has no basis in the patent itself.

[00:07:46] Speaker 04:
And apart from that, if the board were going to affirm on the grounds that the examiner found, it could have done so without coming up with this new instruction.

[00:07:56] Speaker 04:
So I think it would be helpful because, like I said, I think the board did think that there was this circumvention going on and that that's how they found under this broader construction.

[00:08:13] Speaker 04:
Well, that's our argument.

[00:08:14] Speaker 04:
We don't believe that that's what Magnuson shows.

[00:08:17] Speaker 02:
In Magnuson, what are SUB-U and BCND?

[00:08:23] Speaker 02:
Are those blocks of code that are transferred over from the interpretive program?

[00:08:31] Speaker 04:
That's a good question.

[00:08:33] Speaker 04:
Magnuson doesn't have anything explaining what that is.

[00:08:36] Speaker 04:
But my understanding is that everything on the right-hand side in the simulation code to the upper right, that that is code

[00:08:42] Speaker 04:
that has then been interpreted at runtime from the virtual machine instructions into the native machine code, but not compiled as a block, which is what's down in the translated block of the quantum practice.

[00:08:59] Speaker 01:
What's the level of skill in the art for this?

[00:09:02] Speaker 04:
These include us.

[00:09:07] Speaker 04:
I believe that the examiner

[00:09:10] Speaker 04:
define the level of skill in the art as someone with a computer science degree and at least one year of programming experience.

[00:09:19] Speaker 01:
So what is it that you think Magnuson needs to be enabling?

[00:09:22] Speaker 01:
Do you think it needs code?

[00:09:25] Speaker 04:
On the enablement argument, we don't think it needs code, but what we do think it needs, so the entire anticipation is based on this one sentence that says that

[00:09:39] Speaker 04:
Either the internal format includes a direct pointer to the compiled block.

[00:09:43] Speaker 04:
This is at A918 toward the bottom.

[00:09:47] Speaker 04:
So there are two ways of combining the Threaded Code model with block translation.

[00:09:51] Speaker 04:
Either the internal format includes a direct pointer to the compiled block where we introduce a new instruction translated.

[00:09:57] Speaker 04:
There's nothing in Magnuson that talks about how you generate this instruction translated.

[00:10:02] Speaker 04:
When it occurs, there's just no disclosure.

[00:10:08] Speaker 04:
We're not saying, Google argues that we're saying that you need code.

[00:10:11] Speaker 04:
We're not saying that, but you need some disclosure.

[00:10:14] Speaker 01:
Well, how would you introduce a new instruction without overwriting the existing code?

[00:10:19] Speaker 04:
Well, one example could be that you could insert it.

[00:10:21] Speaker 04:
So you could have the lines of code.

[00:10:23] Speaker 04:
As I mentioned before, the point of the invention is to take a block of code and run the native machine code as opposed to the virtual machine instructions.

[00:10:35] Speaker 04:
So rather than overwriting the first line of code,

[00:10:38] Speaker 04:
you can insert the new line of code in front of it, and so that first line of code would still exist, everything would sort of move down, and then you could go over to the native machine instructions, run those, and then come back to the virtual machine instructions after that block is completed.

[00:10:55] Speaker 05:
That's not what Magnus shows, right?

[00:10:58] Speaker 04:
That's right.

[00:10:59] Speaker 05:
If the last bit of the machine code says,

[00:11:09] Speaker 04:
I'm sorry, the virtual or the native machine code?

[00:11:13] Speaker 05:
Well, so in figure five, you have go native, right?

[00:11:18] Speaker 05:
Go native and it goes over and it runs some snippet of machine code.

[00:11:25] Speaker 05:
And then it says, don't go back to bytecode three, go back to bytecode six.

[00:11:30] Speaker 05:
So if the point, I guess I'm a little concerned about your

[00:11:35] Speaker 05:
the, your, your statement of the point of this great solution as perhaps not in fact, depending in any meaningful way on overwriting in the specific sense of deleting a line and replacing it with another, as opposed to what it seems plain to me, the board thought it included, which is skipping the execution.

[00:11:57] Speaker 05:
of steps, which I think is what we've been talking about here in the language of circumvention.

[00:12:01] Speaker 04:
Well, again, that's claim one.

[00:12:03] Speaker 04:
Claim one has the claim language.

[00:12:05] Speaker 05:
You said that the point of the invention here is to go and do a bunch of stuff in machine code that you would otherwise be doing by instruction, by instruction translating from the bytecode in the virtual machine context into machine code, running that machine, executing the machine code, coming back and doing the next thing.

[00:12:27] Speaker 05:
So why would there be, in terms of the purpose of this invention, anything that turns on replacing, that is, deleting a line of code as compared to skipping its execution?

[00:12:44] Speaker 04:
Because everything that we've just described about going and executing and coming back, that's all in claim one.

[00:12:51] Speaker 04:
Claim one requires that executing a new line of code

[00:12:56] Speaker 04:
instead of the line of code that was before.

[00:12:58] Speaker 04:
It's broader than CLAIM2.

[00:12:59] Speaker 04:
CLAIM2 has a specific type of executing code instead of other code, and that's by overwriting the code on top of the original line of code.

[00:13:07] Speaker 04:
And there may be some advantages to that, for example.

[00:13:11] Speaker 04:
It's very elegant.

[00:13:12] Speaker 04:
That's what I want to hear.

[00:13:14] Speaker 04:
It's efficient.

[00:13:15] Speaker 04:
You don't need to insert.

[00:13:18] Speaker 04:
You don't need to deal with pointers and memory.

[00:13:20] Speaker 04:
You can take the Java class file in which all the virtual machine instructions are,

[00:13:25] Speaker 04:
and you can simply overwrite the line of focus.

[00:13:27] Speaker 04:
It's a very elegant solution.

[00:13:29] Speaker 01:
What is the reference to native SPARC code that's on A486 in Magnuson?

[00:13:40] Speaker 04:
The SPARC code is the native machine code.

[00:13:44] Speaker 04:
So the example that Magnuson is giving you is going from the program has written code in M88100 code.

[00:13:54] Speaker 04:
but is trying to run it on a machine that is a Spark, you know, that operates in Spark code.

[00:14:01] Speaker 04:
So that's the native machine code in the example of Magnuson.

[00:14:04] Speaker 01:
Right, so they would, but Magnuson says, assume that we wish to translate a sequence M88100 instructions to native Spark code.

[00:14:14] Speaker 01:
Isn't that effectively overriding?

[00:14:18] Speaker 04:
I'm sorry, where are you?

[00:14:20] Speaker 01:
846, just below figure four?

[00:14:25] Speaker 04:
Assume that we wish to translate M88100 instructions to native Spark code.

[00:14:30] Speaker 04:
I mean, that's what you're just translating.

[00:14:33] Speaker 04:
I'm sorry, are you talking about the next sentence after that?

[00:14:35] Speaker 04:
Yes.

[00:14:37] Speaker 04:
The intermediate code is in a 64-bit format.

[00:14:41] Speaker 04:
So what happens in Magnuson is that the M88100 code gets interpreted into this intermediate code first.

[00:14:50] Speaker 04:
And then the intermediate code has a pointer

[00:14:54] Speaker 04:
then gets translated into the native machine code.

[00:14:58] Speaker 04:
And in figure four, it shows this pointer to a block of code that's already been compiled into the native machine code.

[00:15:05] Speaker 04:
That's all that this is discussing.

[00:15:06] Speaker 04:
It doesn't say anything about that there is a new virtual machine instruction that has overwritten the previous virtual machine instruction.

[00:15:14] Speaker 02:
Let me tell you what my problem is.

[00:15:17] Speaker 02:
We've discussed two things that you say are not

[00:15:21] Speaker 02:
covered by overriding.

[00:15:22] Speaker 02:
You say it doesn't cover circumvention and it doesn't cover insertion.

[00:15:26] Speaker 02:
And that may be correct.

[00:15:28] Speaker 02:
But you also say that Magnusson doesn't show circumvention or insertion.

[00:15:32] Speaker 02:
So what is it that Magnusson shows and why is what Magnusson shows outside of the claim scope of claim two?

[00:15:40] Speaker 04:
Well, the board found that it did.

[00:15:43] Speaker 04:
The board found... Let's forget about the board.

[00:15:45] Speaker 04:
I want to know what... I mean, you're asking me to explain

[00:15:50] Speaker 04:
Google's argument about what it is in the magazine.

[00:15:52] Speaker 04:
I don't think there is anything in the magazine that teaches it, but the board found that there was.

[00:15:56] Speaker 04:
And so if you change the claim construction, it would make a difference in the proceedings before the board.

[00:16:05] Speaker 02:
I'm not sure of that.

[00:16:09] Speaker 05:
Well, in any event... What is your argument about the non-overriding claim?

[00:16:15] Speaker 05:
which claims one and eight, is that what they are?

[00:16:17] Speaker 05:
Yes.

[00:16:17] Speaker 05:
One and eight.

[00:16:17] Speaker 05:
So just focus on those for a minute.

[00:16:19] Speaker 05:
And you say Magnusson does not enable what's going on there.

[00:16:26] Speaker 05:
And that doesn't require overwriting.

[00:16:28] Speaker 05:
That doesn't require replacing a line of code with another one.

[00:16:33] Speaker 05:
So what's the argument for?

[00:16:36] Speaker 04:
Well, the entire

[00:16:38] Speaker 04:
argument for anticipation even as the claims 1 and 8 comes down to this sentence where it says, we introduce a new line of code called translated.

[00:16:48] Speaker 04:
And there's just nothing in the disclosure discussing what that means, how a person with skill in the art would do that.

[00:16:56] Speaker 04:
There's just nothing in the disclosure that would enable a person with skill in the art to accomplish that.

[00:17:01] Speaker 02:
Well, isn't your answer to that question that claim 1, unlike claim 2, would incorporate circumvention and insertion?

[00:17:10] Speaker 04:
It would.

[00:17:10] Speaker 02:
All very interesting, but it doesn't tell us what Magnuson is and why it's outside the claim construction, even with your limits on the claim construction, so the overriding doesn't include circumvention and insertion.

[00:17:25] Speaker 04:
Well, I think, Your Honor, that these are questions that the Board can address on remand.

[00:17:29] Speaker 04:
If this Court fixes the claim construction, then the Board can certainly determine on remand

[00:17:38] Speaker 04:
whether the new claim construction would affect the findings of anticipation in this case.

[00:17:46] Speaker 02:
Thank you, Mr. Herring.

[00:17:46] Speaker 02:
We'll give you two minutes for a bubble.

[00:17:51] Speaker 03:
Mr. Joseph.

[00:17:54] Speaker 03:
Good morning.

[00:17:56] Speaker 03:
The board's claim construction is correct, but as some of the questioning may have suggested, it's a total right, Herring.

[00:18:02] Speaker 03:
The reason is that the board, after addressing Oracle's claim construction dispute,

[00:18:06] Speaker 03:
What the board found as a bottom line fact is the exact same thing that the examiner had, which is that Magnuson, quote, replaces instructions within the intermediate code with new information.

[00:18:18] Speaker 02:
That's Appendix 8.

[00:18:19] Speaker 02:
But let's forget about the board for a moment.

[00:18:22] Speaker 02:
Let's take the question I was asking earlier.

[00:18:25] Speaker 02:
Okay, so let's say the claim construction overriding doesn't properly include circumvention and it doesn't properly include insertion.

[00:18:35] Speaker 02:
What is it that you understand Magnuson to be showing in this figure four, I guess?

[00:18:45] Speaker 03:
Yeah, and to be clear, figure four is a partial description.

[00:18:48] Speaker 03:
We're obviously relying on Magnuson as a whole, not just what's in the figure.

[00:18:53] Speaker 03:
But you're using figure four to walk through it.

[00:18:55] Speaker 03:
This is what Magnuson explains.

[00:18:57] Speaker 03:
Magnuson explains that first, you start with a set of virtual machine instructions, which are called intermediate code.

[00:19:04] Speaker 03:
And that's what's on the left side here of Figure 4, the interpretive program.

[00:19:07] Speaker 03:
So that's your interpretive instructions.

[00:19:09] Speaker 03:
If you didn't change anything in the native code, what you would do is you would run down the intermediate instructions on the left.

[00:19:16] Speaker 01:
Then... So they're in the interpretive program, the virtual machine instructions.

[00:19:21] Speaker 03:
Yes, that's what they are.

[00:19:22] Speaker 03:
The virtual machine instructions run the interpretive code.

[00:19:27] Speaker 03:
And because this is a threaded code model, Magnus explains, the way it works is that you have the virtual machine instruction over here on the left.

[00:19:33] Speaker 03:
What it does is it points you to a service routine, forgetting about native translation for a moment, what it does is the actual virtual machine instruction on the left points you, and there's a physical pointer here in the figure, over to a service routine that actually performs the relevant function.

[00:19:51] Speaker 03:
So for example, on the right side here, under the translated instruction, we have a SUBU instruction, a SUBU service routine, which is for subtraction.

[00:20:00] Speaker 03:
and a BCND service routine, which is a branch on condition function.

[00:20:05] Speaker 03:
So the idea is that if we're over here, then back on the left, at each step, we just move sequentially.

[00:20:11] Speaker 03:
So at the PC pointer, the program counter pointer arrow moves down.

[00:20:15] Speaker 03:
We would guess the instruction that, for example, it would send us over to sub-U, and we would run interpretive text to do subtraction.

[00:20:21] Speaker 03:
We would then go a line down to an instruction that would send us over to do the service routine for the branch on condition.

[00:20:30] Speaker 03:
That's the base case before you get into translation of native code.

[00:20:33] Speaker 03:
That's the familiar threaded code model that Magnuson explains has been around for 25 years, and that he was building on.

[00:20:43] Speaker 03:
What Magnuson does to that is modification to the threaded code model.

[00:20:47] Speaker 03:
It is to say that at runtime, the program can decide to translate certain of the interpreted code into native machine code.

[00:20:57] Speaker 03:
in order to improve the processing machine.

[00:20:59] Speaker 03:
You can run some code that's native for the machine that you're running it on, because it's faster that way.

[00:21:04] Speaker 03:
That's the absolute point of both Magnuson and the 205 patent.

[00:21:08] Speaker 03:
And Magnuson explains that after running, after creating what would be denoted here, for example, as a translated block down here for any given function, Magnuson discloses that what you can do then is that, quote, this is Appendix 8.9.18, we introduce a new instruction translated

[00:21:27] Speaker 03:
that contains, quote, a pointer to the translated block and also handles what he calls entry-exit issues.

[00:21:34] Speaker 03:
So we know that there are two things.

[00:21:35] Speaker 03:
There is a translated instruction that points to the translated block of code, just like all of the virtual machine instructions on the left point to something else over on the right.

[00:21:45] Speaker 03:
So if we want to know where this translated instruction is, we see, well, which instruction on the left has a literal pointer over to the translated block on the right.

[00:21:54] Speaker 03:
And that's the instruction that over here on the left is denoted at

[00:21:57] Speaker 03:
the line labeled PC pointer, which is program counter pointer.

[00:22:01] Speaker 03:
So the concept is this.

[00:22:03] Speaker 03:
You're running your intermediate interpreted code.

[00:22:06] Speaker 03:
At every given level, you've got a function.

[00:22:08] Speaker 03:
Multiply, divide, whatever it might be.

[00:22:11] Speaker 03:
Normally, that kicks you over to a service routine that performs the interpreted code.

[00:22:14] Speaker 03:
Interpreted code being code that can run on any machine, any machine architecture.

[00:22:20] Speaker 03:
What will happen, though, to perform the function with native code, translated native code,

[00:22:25] Speaker 03:
is that the machine in real time will create a translated block of native code for a function along with the corresponding translated instruction.

[00:22:34] Speaker 03:
Now Oracle expressly conceded in the PTO, as they absolutely had to, that the translated instruction is, quote, in the intermediate instruction stream.

[00:22:44] Speaker 03:
That's Appendix 1020 and 1032.

[00:22:47] Speaker 03:
So we know, take it as a given, that the

[00:22:50] Speaker 03:
translated instructions over on the left side, where it has to be, otherwise you'd never get to it, it wouldn't do anything.

[00:22:56] Speaker 03:
And where is it on the left side?

[00:22:57] Speaker 03:
It's on the place on the left side that points to the translated code.

[00:23:01] Speaker 03:
And so as a result, their argument in their reply brief, very clearly their argument in their reply brief ends up being that for there to be anticipation, the word translated would have to appear on the left-hand side, because then you would know there's a translated instruction on the left-hand side.

[00:23:15] Speaker 03:
But given that Magnuson explains that the instructions on the left-hand side

[00:23:19] Speaker 03:
point to the corresponding service routine or code on the right-hand side.

[00:23:23] Speaker 01:
You don't need to label both kinds.

[00:23:24] Speaker 01:
We're talking about 64 bits that are divided to two different, they're pointing to two different places.

[00:23:32] Speaker 03:
Yeah, the way this works is that each of the instructions is, oh, and by the way, you may help explain this just a little bit before I get into just a little bit of running start.

[00:23:41] Speaker 03:
You asked counsel before about the level of skill in the art.

[00:23:44] Speaker 03:
He told you the level of skill that Oracle had spot, but the examiner expressed the reject

[00:23:49] Speaker 03:
The examiner's finding a fact, and this is on page 41 of the appendix, is that the relevant skill in the art is not just a degree in computer science, it's not just a year of experience with computer programming, which was Oracle's answer in Oracle's testimony below.

[00:24:03] Speaker 03:
The examiner found as a fact that it's also a year of experience with designing compilers or interpretive-based software systems.

[00:24:09] Speaker 03:
Now the reason that's important is it's a very high level of skill.

[00:24:12] Speaker 03:
That means that people reading this, those people, this is inside baseball, right?

[00:24:16] Speaker 03:
This is what they do all the time.

[00:24:18] Speaker 03:
And so the way the 64-bits works is that if you look at the instructions, each instruction box over on the left, there's a dotted line halfway through it.

[00:24:27] Speaker 03:
So the 64-bits fits into the top 32 and bottom 32.

[00:24:31] Speaker 03:
For purposes of the translated instruction, that's why from the PCTR pointer instruction, there are two arrows.

[00:24:37] Speaker 03:
One going up to the translated service routine at the top.

[00:24:39] Speaker 03:
That's what the first 32-bit sends you to.

[00:24:41] Speaker 03:
And the second 32-bit sends you with the dotted arrow down to the translated block of code at the bottom.

[00:24:48] Speaker 03:
And so each 32 bits can direct you to a different thing.

[00:24:51] Speaker 03:
Magnuson explains the way that the division of labor between the translated service routine and block can vary, he explains.

[00:24:59] Speaker 03:
But the basic concept is this.

[00:25:01] Speaker 03:
You need the translated block to actually, that's the executable code that runs the function.

[00:25:06] Speaker 03:
Let's say it was a multiplication function that had been translated.

[00:25:08] Speaker 03:
It doesn't matter what it was.

[00:25:09] Speaker 03:
Let's say it was.

[00:25:10] Speaker 03:
In addition to that code, you would also need to know, well, what numbers am I multiplying?

[00:25:16] Speaker 03:
Where do I store the results?

[00:25:18] Speaker 03:
And then there are also what he calls entry and exit issues, where when you move from the interpreted code into a native instruction, and then you switch from native instruction back to interpreted code, there's some practical things you have to do to make sure that it's all working.

[00:25:30] Speaker 01:
But the way you're describing this, it sounds to me like it's not overriding if we assume that the claim construction that the board used was wrong.

[00:25:39] Speaker 03:
No, the reason it is is that the way that it works,

[00:25:45] Speaker 02:
For example, just to be clear, you agree that Magnuson doesn't show circumvention or insertion, right?

[00:25:53] Speaker 03:
I suppose it depends what you mean by insertion.

[00:25:56] Speaker 03:
We have insertion of... It doesn't show circumvention.

[00:26:00] Speaker 03:
That's never been our argument.

[00:26:01] Speaker 03:
Our argument is that... No, no, I understand.

[00:26:02] Speaker 03:
I'm just trying to make sure that there's agreement here.

[00:26:06] Speaker 03:
Yeah, our argument at Magnuson all along is that what it shows is the translated instruction going exactly where the other instruction had been.

[00:26:12] Speaker 03:
That's the only argument we've ever made.

[00:26:15] Speaker 01:
But that's why I'm getting back to this question.

[00:26:17] Speaker 01:
Yes, it ends up there at some point.

[00:26:20] Speaker 01:
But the question is how it ends up there.

[00:26:22] Speaker 01:
So if we assume that the claim construction was wrong and that overriding is to be construed the way your friend on the other side contends it should be construed, then how does your description of how these different pieces and parts then get together

[00:26:41] Speaker 01:
constitute overwriting?

[00:26:42] Speaker 03:
Well, the reason is that over here on the left, in any given instruction block, you know, in this instance, we're talking about the one that's at the designation of PC, of the program counter pointer, but it could be any one of these.

[00:26:53] Speaker 03:
Initially, there isn't a virtual instruction there of the interpretive variety that pointed over to a service routine for interpreters.

[00:26:59] Speaker 03:
So for example, go down a line level to the SUB-U instruction.

[00:27:03] Speaker 03:
There's a SUB-U instruction here on the left.

[00:27:05] Speaker 03:
It points over to the SUB-U service routine on the right.

[00:27:08] Speaker 03:
Now, if that's what had been translated,

[00:27:10] Speaker 03:
then the translated instruction would go in the corresponding part on the loft where the sub-U now is.

[00:27:17] Speaker 03:
Because the point is that the translated instruction takes the place of the instruct and sends you to native code.

[00:27:24] Speaker 03:
So for the translated instruction to be there on the loft and send you to the native code at the right time, the right part of the program, it takes the place of the instruction that had previously been there and sent you to a service routine for implement for.

[00:27:35] Speaker 01:
Okay, so takes the place because

[00:27:37] Speaker 01:
They're both in there and one has a priority?

[00:27:41] Speaker 03:
No, it goes in there and the other one comes out.

[00:27:43] Speaker 03:
Magnuson also explains.

[00:27:44] Speaker 03:
Comes out?

[00:27:46] Speaker 03:
It's stored elsewhere so they can put it back in.

[00:27:48] Speaker 03:
This is what the briefs talk about in terms of the exit routines.

[00:27:51] Speaker 03:
And this also then is further evidence that the examiner relied on for the fact that they really hadn't been overriding.

[00:27:56] Speaker 03:
The original virtual machine instruction that had been there is stored in by what Magnuson describes as

[00:28:05] Speaker 03:
places a variable called constant.

[00:28:08] Speaker 03:
And at page 81020 in the board, Oracle expressly conceded about the original instruction being stored in constant.

[00:28:16] Speaker 03:
Now the reason the original instruction has been overwritten there, the reason the original instruction is stored elsewhere is that some other time when you run this code, maybe on a different machine architecture, you might want to go back to using the interpret instruction instead of just having this new native one that you had there.

[00:28:33] Speaker 03:
So during this, you store

[00:28:35] Speaker 03:
the original machine instruction that had been literally replaced in a variable called constant.

[00:28:40] Speaker 03:
When you're now done executing the... There's nothing wrong with that because the patent shows storing it.

[00:28:46] Speaker 02:
There's nothing wrong with that because the patent shows storing it.

[00:28:49] Speaker 03:
That's what I was going to get to.

[00:28:50] Speaker 03:
It's exactly the same thing as the patent.

[00:28:53] Speaker 03:
Because you overwritten it here, you store it somewhere else.

[00:28:56] Speaker 03:
Now, when they finish running the translated block, one of the things that can be done as part of what's called an exit routine is to take the stored original instruction

[00:29:04] Speaker 03:
and then put it back where it had been so that the next time you run the code, you'd again have the choice of using it.

[00:29:09] Speaker 03:
And the reason that's a very important confirming evidence that the examiner lied in her findings is that Oracle again argues in the same brief in this court that the fact that the patent stores the original instructions somewhere else so that it can be put back, they say that's proof that there really was overriding in the patent in the way that they mean it.

[00:29:29] Speaker 03:
And it's the exact same point for Magnuson.

[00:29:32] Speaker 03:
that Magnuson works exactly as the patent does, because the only way this machine code could even work, the only way this could even work is what Magnuson describes, which is you have a new translated instruction on the left pointing to the new translated block on the right for the function that otherwise would have been there in interpretive code.

[00:29:48] Speaker 05:
And because you put... Can you put aside for a minute the question of storage of whatever was originally in the left hand?

[00:29:58] Speaker 05:
I'll put that completely to one side.

[00:30:01] Speaker 05:
What else tells us that what's going on within the block where the PC pointer is?

[00:30:12] Speaker 05:
Program counter is on this.

[00:30:13] Speaker 05:
Program counter pointer is not simply a pointer to a translator instruction over to the right and to the block as opposed to a replaced line of code one

[00:30:31] Speaker 05:
one being replaced by the other.

[00:30:33] Speaker 03:
Magnuson expressly discloses both, which is why you can't limit it to one or the other.

[00:30:39] Speaker 03:
Magnuson expressly discloses that, and this is at, sorry, Magnuson expressly discloses, this is at page A918 of the appendix,

[00:30:56] Speaker 03:
that you can do one of, there are, quote, there are two ways of combining the threaded code model with block translation.

[00:31:02] Speaker 05:
Either... Where on that page are you reading?

[00:31:04] Speaker 05:
Oh, I see, I got it.

[00:31:06] Speaker 05:
Okay.

[00:31:06] Speaker 05:
Two, three quarters of the way down.

[00:31:08] Speaker 03:
Yep, beginning of a paragraph.

[00:31:09] Speaker 03:
It says there are two ways of combining the threaded code model with block translation.

[00:31:13] Speaker 03:
Either the internal format includes a direct pointer to the compiled block, which is the option you asked about, or we introduce a new instruction translated.

[00:31:21] Speaker 03:
And it then goes on to explain the new instruction translated.

[00:31:23] Speaker 05:
But why couldn't that be in search?

[00:31:27] Speaker 03:
Well, that's why I said before.

[00:31:28] Speaker 03:
The second piece.

[00:31:29] Speaker 05:
The first piece is clearly, I think you would agree, is clearly not overwriting.

[00:31:35] Speaker 03:
The claim language requires that an instruction overwrite an instruction.

[00:31:38] Speaker 03:
So we're not saying that a pointer overwrites an instruction.

[00:31:40] Speaker 05:
Okay, so then there's the second option.

[00:31:43] Speaker 05:
Or we introduce a new instruction.

[00:31:45] Speaker 05:
Why can that not be?

[00:31:47] Speaker 03:
Well, that's why when Judge Sack asked before whether we agree there was an insertion, I said it really depends on what you mean by insertion because

[00:31:54] Speaker 03:
any version of overriding.

[00:31:55] Speaker 05:
Putting in a new line of code between two that already exist without displacing either the two that already exist.

[00:32:02] Speaker 03:
The reason that you, the reason you don't have that is this is a, is our... Would that be overriding if you inserted a new line of code?

[00:32:10] Speaker 03:
Now we're flipping over to clamp construction, but we would certainly argue yes, not the issue here and not relevant because that's not what happens here, but sure, because you're displacing...

[00:32:18] Speaker 03:
Now, the reason it's not what happens here, as the examiner found, our expert testified to you, from the perspective of a person with a lot of skill in the art, which is important when reading highly technical paper like this, is that the way the threaded code model works, and Magnuson explained that in the round for 25 years, cited a paper on it, the idea of a threaded code model is that you proceed sequentially from one line to the next to the next.

[00:32:39] Speaker 03:
And in any given line that sends you off to a service routine, the service routine returns you to the next line.

[00:32:46] Speaker 03:
When the instruction before the one that was translated finishes running, the service line sends you down to what we're calling the PC pointer box.

[00:32:54] Speaker 03:
If the translated instruction is not there, then it's not going to run.

[00:32:58] Speaker 03:
Instead, what's going to run is what's there, which is the original virtual machine instruction pointing you to interpret code, which is why the examiner found as a fact that for this to work, the only way that the threaded code model actually works is for the new translated instruction to go exactly where, to this place, to be exactly where,

[00:33:15] Speaker 03:
the interpreted instruction otherwise would have been.

[00:33:18] Speaker 03:
That's how a threaded code model works.

[00:33:20] Speaker 03:
Now there are other ways of overriding things where you don't literally have to put something in each other's place, but not in the threaded code model as understood by a person with quite a lot of skill in the art and as described by Magnuson.

[00:33:33] Speaker 05:
So now turning to the storage business.

[00:33:38] Speaker 05:
I got it.

[00:33:38] Speaker 05:
This is it.

[00:33:39] Speaker 05:
I think you pointed to a 10 20, which is what or some Oracle file.

[00:33:44] Speaker 03:
That was a concession by Oracle below.

[00:33:46] Speaker 05:
What's, what's the confession that you, that you were referring to?

[00:33:49] Speaker 03:
What they agreed upon there, they referred to quote the original instruction, the one that we are used to overwritten, the original instruction being stored in the common constant C O N S T. Right.

[00:34:01] Speaker 03:
No, the reason that that's important is the reason the concession is important is that they've disputed that in their briefs here.

[00:34:06] Speaker 03:
But the point of it is this, and this is exactly how the patent works, as Judge Dyke pointed out.

[00:34:10] Speaker 03:
When the interpreted instruction that was overwritten by the translated instruction was overwritten by the translated instruction, you don't want to lose that forever.

[00:34:18] Speaker 03:
You may need it the next time you run the program on a different computer architecture.

[00:34:21] Speaker 03:
So the initial, the original replaced instruction is stored in a variable called constant, so you don't lose it.

[00:34:27] Speaker 03:
It's stored somewhere else.

[00:34:29] Speaker 03:
Then Magnuson explains that it's part of the exit routine.

[00:34:33] Speaker 03:
Exit means you're getting out of the

[00:34:34] Speaker 03:
native coding going back to the interpreted code.

[00:34:37] Speaker 03:
One of the things you can do at that point is to then take that original instruction that was stored elsewhere in the constant and put it back where it had been.

[00:34:45] Speaker 05:
So that it's available the next runtime.

[00:34:47] Speaker 03:
Exactly.

[00:34:47] Speaker 03:
And which is exactly what happens.

[00:34:48] Speaker 05:
They say expressly on 1020 rather constant contains information about the original instruction precisely because in the intermediate format instruction stream

[00:35:00] Speaker 05:
translated instruction was used instead of, it helps me to emphasize the word used that is executed, not the emphasize instead of the original instruction.

[00:35:11] Speaker 05:
But the reason for the original instruction being stored is not necessitated by it being overwritten.

[00:35:17] Speaker 05:
Now maybe you're the wrong person to ask what is meant, but they do expressly their

[00:35:22] Speaker 05:
deny the implication of overwriting from the storing of the original instruction.

[00:35:29] Speaker 03:
I must say they were conceding that factual premise and that means that they're wrong because of what we were talking about earlier, which is elsewhere in their briefs in this court, they argued that the fact that the original instruction after being overwritten in the patent is stored according to patent, that necessarily means that it was literally overwritten because why else would you store it anywhere else?

[00:35:48] Speaker 03:
And our point is what's good for the gander.

[00:35:52] Speaker 03:
The reason

[00:35:53] Speaker 03:
This is interpretive evidence, but the reason in both the patent and Magnuson that the original instruction is stored after being replaced over it, whatever you want to call it, is stored elsewhere in a constant is precisely because it's been displaced.

[00:36:07] Speaker 03:
If it was still there all along, you wouldn't need to remove it.

[00:36:12] Speaker 03:
You wouldn't need to take it out and put it back.

[00:36:14] Speaker 03:
And that's squarely what they argue on their own claim construction argument about what happens in the patent.

[00:36:21] Speaker 03:
The other point is it's worth

[00:36:23] Speaker 03:
I mean, so the basic points in this are one, just, you know, I sort of walk through hopefully what's actually disclosed here.

[00:36:28] Speaker 03:
And their argument in the brief really does end up being you need the word translate to appear on the left as well as on the right.

[00:36:32] Speaker 03:
But since the left points to the right, you don't need labels on both sides, especially if person skilled in the art.

[00:36:37] Speaker 03:
And it's well worth remembering, well worth remembering that the basic point of both the patent and Magnuson is to speed, is to improve execution speed by replacing a

[00:36:52] Speaker 03:
interpreted code with native code.

[00:36:56] Speaker 03:
They're both trying to do exactly the same thing.

[00:36:58] Speaker 03:
So it's not a surprise that they end up doing it.

[00:37:01] Speaker 05:
Can you answer a question that I'm sure is going to sound extremely stupid, but how do you save time when you are doing the replacement in runtime as opposed to in advance?

[00:37:12] Speaker 03:
The reason, and Magnuson walks through this early on, but it's pretty technical, the reason is that

[00:37:18] Speaker 03:
If I run a native code, that's code that's actually been intended for the particular computer architecture I'm running, so you can run it directly.

[00:37:26] Speaker 03:
If you run virtual machine and code, the idea of that code is that it's code that can be run through a virtual machine, software platform, that will then be able to run on any computer architecture.

[00:37:37] Speaker 03:
It's part of the idea of Java, where it wants to run anywhere.

[00:37:41] Speaker 03:
But the thing is, if you have your code that you have to run through the virtual machine,

[00:37:46] Speaker 03:
in order to convert, in order to make it run on any computer architecture, that just entails additional processing steps.

[00:37:53] Speaker 03:
And those additional processing steps slow things down.

[00:37:56] Speaker 03:
So I take it your question is, yeah, but if you're going to convert to native code, that takes some processing steps, too.

[00:38:02] Speaker 03:
And in theory, yeah, there's a trade-off there.

[00:38:05] Speaker 03:
But as Magnuson explains, and he ran his prototypes and tests to show it, it turns out that it's significantly faster, that the processing steps involved in

[00:38:14] Speaker 03:
running the virtual machine are greatly in excess of the speed and tail of the processing steps of switching to native machine code that can then run a whole lot faster.

[00:38:24] Speaker 02:
Could I take one more crack at seeing if I can articulate this in a way that I can understand and you tell me if I'm wrong?

[00:38:31] Speaker 02:
That if I understand the patent figure five in the left hand column of figure four, it would have overwritten part of the code here.

[00:38:45] Speaker 02:
and changed it before there's any translating staff or whatever you want to call it, putting it into something like the Java bytecode.

[00:38:59] Speaker 02:
But what figure four in Magnuson shows is not that, that the interpreter program is not itself being changed, but that the code blocks are being transferred over to the simulated code and that the code block

[00:39:15] Speaker 02:
which we're focusing on, is not transferred over instead that the native code is substituted instead as part of the transfer process.

[00:39:28] Speaker 02:
I don't know whether that makes any sense or not.

[00:39:30] Speaker 03:
Do you understand what I'm trying to say?

[00:39:32] Speaker 03:
Maybe.

[00:39:33] Speaker 03:
I mean, if my answer shows I didn't, please.

[00:39:36] Speaker 03:
I think I did, but if my answer shows that I didn't understand what you said, please just let me know and I'll try again.

[00:39:41] Speaker 03:
But I think that the answer is that it's important in Figure 4 to understand.

[00:39:44] Speaker 03:
magazine figure four?

[00:39:46] Speaker 03:
There are two different things because the way that this model works is on the left you have the virtual machine instructions but those don't, whether the virtual machine instruction is the original or an overwritten replaced one, either way the virtual machine instruction itself doesn't execute the underlying function, be it subtraction or branch on condition or whatever else.

[00:40:06] Speaker 03:
No matter what you have a virtual machine instruction on the left that points to executable code on the right and that's true whether we're talking about

[00:40:15] Speaker 03:
whether it's native or not, okay?

[00:40:17] Speaker 05:
And so, what is, so for example, if you look at this, I'm sorry, whether it's native or not.

[00:40:23] Speaker 03:
But whether we're talking about the original interpreted code or native code.

[00:40:26] Speaker 05:
By native, you don't mean machine code.

[00:40:29] Speaker 05:
You mean the original in the... Sorry, I meant the translated code.

[00:40:35] Speaker 03:
I mean, the idea of, two things are trying to distinguish between, I mean, there's an original native code before any of this happens that was turned into synthesized code,

[00:40:45] Speaker 03:
But what I meant is you have the interpretive code, which is, say, Java code, write once, run anywhere.

[00:40:51] Speaker 03:
And then what you're doing is you translate some of that into native code, meaning code that's native for the computer architecture that you're running on right then, whatever that may be.

[00:41:01] Speaker 03:
So the original virtual machine instructions over on the left, I'll refer you on the right to a service routine of interpretive code that will actually perform the relevant function.

[00:41:11] Speaker 03:
So the code that performs subtraction

[00:41:14] Speaker 03:
is not the instruction on the left, it's the sub-use service routine on the right that's pointed to by an instruction on the left.

[00:41:19] Speaker 01:
So the virtual machine instructions are, in your view, the interpreted code, or the simulation code, or some combination of both?

[00:41:28] Speaker 03:
I think it's common ground that the virtual machine instructions are the ones on the left.

[00:41:34] Speaker 03:
That's the intermediate program code.

[00:41:37] Speaker 03:
But the point is that the way that they work is that each of those isn't self-executing, in a bad term.

[00:41:43] Speaker 05:
The machine doesn't directly execute those.

[00:41:46] Speaker 03:
The virtual code on the left refers to service routines over on the right, and the service routine on the right just happens to look at somewhere else, performs the function.

[00:41:56] Speaker 03:
That's true if it's interpreted or translated as native.

[00:42:01] Speaker 03:
And so the virtual machine instructions, I think everyone agrees, are on the left.

[00:42:05] Speaker 03:
The point is simply that when we translate one of the service routines on the right,

[00:42:11] Speaker 03:
from interpreted code, say interpreted subtraction into native subtraction for the relevant computer code.

[00:42:17] Speaker 03:
Two things happen.

[00:42:18] Speaker 03:
One is we make a translation of the underlying implementing executable code over on the right.

[00:42:22] Speaker 03:
And the second, Magnuson tells us that over on the left, we either include a pointer that will get us to the new native code or we introduce a new instruction translated that among other things contains that pointer.

[00:42:36] Speaker 02:
Would it be fair to say that in changing the

[00:42:40] Speaker 02:
virtual machine instructions over into the simulated code, you are transferring blocks of code from one column to the other and then manipulating that code in the process.

[00:42:57] Speaker 02:
But what Magnuson shows is as part of the process of transferring the blocks of code, we're going to substitute native machine instructions for the

[00:43:10] Speaker 02:
virtual machine instructions as part of that process.

[00:43:14] Speaker 02:
Does that make any sense?

[00:43:16] Speaker 03:
The second half of that's clearly correct.

[00:43:20] Speaker 03:
The first half, I'm sorry, I'm not entirely sure.

[00:43:24] Speaker 02:
So the difference between this and figure five of the patent is that the substitution is taking place at a different stage of the process.

[00:43:36] Speaker 02:
In the patent, the substitution is taking place

[00:43:39] Speaker 02:
while the interpretive program is there and before there is any manipulation of that code, whereas in Magnuson it takes place as part of the process of manipulating the interpretive code over into the simulated code, simulation code.

[00:44:00] Speaker 03:
Maybe let's go to the patent figure five, back to patent figure five.

[00:44:03] Speaker 03:
But what I said doesn't make any sense or does it make sense?

[00:44:07] Speaker 03:
The reason is this.

[00:44:09] Speaker 03:
The reason is this.

[00:44:11] Speaker 03:
On a patent figure, I know it, but again, I'll point out that the technical complexity points to the high level skill in the art and deference, which is true and an important point.

[00:44:22] Speaker 03:
But patent figure five on the left, where the GoNative instruction replaces bytecode two, okay?

[00:44:28] Speaker 03:
Just like over here, the translate instructions replaces the instruction that had previously been in the same place.

[00:44:33] Speaker 03:
What does the GoNative instruction do?

[00:44:35] Speaker 03:
We have an arrow that takes us over to a snippet zone.

[00:44:37] Speaker 03:
And the snippet zone contains the executable code.

[00:44:41] Speaker 03:
So in the patent, we're replacing two different things, right?

[00:44:44] Speaker 03:
We're replacing an instruction on the left.

[00:44:47] Speaker 03:
And then on the right, we are run.

[00:44:50] Speaker 03:
And then that takes us over to the right to a block of executable native code that is run instead of what byte code 2 otherwise would have run.

[00:44:58] Speaker 03:
And this is my point.

[00:44:59] Speaker 03:
That's exactly what Magnuson does.

[00:45:01] Speaker 03:
You replace the instruction on the left, the virtual machine instruction on the left, whether you call it go native or translated, depending on which one you're in.

[00:45:08] Speaker 03:
And either way, what it does is it takes you to the right.

[00:45:11] Speaker 03:
The patent calls the snippet zone.

[00:45:13] Speaker 03:
We call it service routines in Magnuson or blocks of translated code.

[00:45:17] Speaker 03:
But either way, at the same point, it just does a logistical matter.

[00:45:20] Speaker 03:
What you replace is a virtual machine instruction on the left.

[00:45:24] Speaker 03:
That takes you over to a new block of native code that runs instead of the interpretive code that otherwise would have run.

[00:45:30] Speaker 03:
And that's why it sounded like to me, Judge Steck, like you were talking about, are we moving things from the left to the right and vice versa?

[00:45:36] Speaker 03:
And my answer to that would be no, because in both of them, there's something on the left and something on the right, and what's on the left stays on the left, what's on the right stays on the right.

[00:45:43] Speaker 03:
There's just a new instruction put on the left and a new corresponding block of code put on the right.

[00:45:48] Speaker 03:
And that's true of both the patent and Magnuson.

[00:45:52] Speaker 02:
But maybe the difference between the patent and Magnuson is that the patent has three steps.

[00:45:58] Speaker 02:
whereas Magnuson has two steps.

[00:46:00] Speaker 02:
In other words, in figure five of the patent, the first column as part of the transfer to the second column has this overriding of bytecode two.

[00:46:10] Speaker 02:
Whereas in Magnuson, you're not doing that step.

[00:46:17] Speaker 02:
You're going from the left-hand column to the right-hand column.

[00:46:21] Speaker 03:
No?

[00:46:22] Speaker 03:
Well, but how do you get, in either of them, how do you get from the left-hand column to the new part of the left-hand column to the new part of the right-hand column?

[00:46:28] Speaker 01:
And isn't the Go Native, isn't that the overwriting that Judge Dyck was just talking about?

[00:46:32] Speaker 01:
Precisely.

[00:46:33] Speaker 03:
And that's what I'm about to say is the same thing with Magnuson.

[00:46:36] Speaker 03:
The Go Native instruction on the left overwrites bytecode 2 and sends you to a service, they call it snippet zone, which is a new block of translated native text over on the right.

[00:46:46] Speaker 03:
That's exactly what the patent shows.

[00:46:49] Speaker 03:
Magnuson, now as a highly technical paper written for a highly technical audience, Magnuson doesn't do as much labeling on the left side.

[00:46:56] Speaker 03:
But what it shows is on the left side, you have this is the interpret program, the intermediate program code, the stream of instructions.

[00:47:02] Speaker 03:
And each of them contains a pointer to a block over on the right side, which Magnuson calls either a service routine or a block of translated text.

[00:47:11] Speaker 03:
Either way, it's the same thing.

[00:47:12] Speaker 03:
You have an instruction on the left that points you to implementing or executing code over on the right.

[00:47:18] Speaker 03:
And we know that the equivalent over here, if you want to say the PC pointer was the equivalent of bytecode 2,

[00:47:27] Speaker 03:
We know that it's been overwritten by the translated or go native, whatever you want to call it, instruction because Magnuson says that we can introduce a new instruction translated that will point to the new replacement block of code.

[00:47:37] Speaker 01:
Under that theory, wouldn't it be more correct to say that the simulation code is actually the virtual machine code in Magnuson?

[00:47:46] Speaker 03:
The claim language as a whole, and this is true for both Magnuson and the patent,

[00:47:52] Speaker 03:
The claim language as a whole refers to a virtual machine instruction that, quote, represents or references one or more native machine instructions that can be executed.

[00:48:02] Speaker 03:
So the claimed virtual machine instruction is something that represents or references executable code, which is why in both Magnuson and the patent, the claimed virtual machine instruction for overwriting that we're talking about is the bytecode or instruction on the left, not the block of code on the right that it points to.

[00:48:20] Speaker 03:
That's true for either one of them.

[00:48:22] Speaker 03:
It's just a function of other claim language that's not otherwise directly in dispute here.

[00:48:26] Speaker 03:
But again, I just can't keep coming back to the fact enough that the examiner found that there's a very high level of skill in the art here.

[00:48:33] Speaker 03:
And when it comes to reading a highly technical paper from the perspective of a person skilled in the art, the examiner's fact finding, which is the same fact finding the board ultimately made, is entitled to considerable deference, I think in part because of some of the things we're talking about here.

[00:48:49] Speaker 03:
Thank you, Mr. Joseph.

[00:48:51] Speaker 02:
Thank you.

[00:48:59] Speaker 04:
I'd actually like to respond first to the last thing that my friend said, which he said that the board made the same factual finding as the examiner.

[00:49:14] Speaker 04:
And that's not correct.

[00:49:16] Speaker 04:
The board made a finding

[00:49:18] Speaker 04:
that there was code overwritten.

[00:49:20] Speaker 04:
I'm sorry, the examiner made a finding that there was code overwritten.

[00:49:22] Speaker 04:
The board only made its finding based on the, under the erroneous claim construction.

[00:49:27] Speaker 04:
It was not able to find anywhere in Magnuson that code was overwritten, and that's because nothing in Magnuson discloses it.

[00:49:33] Speaker 04:
Now, to be sure, most of the discussion that just occurred explained how, in figure four, it shows that there's code, I'm sorry, virtual machine instructions on the left side,

[00:49:46] Speaker 04:
that point to a block of compiled code on the right.

[00:49:49] Speaker 04:
That's entirely true.

[00:49:52] Speaker 04:
But nothing about that fact indicates that what occurred is that at runtime, there was a new virtual machine instruction that was generated and that was written on top of an existing virtual machine instruction.

[00:50:04] Speaker 04:
There's simply nothing in magazine.

[00:50:05] Speaker 04:
The only thing to which they point is this sentence that says, we can introduce a new instruction.

[00:50:12] Speaker 04:
Well, the plain meaning of introduce is just to put into use.

[00:50:16] Speaker 04:
There are two ways of doing this.

[00:50:19] Speaker 02:
It doesn't have to be that the original instruction is deleted at the same time?

[00:50:24] Speaker 04:
No, it doesn't because there are multiple ways that you could introduce a new instruction.

[00:50:29] Speaker 04:
You want to put into use this new instruction.

[00:50:32] Speaker 04:
The new instruction could be inserted, it could be somewhere else in the file, and you could have memory pointers pointing to the new instruction.

[00:50:39] Speaker 04:
But you said the Magnuson doesn't show insertion.

[00:50:45] Speaker 04:
I mean, Magnuson doesn't appear to show insertion, but it also doesn't appear to show overwriting.

[00:50:50] Speaker 04:
So what Magnuson shows is that code was originally written, and that when the source code gets taken over into the interpreted code, that at that point, part of the code gets interpreted into the native machine instructions.

[00:51:08] Speaker 04:
Part of it is already compiled.

[00:51:11] Speaker 04:
But picking up from a point that you made earlier, what it doesn't show is the three-step process.

[00:51:16] Speaker 04:
It just shows the two steps.

[00:51:18] Speaker 04:
It shows that code points to the compiled code, but it doesn't show the three-step process, which is you originally had code that was going to be interpreted, and then a new line of code gets overwritten on top of the line of code.

[00:51:32] Speaker 04:
Simply nothing in Magnuson discloses that.

[00:51:36] Speaker 01:
Obviously your friend on the other side doesn't think this is how it works, but is it possible that what Magnuson is saying is that the interpreter code points to the simulation code, which is where the virtual machine instructions lie.

[00:51:51] Speaker 01:
And then when the spark code is generated at run time, that that's when the translation occurs.

[00:51:57] Speaker 04:
Well, the spark code, magazine doesn't say the spark code is generated at runtime.

[00:52:01] Speaker 01:
Yeah, it does actually.

[00:52:03] Speaker 04:
Well, it discusses at that point, that's in a discussion about the previous art, the previous before the new.

[00:52:12] Speaker 04:
So, magazine introduced this partial translation idea that the sentence to which they point that it could be generated at runtime is actually in the discussion of the block interpretation, not the partial translation.

[00:52:25] Speaker 04:
In the discussion of partial translation, nothing says that this occurs at runtime.

[00:52:31] Speaker 05:
There was a lot of discussion about the storage and the... Can I just... So the sentence in Magnusson says you can either point to this other instruction or you can introduce an instruction.

[00:52:54] Speaker 05:
So what version of non-pointer is there that is something other than deletion and replacement, which is what I take you to mean.

[00:53:07] Speaker 04:
You could still introduce a new instruction, and the instruction could take as a parameter the lines of code.

[00:53:14] Speaker 04:
Just like it says, you can introduce a new instruction, but that doesn't mean that that new instruction gets written on top of

[00:53:20] Speaker 05:
In that sense, introduce has to mean something other than point to what?

[00:53:26] Speaker 04:
Introduce, the plain meaning of introduce is to put into use.

[00:53:30] Speaker 04:
So what Magnuson is explaining is rather than having a pointer, we're going to have a line of code called translate.

[00:53:39] Speaker 04:
And that line of code called translate is going to have the parameters that are going to then point to the compiled code, the native code.

[00:53:48] Speaker 04:
But nothing about that.

[00:53:49] Speaker 04:
That just simply says we're going to, rather than using pointers, we're going to use a new instruction culture.

[00:53:56] Speaker 05:
I guess I'm having my imagination and knowledge are too limited here.

[00:54:01] Speaker 05:
An instruction that says, go there and do this.

[00:54:04] Speaker 05:
I take it to be a pointer.

[00:54:07] Speaker 05:
Insertion can be, you go from one to now 1.5.

[00:54:11] Speaker 05:
I forget about the number before you, but you don't erase one or two.

[00:54:15] Speaker 05:
and 1.5 is introducing this instruction.

[00:54:19] Speaker 05:
Is that a non-pointer way of introducing?

[00:54:23] Speaker 04:
That's a non-pointer way of introducing and not overwrite.

[00:54:27] Speaker 05:
Yes.

[00:54:28] Speaker 05:
Okay.

[00:54:28] Speaker 05:
And can you explain the point we were discussing before about why if you don't overwrite in the specific sense of replacing

[00:54:43] Speaker 05:
deleting what was there and putting something else in its place.

[00:54:48] Speaker 05:
Why would you store the line of code or the instruction that you are, yeah, why would you store it?

[00:54:58] Speaker 04:
Oh, and you're not executing.

[00:55:01] Speaker 04:
I mean, I agree that the fact that code gets stored in the patent, for example, shows that it's overwriting the line of code.

[00:55:09] Speaker 04:
Google argues, though, that based on the exit routines,

[00:55:13] Speaker 04:
that it shows that code is stored somewhere and is going to be replaced.

[00:55:19] Speaker 04:
That's not true.

[00:55:21] Speaker 05:
First of all, the board did not find... I'm not asking about what the board found.

[00:55:27] Speaker 05:
I want you to try to explain to me why it is, even intuitively, one would take the original line of code, store it somewhere else, unless you are overwriting it.

[00:55:41] Speaker 04:
You wouldn't, but that's not what Magnuson teaches occurs.

[00:55:45] Speaker 04:
Magnuson does not show that a line of code gets stored somewhere else and that it's going to come back and be replaced.

[00:55:51] Speaker 04:
That's in the discussion of the exit routine.

[00:55:54] Speaker 04:
And I do think it's important that the board didn't find that the exit routines occurred because that would be an alternative ground that's outside the domain of this court.

[00:56:03] Speaker 04:
That's a factual finding that the board has to make, not this court.

[00:56:07] Speaker 02:
Is what you're saying that the interpreted program has never changed.

[00:56:10] Speaker 02:
It just stays there.

[00:56:12] Speaker 02:
So there's no need to store the interpreted program somewhere else.

[00:56:17] Speaker 04:
That's right.

[00:56:18] Speaker 04:
That appears to be under the fact that Magnuson only has the two steps, not the three steps.

[00:56:26] Speaker 04:
The new line of code doesn't get put there.

[00:56:29] Speaker 04:
So you don't need to take another line of code.

[00:56:31] Speaker 04:
And even if you think that Magnuson does do the three steps,

[00:56:37] Speaker 04:
Again, nothing about the exit routines shows that there was a new, that there's instruction that was stored and that's going to come back.

[00:56:46] Speaker 04:
Their experts report is entirely conclusory about that.

[00:56:49] Speaker 04:
It just, it simply says, in fact, the point that their experts reports discussion, and this is important, of what happens in those exit routines says that the translated, the all caps translated is what gets overwritten.

[00:57:05] Speaker 04:
Even their experts,

[00:57:06] Speaker 04:
doesn't say that the exit routines show that the line of code comes, that there's any original line of code that replaced the existing line of code.

[00:57:14] Speaker 04:
What their expert says is that the translated instruction, the new introduced instruction, is what gets overwritten, and that's not what's claimed in the patent.

[00:57:25] Speaker 01:
If we agree with you with respect to the claim construction, what do you think is the proper course at that point for us to take?

[00:57:35] Speaker 04:
We would ask the court to

[00:57:36] Speaker 04:
find that nothing or to hold that nothing in Magnuson discloses overriding under the correct construction and remain to the board with those instructions.

[00:57:49] Speaker 04:
But if there's any doubt about that, this is a factual finding that the board should make under the new construction.

[00:57:57] Speaker 04:
The board only found under the old construction at A9

[00:58:03] Speaker 04:
The board says, under the broad but reasonable interpretation of overriding previously set forth, we find this process replaces instructions within the intermediate code with new information.

[00:58:14] Speaker 04:
In other words, the board only found replacement and never found overriding.

[00:58:18] Speaker 04:
It was all based on the old construction.

[00:58:23] Speaker 04:
There was a lot of discussion that this is very highly technical art, that this is something that

[00:58:29] Speaker 04:
takes a very high level of skill in the art and if that's the case then that's something that the board should find on remit.

[00:58:35] Speaker 05:
I want to come back to what I still don't understand.

[00:58:39] Speaker 05:
10-20.

[00:58:39] Speaker 05:
10-20?

[00:58:45] Speaker 05:
I gather this is your filing in the patent office and right at the bottom you say the reason for talking about Magnuson

[00:58:56] Speaker 05:
the reason for the original instruction being stored in constant is not one thing or another.

[00:59:03] Speaker 05:
I take that to be a concession that the original instruction is, in fact, stored in constant.

[00:59:09] Speaker 05:
And we can argue about why.

[00:59:11] Speaker 04:
Well, I think that that's a response to Google's argument.

[00:59:15] Speaker 04:
In other words, assuming that the original code is stored in constant.

[00:59:21] Speaker 05:
Because previously on the... Right.

[00:59:22] Speaker 05:
I mean, if you want to tell me that

[00:59:25] Speaker 05:
this is unfortunately worded and all you meant to do is to say, assuming that's one thing, but I took it that the factual presupposition of this sentence is an agreement that the original instruction is in fact being stored in consonants.

[00:59:45] Speaker 04:
Well, I think that the better, I think that what was meant to be said there was assuming that that occurs, this doesn't show overriding.

[00:59:55] Speaker 04:
There's an issue in the exit routine itself.

[01:00:01] Speaker 04:
I mean, the exit routines demonstrate that it can't mean replacing the original code.

[01:00:08] Speaker 04:
The exit routine, exit zero and exit D, which is... We are at A920.

[01:00:27] Speaker 04:
Exit 0 has ROP equals upper const and ROP and lower const.

[01:00:33] Speaker 04:
And then the Exit D routine down at the bottom has ROP equals 0.

[01:00:40] Speaker 04:
And the description says that it dispatches OP code 0, which corresponds to not decoded.

[01:00:48] Speaker 04:
In other words, the Exit D routine is the deallocation routine.

[01:00:54] Speaker 04:
that says we're now going to deallocate the compiled block of code.

[01:00:58] Speaker 04:
We're not going to use it anymore.

[01:00:59] Speaker 04:
So we want to return to the way things were.

[01:01:03] Speaker 04:
Assuming under Google's view of the universe, we want to return to the way things were.

[01:01:07] Speaker 04:
But it says ROP, which equals zero, rather than ROP equals const.

[01:01:14] Speaker 04:
If const is what stored that original line of code, this would say ROP equals const, just like it does up in the exit zero routine.

[01:01:23] Speaker 05:
You won't be surprised to learn that I did not follow that entirely.

[01:01:28] Speaker 05:
But getting back to 1020, let's just now indulge the assumption.

[01:01:37] Speaker 05:
You are saying something that either the original instruction is stored in constant, or at the minimum, you're saying if it's stored in constant, that does not imply, presuppose, necessitate

[01:01:53] Speaker 05:
that the original instruction was replaced.

[01:01:57] Speaker 05:
Right.

[01:01:57] Speaker 05:
Why not?

[01:01:57] Speaker 05:
Why would you store the thing if it's not going away?

[01:02:02] Speaker 05:
Not going away in the original instruction?

[01:02:05] Speaker 04:
Well, according to Google's expert, and that's at A897 to A898, Google's expert says that the exit D routine

[01:02:22] Speaker 04:
overwrites the translated instruction.

[01:02:24] Speaker 04:
In other words, it's not overwriting the original instruction as the claims are required.

[01:02:29] Speaker 04:
Google's expert says that assuming that that const stores the original line of code, all it does is it overwrites the translated instruction.

[01:02:38] Speaker 04:
That doesn't show that the translated instruction ever overwrote the original line of code.

[01:02:44] Speaker 05:
I guess I'm asking for something that's more about an intuitive explanation.

[01:02:49] Speaker 05:
At a minimum at the bottom of 1020,

[01:02:52] Speaker 05:
you are saying if, and the language is, the original instruction is stored in constant.

[01:02:59] Speaker 05:
There's a reason to do that even if you are not taking it out.

[01:03:05] Speaker 05:
What is that reason?

[01:03:06] Speaker 05:
Can you make me understand why you would store it somewhere if you haven't taken it out?

[01:03:12] Speaker 04:
I think that the fact, if code is stored as the patent shows in our construction of overwriting from the patent,

[01:03:21] Speaker 04:
that supports that.

[01:03:25] Speaker 04:
The code, in other words, no.

[01:03:28] Speaker 04:
I don't know why you would store that code, except that that's not what Magnuson says is going on.

[01:03:35] Speaker 04:
All that Magnuson says is going on, even under Google's expert report, is that it would overwrite the translated.

[01:03:41] Speaker 04:
So if you were going to store the code somewhere.

[01:03:44] Speaker 02:
You're saying that the interpretive program, parts of it are not saved.

[01:03:47] Speaker 02:
It's just never changed in Magnuson.

[01:03:50] Speaker 04:
That's right.

[01:03:51] Speaker 04:
That's right, Magnuson appears to disclose that when you took the original source code and you create then the virtual machine code, which they call the intermediate code, that at the time you're creating that, you could create that translated instruction that then points to the compiled code, as opposed to in the patent where you would create that instruction

[01:04:20] Speaker 04:
And at runtime, it's going to overwrite the instructions.

[01:04:23] Speaker 02:
So it's going to overwrite after the transfer from interpreted program to simulated code rather than before.

[01:04:31] Speaker 02:
And that's basically your argument.

[01:04:34] Speaker 02:
And that doesn't satisfy the PAC.

[01:04:36] Speaker 03:
That's right.

[01:04:40] Speaker 02:
Anything more?

[01:04:43] Speaker 04:
In any event, we would ask that the claim instruction at a minimum be reversed

[01:04:50] Speaker 04:
case be remanded for the board to consider under the new construction.

[01:04:54] Speaker 02:
Thank you, Mr. Herring.

[01:04:55] Speaker 02:
Thank both counsels.

[01:04:56] Speaker 02:
The case is submitted and that concludes our session for today.