So in this area will be finding that to reduce our dog.
How so the broken countries of this period this information and you can return using the get together
information function you're going to see all of these privileges we can finish the premises using this
we are my comment but in our next video will be adjusting this privileges using another function.
And here I can see I have this privilege assigned to but it is ever by default so that actually when
you will be enabling this essential shutdown, which Bouchard does not competence, we don't have this
privilege because it will disappear.
So this privilege from visible to enable you need to first down the privileges you have.
So that is going to be we are doing in this video.
So if you need to access this token handle before that, we will open this process our get our current
process handle so we can use this using process, not get current process that handle.
And the return date is a pointer.
The program will.
And we'll be using this open process to again function.
And it recites all at once.
You bet that you do the.
And the return type is bull.
And the first parameter is, uh, process handle.
That is a pointer.
And the second one is a desert axis.
With what axis?
You are on board when these are broken.
So I will be just grinding nine tokens.
So you can just use this broken query.
And the number for this is Doug inquiry the congestion.
So.
We consider this.
In the broken quite easy question this value.
And the pointer to this uh, uh, token handed sort of reference in the point that.
Our token handle.
So that's going to.
Open process token off.
The first one is the process, and that is the handle.
And the second one is this token query.
And the third one is the reference to first creating a pointer.
And passing this token and output will be so you can't ignore the written library and just put this
book resources equals to function.
So we have this token handle.
We need to get the information from this so we can do that using this function to get token information.
And the first parameter is the token handle, and the second parameter is that broken information class.
And if you go to this broken information class, this is the enum.
So it starts with one and the remaining values are 24.
Following the groups, etc. will be focusing on broken privileges structure.
Under the facade, you'll also see the structure.
And if you go to the token privileges.
Here we have.
The first one is the privilege count number of privileges a token.
And the second one is a real structure.
And that structure is rooted in attribute.
So this really is a unique REIT that content that is the long.
So if you go to these leading attributes.
So first, let's define this rule, the net structure and instead you have this idea really is a unique
value.
It contains the low part and the higher part.
It's just a long value.
So based on that, what we're going to do is we're going to pitch the tape of the pyramid, we hope.
So fortunate to get this structure.
So we need to create another structure that is a new idea.
So let's create that one.
And it contains the low part and the hyper.
So our researcher is successful.
Ah.
It's quite clear this route that routes.
And the question is of the type fluid structure annuity, and they're going to need the D-word.
Attributes.
So in these attributes, we'll be placing the value to who get this privilege and will.
So you see the slippery driver and this value is to.
So we had to find this new data structure.
So that's going to define our priority structure.
The first one is the privilege or the number of privileges we have.
And the second one is the idea of these structures.
So we need to master this one.
Martial arts and murder tied up by value added.
And also we need to define the science constant.
So it's constant at its 100 so interiority it will be I drew create this 100 members so 100 at our 400.
So it's like a maximum value.
If you take this to some one or two, whenever you have political like ten, so you can fit the ten
privileges I address into this, uh, uh, for you are six sides of it.
So we are declaring this hundred and we cannot changes are dynamically so we will be setting 100.
Now let's go.
And I think the TARDIS structure needs.
So you can also copy this.
Probably, you know.
You can collapse in this one.
The functionaries get to get information.
And the first value is that I can handle.
And the second one is the information class structure.
Remember information class and remember sorry, the object.
And the third one is the output.
Of this token information.
So whatever you specify here, you will get the pointer to this structure if you specify the token information
class dot token bridges.
When we getting the structure to that a pointer to this structure.
So here again the description.
And the next round is talking information then.
So we need to pass the length of this structure we want to query.
And now Poppy's output will also gives you the length of the structure.
So to get the length of our structure faster will be will be just carrying without this pointer zero.
Uh, to get the structure.
So we'll be cutting the second time because we know the length and we can return the structure.
Okay.
So let's go and call this one.
Get together in formation.
So the first thing, getting the token privileges.
Because we don't not yet.
Again, can see this is a dynamic tape.
We may expect uh, uh, five or six errors.
So notice, uh, so at our we don't know.
So that's why we are going to get the token information.
And the first one is that I can handle.
And the second one is our token information class.
That token privileges.
And a third one is we can just say 0.0 for no because we are not interested in getting any output.
We are interesting only getting output of the rental.
So we need to create a kind of prevalent, easy, constant zero and we passing this one here we rent.
And the reference to prevalent.
Now, if I go and print this problem, we should see actual number rather than zero.
And also it will be.
Using the cross handle.
That is from Canada, too.
Too, I think.
Yes.
So we cannot call this our handle does here automatically grow this we like to manage record but our
dog can handle this and manage it because we are using this order and process took it.
So at last we can grow sandy love dog can handle.
And that's their press.
Any key to continue?
So if I go and run this.
And here we can see the rent is 64.
So there is actually that structure.
Is there in this article.
So we need to pitch that information.
So we need to create a pointer to hold this metadata.
So let's.
Broken privileges.
Martial art and memory.
How much of a memory we want we want to hold?
Is this much of the problem?
I think we're not going to get any memory because we'll be getting in now.
But point.
So that changed.
We are not zero.
Get this.
This?
Ah, yes.
So it should be safe anywhere.
Get all the information off.
The first one is spoken handle.
And second one is as usual.
Our privileges.
Now.
We need to pass this.
BP.
The informal sector is the prevalent and the reference to prevalent.
So here we are sending an input and this one is output.
Now we can try to put into the program.
It should be the same as the previous.
So again, we got the pointer that is BP.
That is pointing to this structure broken.
And here you can see the first one is the privilege card.
The size is the for.
And remaining we don't know the size of its challenges.
64.
We can say that 60, but we don't know the size.
It may vary.
So what we're going to do is we are going to first pitch this prediction and then we'll move over this.
From this point, our plans for the end of this project and then we'll be printing out of this various.
So first, let's bring to the parade count how many priorities we have.
So we need to convert this point back to the sector we can use my pointer to.
Structure.
So pass that BP.
And the second one is the actual bypass token privileges.
So let's actually regard this as a deep point to.
So we got the structure and we can now put into that BP, that privilege column.
So if I go and run this and you can see we have the five privileges.
So these are the five privileges.
So we got the privilege gone and the next two.
How do you find the starting of this route?
All right.
So here you can see the first one is gone and the starting the from the not onwards, you have this
edit.
So are we going to use?
We can say first we are.
Starting point is equals two.
Actually, we need to see in knowing the period of we need to convert this pointer to the 64 bit and
then we need to add the size of this.
But it's count.
So let's do that.
So we hope that is pointing to the starting date for.
Let's first.
32.
You need to.
You can also write in the program that that was 64 bit systems.
So he's off.
You.
Okay.
So what we have done is we have converted this pointer to that and then we are adding the size of within
to get the pointer to the first member of the factory of this root that we can fix before it's because
of a change.
Right click on this and go to build and turn this to any see any CPR to see.
Now we have this starting point.
Now, what we're going to do is we are going.
Canvas this pointer pointing to the structure to actual structure.
So we can say marshal that pointer to.
Structure.
And then we need a starting point.
And that type of.
Rude.
And that's.
Sort it's it's every year religion.
And what I want to do is.
I want to do this every not.
We need to make this as public.
I want to print to the high part and the low part.
So let's gone from this.
And we have some values.
So the reserve function can't look up its name to convert these values into the corresponding name.
So it's corporate this.
The first is the system name.
So it's, uh, uh, now that you can pass the whole.
The second one is the pointer to the the lady with the priorities.
No, not a target system.
So we need to pass the pointer to this rouge structure.
So we can see Pointer to Louie.
And the third one is the name.
Oh.
So we can master this one.
Martial arts.
Unmanaged type dirt.
The string so wide casting we are going to say spring bear that.
And the last one is the rental.
The rental this spring builder too to get the output.
So if this Fed grow, it cannot output anything.
So we need to, uh, specify like 50 or a hundred to hold this matter.
So, of course, the name of the bridge cannot be more than 100.
So.
So friends in bigger doses.
So we'll be seen as equals to.
Hundred and then spring builder as be.
So before that, we need to convert this structure to the pointer because this is a structure.
We need to pass the pointer to this structure.
So martial art structure 2.0.
So we need to create a pointer in the PDR.
That's a rude pointer.
Martial arts etiquette sites.
So how much of the size you want to allocate that is?
Let's take this one.
So.
Martial art.
He's off.
And they don't really.
So they should do fine.
So what we're actually doing is we are getting the size of this large structure and then we are getting
the pointer to hold that much of the structure.
So whenever we convert this array to this pointer, you get this uh, uh, pointer so you can pass this
to this look up name w function.
So we are going to convert this structure to pointer.
So which vector we want to convert array not really comma.
And what we can do is the next is pointer.
The third parameter is true.
So we got this rule point structure.
So all we can do is begin to look up.
But name.
And the first one is that the sternum, which is note and the pointer to this which to reduce fluid
pointer.
And the third one is the output that is as meat.
And the last one is the length referencing.
So we are good to go.
We can bring the best builder to screen.
This will give us the progress.
We hope so that we are on this.
So let's go and run this.
And here you can see we got the prism and C shutdown privilege.
So that is the first privilege we have.
So we want to which are the privileges.
So what we can do is we can loop for this one.
So we have the starting point, right.
So how much we want to add everytime we want to add everytime.
The size of this.
I love that structure.
So that is what we're going to do now.
So far in I use equals to do zero.
Ah yes then.
So how do we know?
How do we help?
By using this pilot privilege card.
So this defines the number of police.
If you're if you don't if you don't put this privilege part and if you put like, say, 20 or 30, you
may get five privileges.
And along with the not because we have created this, uh, array as the 100, 100, that is.
So we're getting the real value.
That's right.
We want to limit our enumeration to this privilege count.
I press?
Press.
So how do I get the starting point so we can start being starting point to.
Starting point.
They're not going to 64 press.
So we can say these are the new temporary winter air.
So we need to get to the starting point better and how much we want to add every time we want to add.
The site martial outside of.
A bus route that routes.
So that much if you want if you skip this model the size you will get the pointer to the next edit.
So I can just simply say here I in because we are looping, we want to skip these many number of bytes.
So new in.
Buying better or so.
Make sure these brackets are okay.
So we are good to go.
Somewhere in the starting point or to be integer.
And then we are adding this much the size every time.
So changes to tempo for inter and you get the regulatory structure and we are printing them.
So I think we are good to go.
So let's run this.
Okay.
We got some.
We have got the.
One of the few privileges we did not get.
The remaining two we got the values.
But I was able to put into them.
So I think.
So let's first copy this.
To year.
I think this these sites are different, I guess.
So it's a martial art.
So he's off.
And they are to.
Let's put another brackets here.
So let's run this again.
I think that sends 232.
Still we are getting the different to where it is for this.
So I have found this error because of this unit.
So these are this high bar should be the integer, not b, I should not be the long because the long
Aug three takes eight bytes.
So we got that error again.
And now let's go and run this one.
And here we can see regard in that same order.
Down 1093 and the.
And rebranding these two.
So you can also see these are good values here.
The hard part is always zero and only the lower part us.
So that's it for this video.
So sorry for these mistakes.
These are stereotypes.
You need to ask these very carefully otherwise.
The point gets are we get to the wrong location and we converting that to structure and obviously we
get the wrong values.