that is unduly broad you do concede that that we have to disagree with the claim construction for there not to be anticipation we have not argued that as you did claims that have the overriding limitation in it saying is that a proper clean construction would exclude circumvention concluded with an override it's not a fair statement i'm not sure exactly what you mean by circum as a list of virtual machine instructions and then the interpreter decides that for a block of code we're going to read it's going to be more efficient to run the native machine code rather than the is your argument really that the board construction reads out of virtual machine instruction for sure the claim i don't think that's our argument i think our argument is simply that it doesn't require that the claim that the new virtual machine instruction actually be written over the original virtual machine instruction it the words construction simply says that it ok i'm still i think i need to understand figure four and magnus and get an order to understand i understand your argument that overriding doesn't include circumvention and seems to be a pretty good already but you also say that figure work is showing circumvention so what is trivial for showing with respect is it for example in the translated box at the top is that the c is the translated block of the bottom so it's it's magnus's very difficult to follow it's pretty in comprehensible but the best that i can understand it is that the interpreter program part on the left to figure  when correlate with the virtual machine instructions in figure five on the right the translated would be the block of so that the small caps translated on the right is a blo of native machine code not virtual machine code and figure forth all figure for show how does that relate to the box bottom so i was trying to write and the box of the bottom is this new block of well not necessarily and it's a lot of compiled native machine instructions i mean folk in earlier that i'm not it's not clear that the translated on top is made of machine instructions the translator block in the bottom is a is a block of native machine instructions from best we can tell so this shows that there's a pointer from the interpreter program down to this translated block but a it doesn't say that nothing  magnussen is covered by the twenty min since we seem to agree that magnus doesn't show circumvention what are they supposed to do well i think the board thought that manson does show some convention and i think that you know the only way that the board was able to affirm these amorous rejections as by coming up with this new claim construction that has simply has no basis in the pattern itself and apart from that like the work if the board are going  affirm on the grounds that the examiner found it would have could have done so without coming up with this new instruction so i think it would be helpful because i like it and i think the board did think that there was this explaining what that is but my understanding is that everything on the right hand side in the simulation comes to the upper right that that is code that has then been interpreted at runtime from the virtual machine instructions into the the native machine co either the internal format includes a direct pointer to the compile block or reintroduce a new instruction translate it there's nothing in magnussen that talks about how you generate this instruction translated when it occurs  there's just no disclosure and so we're not saying i'm evil are you that we're saying that you need code we're not saying that you need some disclosure but what how would you introduce a new instruction without overwriting the thing well one example could be that you c so you could have the lines of code that i mentioned before that point of me the invention is to take a block of code and run the native machine code as opposed to the virtual machine instructions so rather than it runs a snippet of machine code and then it says don't go back to by code three go back to by code say right so if the point i guess i'm a little concerned about your or 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 of steps which i think is what we've been talking about here in the language of circumvention well again that's claimed one claim one has a claim language and you said you the point of the invention here is to go and do a bunch of stuff in the sheen code that you would otherwise be doing by instruction by instruction translating from the byte code in the virtual machine context into machine code running that machine executing the machine still coming back and doing the next thing so why would there be in terms of the purpose of this invention anything that turns on placing that is deleting a line of code as compared to skipping its execution because of everything that we've just described about going executing and coming back that's all in claim one claim one requires that executing a new line of code instead of the line of code that was for rather than claim to claim to have a specific type of executing code instead of other code and that's why overwriting  that's walking about so what happens in magnussen is that the immediate one hundred code gets interpreted into the intermediate code first and then the intermediate code has a pointer then get and that doesn't require overwrite that doesn't require replacing a line of code with another way so what's the argument for the end of the entire argument for anticipation even as a clue when it comes down to this sentence where it says we introduce a new line of code called translated and there's there's just nothing in the disclosure discussing what that means how a person mean well i think you're one of the these are questions that the board can address on remand if this court fixes a claim construction then the board can certainly determine on remand whether the new claim construction the question i was is your lawyer ok so this will say the claim construction overwriting doesn't properly include circumvention doesn't properly insertion what is it that you but in the figure but you're using three or four to look through it this is what magnussen explained that this explains the first you start with a set of virtual machine instructions which are called intermediate code and that's what's on the left side here a figure for the interpreter program so they are the virtual machine instructions are run the interpreted code and because this is a thread of code model next explains the way it works is that you have a virtual machine instruction over here on the left what it does is it pointed to a service routine if forgetting about native translation for a moment what it does is the actual virtual machine instruction on the last point you know there's a physical pointer here and in the in the in the figure over to a service routine but actually performs the relevant option so for example on the on the right side here under the translated instruction we have a sub you instruction which a sub you service routine which is for subtraction and a b c and d service routine which is a branch on condition function so the idea is that if we're over here a line down to an instruction that would send this over to do the service routine for the branch on condition now that's the base case before you get in the translation of native code that's the familiar for the code  program can decide to translate certain of the interpreted code into native machine code in order to improve the process a machine you can run some code that is native for the machine that you're running on because it's faster that way absolute point of both mag appendix eight nineteen we introduced a new instruction translated that contains quote a pointer to the translated walk and also handles what he calls entry exit issues so we know there are two things th translated instruction that points to the translated block of code just like all of the original machine instructions on the law what something else over on the right so if you want to know where this translated instruction is we see well which instruction on the left happen though to to perform the function of native code translated native code is that the machine interrupt in real time will create translated block of native code for a function along with the corresponding translated instruction now oracle expressly can see 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 transmitted instruction on the left hand side but given that magazine explains that instructions on the left hand side point to the corresponding service routine or code on the right hand or interpret of a software system now the reason that's important is it's a very high level skill that means that the people reading this those people this is inside baseball this is what they do all the time and so the way the sixty four business works is that if you look at the magnussen explains the way that the division of labor between the translated service routine and block can vary explains but the basic concept is that you need to translate it was actually you know that's the that's the executable code that runs the function but say it was a multiplication function and translate it doesn't matter what it was say it was in addition to that code you'd also need to know but numbers are multiplying where do i store the results and there are also way calls entry and exit issues where when you move from  interpreted code into a native instruction and then you switch from a destruction back to interpret code there are some practical things you have to do next sure that's all working but and the way you're describing this it's it sounds to me like it's not overwriting if we had up there so the so if we assume that the claim construction was wrong and that overwriting is it's to be construed the way your friend on the other side contend which we can then how how does description of how these different pieces apart then get together constitute overwriting well the reason is that over here on the left in any given instruction block you know it is in the sense that we're talking about the one that set the designation of  sub you service routine on the right now if that's what i've been translated then the translated instruction would go in the corresponding part of the loft where the where the sub you know is because the point is that the translated instruction takes the place of the instructor and sends you to native code so for the translate instruction to be there on the left 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 se 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 set of having this do this new one you had there so during this you store the original the same thing as the pap because you store so because you over and here you store it somewhere else now when they finish running translate it was one of the things that can be done as part of a skull and actually routine is to take the stored original instruction and then put it back where it had been so original instructions somewhere else so that it can be put back they say that's proof that there really was overwriting in the past in the way that they mean it and it's the exact same point for magnussen the magazine works exactly as it happened to us because the way put aside for a minute the question of storage for whatever it was originally in what left hand now put that completely to one side what else tells us that what's going translator instruction it over to the right and adds to the block as opposed to a replaced line of code one one main replaced by the magnuson disclose insertion i said it really depends what you mean by insertion because anybody of overwriting it putting in a new line of code between two that already exists without displacing either the two that are yes that's the reason that you the reason you don't have that is that this is  testified to from the perspective of a person with a lot of skill in the art which is important in reading highly techno paper like this is that the way the thread could model works and magnussen explained that in there over twenty five years as a paper on it if you have a turncoat model is that you proceed sequentially from one line to the next the next and any given line that sends you off a service routine the service routine returns you to the next line so when when the instruction before the one was translated finishes running  box if you can translate instruction is not there then it's not going to run instead was going to run as what's in there which is the original virtual machine instruction pointed to interpret code which is what the examiner found as a fact that for this to work the only way the thread could model actually works is for the new translate instructions to go exactly where to displace to be exactly where the interpreted instruction otherwise would have been that's how it sort of model works now there are other ways of overwriting this part of the exit routine actually means you're getting out of the native coding going back to interpret code one of the things you can do at that point is to then take that original instruction it was stored elsewhere in the constant and put it back where it had been which  available the next or in time exactly and which so i think they say have pressley on ten twenty rather constant contains information about the original instruction precisely because in the intermediate format a strict instructions strin instruction is store after being placed over it whatever you want to call it is stored elsewhere in a constant is precisely because it's been displaced if it was still there all along you wanted need to remove it you want to need to take it out and put least and that's really what they are you on their own claim struction argument about what happens at the other point is worth i mean the basic points in this one just sort of walk through hopefully what's actually disclosed here and there are given the briefly x is to improve execution speed by replacing a conservative instructor interpreted code with with native code both trying to do exactly the same thing so it's no surprise that they end up doing  article the reason is that if i run a native if i run native code that's code that's actually been intended for the particular computer architecture i'm running so you can run it directly if you if you run a virtual machine encode the idea of the idea of the of that code code that can be run through a virtual machine software that will then be able to run on a computer architecture for the idea of a child all right once run anywhere but the thing is if you have your code that you have to run through the virtual machine in order to convert in order to make it run on any computer architecture that just tells additional processes and those additional processing steps slow things down so i think your question is yes but if you're going to convert to native  takes some processing steps two and in theory the others trade off there but you know as madison explains in iran as prototypes of test show it you know it turns out that it's significantly faster that the process of steps involved in running r i mean 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 over it replaced one either way the virtual can structure itself doesn't execute the underlying function of its attraction for branching condition or whatever else no matter what you have a virtual machine instruction on the left the points to execute look out on the right and that's true whether we're talking about it whether it's but what i meant is you have you have interpreted code which is a java code right once running or ok and then what you're doing is you translate some of that into native code meaning code that's needed for the computer architecture that you're running on right whatever that may be e i think it's common ground that the virtual machine instructions are on the are the ones on the lot of the that's the intermediate program code but the point is that the way that they work is that each of us does this as a self executing a timing and that term the machine doesn't translated as native and so the virtual machine instructions i think everyone agrees are on the last the point is simply that when we take when we translate one of the service routines on the right from interpreted code state interference of traction us to the new native code or we introduce a new instruction translated that among other things contains that line or would it be fair to say that in changing the virtual machine instructions for the left over to the simulated column you are transferring blocks of code from one column to the other and then manipulating that code in the process but that what process as it does not make any sense the second half of that's clearly correct the first half like for i'm i'm sorry i'm not entirely sure that the difference between this and in figure five is that the substitution is taking place at a different stage of the process and in the patent the solution is taking place while the interpret program is there and before there is any manipulation of that come where is magnussen it takes place as part of the process of manipulating the interpreted code over onto the just like over here the you translate instructions for voice instruction that produce from the same place where the go native instruction do we have an arrow that takes us over to snippets on and the snippet zone contains the executable code so in the pattern we're placing two different things right we're placing an instruction on the left and then on the right we are we are we are running and then that takes us over to the right to a block of executable native code that is run instead of what byte could you otherwise would have run was translated code but either way it's the same point that just as a logistical matter what you replaces it is a virtual machine instruction on the left that takes you over to a new block of native code that runs instead of interpretive code that otherwise would have run  that's why it sounded like to me just like you're talking about are we are removing things from the left or the right and vice versa and my answer to that would be no because in both of them there's something on the left something on the right and what's on the left stays on the left what's on the right stays on the right there's just a new instruction put in the which is a new block of translated native talks over on the right that's exactly what happened shows magnussen not written as a highly technical paper or how a technical audience magnussen doesn't do as much labeling on the left side and when it shows on the left side you have this is the interpreter program the intermediate program the stream of instructions and each of them contains a pointer to a block over on the right side which magazine calls either a service routine or a block of type of translated taxiways the same thing you have instruction the points you too you know implementing or executing code over on the right and we know that the equivalent over here if you want to see the p c pointer is the equivalent of like it was equivalent by code to we know it has been overwritten the translated or go native whatever you want to call it instruction because magnussen says that we can introduce a new instruction translated that will point to the new replacement block of code under that theory wouldn't it wouldn't be more correct to say that the simulation is actually the reference is one or more native machine instructions that can be executed so the claims of virtual machine instruction is something that represents a references executable code which is why in both  come back to the fact that enough that these m are found there's a very high level of skill in the art here and when it comes to reading a highly technical paper from the perspective of a person skilled in the art the examiner saxony which is the same fact finding the world i'd actually like to respond first the last thing that my friend said which he said that the board made the same factual findings as the examiner and that's not correct the board made a finding that there was  sure most of the discussion that was that just occurred explained how in figure four it shows that there is code native server for machine instructions on the left side that point to a block of compiled code on the right true that's that's entirely true 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 there's simply nothing in bags and the only thing to which they point is the sentence call that says we can introduce a new instruction while interesting deep plain meaning and introduces just to put into use we can there are two ways of doing this  doesn't appear to show overwriting so what what magnussen shows is that code was originally written and that when the code of the source code gets taken over into the interpreted code that at that point it goes part of the code gets interpreted into the native machine instructions part of it is already compiled compiled but but i picking up from a point that you made earlier what it doesn't show is the three step process it just shows the two steps 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 when it comes simply nothing in mag was what about i mean it's obvious that your friend on the other side doesn't doesn't think this is how it works but it is it possible that what magnussen is saying is that they interpret code points to the simulation which is where the virtual machine point that it could be generated runtime is actually a discussion of the block interpretation not the partial translation in the discussion of personal transactions nothing says this is a christian and there was a lot of discussion about this other instruction right or you can introduce an instruction that's well what version of nine point or is there that is something other than  deletion and replacement which is what i take you to mean you're going to still introduce a new instruction and the instruction could take as a parameter the lines of code just like it turns you can introduce a new instruction but that doesn't mean that that new instruction gets written on top of what is in that sense introduce has to mean something other than point to what introduced the plain meaning of introduced is to put into use so we're in rather than what madison is explaining is rather than having a pointer we're going to have a line of code called translator and that line of code called translator is going to have the parameters that are going to then point to the compiled code that the native code but nothing about that that just simply says returning it rather than using pointers we're going to use a new instruction called transfer except i guess i'm having my imagination and knowledge is too limited here and its structure that says go there and do this i take it to be a pointer insertion and they go from one to now one point five get above the number and before you you don't a race one or two and one point five is point we were discussing before about why if you don't overwrite in the specific sense of replacing deleting what was there and putting something else in its place why would use store the line of code where the instructions that you were why would you stuart well you know when you're not it i mean i agree that that code word somewhere is going to be replaced that's not true first of all the board did not talk i'm not asking about what the board fence i want you to try to explain to me why it really one would take the original line of code stored somewhere else unless you are overwriting it you wouldn't but that's not what magnussen teaches occurs magnussen does not show that a line of code gets stored somewhere else and that this is going to come back and be replaced that's in the find in the discussion of the exit routine and i do think it's important that the board didn't find that the exit routines occur because that would be an alternative ground that code and even if you think that medicine doesn't do the three steps again nothing about the exit routines shows that there was a new and that there's instruction that was stored and that's going to come back  there there expert's report is entirely conclusory it just it simply says in fact the point that they their experts reports discussion and this is important of what happens in those exit routines says that board with that with those instructions but if there's any doubt about that this is a factual finding that the board should make under the new construction the board only found under the old construction eighty nine the board says under the broad but reasonable interpretation of overwriting previously set forth we find this process replaces instructions within the intermediate code with new information in other words the board only takes a very high level of skill in the art and if that's the case and not something that the board should mind i'm dreaming and i want to come back to what i still don't understand ten twenty five ten twenty i gather this is your filing in the patent office and write this about and you say the reason for the talking about magnus and the reason for the original instruction being stored in constant is not one thing or another i take that to be a concession that the original restriction is in fact stored in constant and then we can argue about what well i think that that's a response assuming that's one thing but i took it that the factual pre supposition of the sentence is an agreement that the original instruction is in fact being stored two so you won't be surprised to learn that i did not follow that entire getting back to ten twenty yes let's just  you are saying something that either the original struction is stored in constant or for idle the minimum you're saying if it's stored in constant that does not imply presuppose necessitate that the regional instruction was replaced why not why would you none of them thing if it's not going away not going away in the in the original instruction well according to google's expert and that's  google's expert says that the assuming that that const sort of the original line of code all it does it over into the translated instructions that doesn't show that the translated instruction ever over wrote the original line  i guess i'm asking for something that's more about two of explanation at a minimum at the bottom of ten twenty you're saying if and the language is the original instruction is stored in constant there's a reason to do that even if you're not taking it out what is that reason can you make me it's understandable why you would store it somewhere if you haven't taken it out i think that the  that the interpreted program parts of it are not see it's just never changed and magnus that's right that's right magnussen appears to disclose that when you took the original source code and you create then the ensure that the virtual machine code that the with that 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  top rather than before and that's that's basically your argument that that doesn't satisfy pat that's right