Download "// Алгоритмизация #9 // Язык программирования //"
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FjYdpqRbTYko%252Fmaxresdefault.webp&w=1139&q=75)
Please wait. We're preparing links for easy ad-free video watching and downloading.
Table of contents
Similar videos from our catalog
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252F2YMrV-e5rZQ%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252F6lDPRmk-T-w%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FE9LXRcL8MpE%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FEAN54ZvkZaE%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FEVMqbEkR5dA%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FMnG_lre07mQ%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FVvhHbuCgLP4%252Fmaxresdefault.jpg&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FZQGu5yMfbq0%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252F_B-ELokM0DA%252Fmaxresdefault.webp&w=1139&q=75)
%3Aformat(webp)%2Fi.ytimg.com%252Fvi_webp%252FmSz1qdhMFCk%252Fmaxresdefault.webp&w=1139&q=75)
Video tags
Subtitles
Russian
00:00:02
on algorithmization00:00:03
In this video we will try to implement00:00:05
high level I language and use00:00:06
standard language tools00:00:07
C programming and accordingly00:00:10
At this stage we need to understand00:00:11
what are we going to move that is what00:00:13
will be our programming language and in00:00:15
Secondly, we need to understand what00:00:17
we should already have initial knowledge00:00:20
be well, let's start with the second one00:00:22
accordingly what initial00:00:23
knowledge we must first have this00:00:25
C programming language or its basics00:00:27
basics00:00:28
so that you simply understand the code you00:00:30
you write were able to analyze it00:00:32
read and implement later00:00:34
himself00:00:35
next second second thing we need00:00:38
this is a ton more than it will hold here00:00:40
future programming language in this00:00:42
case it will stay on virtual00:00:45
car, that is, he will not appear00:00:47
compile purely and it will not be00:00:49
purely interpreted language00:00:51
programming that is, what it will be00:00:53
do it will be broadcast on00:00:56
assembler on and representation of virtual00:00:58
machines followed by a virtual machine00:01:00
will compile this assembler into and00:01:02
representation into your byte code and00:01:05
later this byte code will already be00:01:08
capable accepted by the virtual machine and00:01:10
This is how our language is read00:01:13
programming will have as many as three00:01:15
stages the first stage is the broadcast then00:01:17
there is a transition from highland language to00:01:19
low-level second stage is00:01:21
compilation transition from low level00:01:24
language into machine code and the third stage is00:01:28
direct interpretation that is00:01:30
interpreted and machine code or00:01:33
bytecode in this case is already needed00:01:36
consider from some point of view00:01:37
machine code from what point of view is it00:01:39
byte to00:01:40
one way or another we will need00:01:42
virtual machines and virtual machine00:01:45
we realized the benefit in the previous00:01:47
video on algorithmization respectively and00:01:49
and you can easily download everything from Github00:01:52
I will directly leave the links in00:01:53
description but it’s worth telling us one thing00:01:57
this virtual machine has been modified00:02:00
my slightly modified then are contained here00:02:04
here lies the following firstly I00:02:08
I just chose a dollar sign here because00:02:10
that it was just a description of what we are00:02:13
we use addresses but since ours00:02:15
functions00:02:16
more precisely our instructions lot from Torah00:02:18
are pound are instructions00:02:22
which work with addresses then in this00:02:24
there is no longer any meaning as such00:02:26
accordingly in this case I am00:02:28
hit, yes of course stor could have done it earlier00:02:31
load specific values let's say00:02:34
so that is, let’s say they could be here00:02:37
some values and to some area00:02:38
in memory these values could be transferred00:02:40
but nevertheless, it’s better to do it now00:02:43
in this way, that is, so that we can00:02:47
only work with addresses using00:02:49
of these two instructions this is the second time00:02:52
I did it, changed the operand, it won't work00:02:54
that is, now the first arguments are not00:02:56
is the last one in the list and vice versa00:02:58
is the first that is, it is first00:03:00
it’s more convenient for a person and secondly it’s more convenient00:03:03
even the translator himself will be in00:03:05
further when we will be all this00:03:07
directly implement and00:03:09
the third thing that has changed here is simply00:03:12
added let's say00:03:15
interface part that is now it00:03:17
a completely separate application that is00:03:19
it can work without make-up files and00:03:22
accordingly in this case she00:03:24
takes the following arguments, that is00:03:26
she can accept00:03:27
argument build that is, compile and00:03:30
can accept the ran argument that is00:03:32
basically run it all00:03:34
the only change is still there00:03:36
of course a change regarding the shitty code00:03:40
let's just say when I was just cleaning this one00:03:42
the most shitty code and00:03:44
already provided the program in a better way00:03:47
order but somehow basic00:03:49
There are no such global changes here00:03:51
observed00:03:52
accordingly you can easily00:03:53
view previous videos00:03:56
analyze this code, go further00:03:59
here view this already code but also00:04:01
major changes as such in00:04:03
principle there will not be with this part we00:04:06
now we understand what will happen00:04:08
introduce00:04:10
programming language we will00:04:12
create00:04:13
it will be functional and even00:04:15
not just functional but clean00:04:17
functional programming languages00:04:18
it will tell you what's in it00:04:21
first there will be no such functions as input00:04:23
output i.e. standard water flow00:04:25
and there is no standard output stream in it00:04:27
this will definitely be a minus, that is, we00:04:29
we will not be able to write any acceptable text00:04:31
no number from the keyboard and place00:04:33
it immediately in the meaning of the language or vice versa00:04:37
derive some meaning from language00:04:41
directly the terminal we do this00:04:43
we can't do it then the question is00:04:45
appears how we can work then00:04:47
with this language the point here is that00:04:50
that he will appear00:04:51
in very mathematical language the essence of it00:04:53
lies in the fact that he will accept00:04:55
certain input values and00:04:57
spit out certain values on00:04:59
exit that is, he will stick00:05:01
some such concept of pure functions00:05:03
when it doesn't exist as such00:05:05
states accordingly do not exist00:05:07
no variables and if does not exist00:05:08
there are no cycles in change because00:05:10
that cycles are based on state and that's it00:05:15
arguments all meaning one way or another they00:05:18
will go from function to function then00:05:20
there will be a composition going on00:05:22
functions and ultimately from all this00:05:25
we will receive compositions of functions00:05:27
the final result the question may be00:05:30
what can we call a language?00:05:34
programming language programming00:05:35
if it doesn't even have cycles like us00:05:38
Let's say we implement some function00:05:40
Fibonacci factorial of greatest common00:05:42
divider even if taken purely00:05:44
mathematical functions and the point is that00:05:46
we will use recursion recursion00:05:48
there is an excellent option for cycles, they even00:05:51
are in fact above the set of these00:05:53
most cycles but here concluded in that00:05:56
that this tea minus will even be included in00:05:59
what we have00:06:00
functions will not be optimized for00:06:02
tail recursion is done for the purpose00:06:05
in order to simplify the language itself00:06:07
programming so that it can be00:06:09
easier to analyze differently if we00:06:10
created support for tail recursion00:06:13
this language would become more complex many times over00:06:16
this is one minus next 2 minus what00:06:20
concluded this is what is the only one00:06:23
in the language there will be only one data type this00:06:25
they are 32 t, that is, a 32-bit number00:06:28
there won't be any lines00:06:30
no big numbers allowed and so on00:06:33
further that is, it will be purely created on00:06:36
based on a virtual machine which00:06:38
only supports these 32-bit numbers00:06:40
and nothing more00:06:41
further functions will be in this language00:06:45
global, that is, it will not be possible to have one00:06:48
insert a function into another function and00:06:50
use it as a local function00:06:52
purely for one specific external00:06:55
functions00:06:56
that is, there is no such thing in this language either00:06:57
there will be but it will be local00:07:00
arguments00:07:01
that is, to allow an argument x where00:07:04
one function was not the same00:07:07
argument x to another function that is00:07:09
and we will be at least in this language00:07:12
will be implemented like this00:07:14
encapsulation or just local00:07:17
variable local data for00:07:20
a certain function here in principle00:07:22
This language will have such disadvantages but00:07:25
what are the advantages first of all?00:07:26
minimalism because of which it00:07:28
I tried to make it as small as possible but00:07:31
at the same time as functional as possible, well as00:07:34
if it weren't about a pun what is it00:07:36
is a functional language and we00:07:38
functional we will do next we will have00:07:42
mathematical clarity that is, like me00:07:44
said this before00:07:45
this language will adhere to the concept00:07:47
pure functions and the third plus is00:07:50
we compile and there is bytecode, that is, it00:07:52
is not purely interpretable00:07:54
language and it is created on the basis00:07:57
specific virtual machine and00:07:59
accordingly, he supports in fact00:08:02
its all the functions that exist in it00:08:04
and accordingly the final code00:08:08
compiled it will be obtained00:08:10
will be more accurately reproduced where00:08:12
faster than we interpret00:08:15
option, basically everything is like this00:08:18
the main criteria are the main advantages00:08:21
We have discussed the disadvantages of this language00:08:24
now let's start implementing00:08:25
well first of all right away00:08:29
let's copy the virtual machine and from00:08:33
and let's start directly00:08:36
develop like this here we write git clone00:08:39
then we indicate this and copy the class00:08:44
virtual machine directly00:08:46
copied then go to this00:08:47
compiling the virtual machine00:08:50
a library first of all is a library00:08:53
used by the virtual machine itself and00:08:55
Next we compile this myself00:09:01
Here's the program we're writing: Mike compiles00:09:04
we got the result back in this case00:09:06
the result is this factorial00:09:08
that is, in this case it’s simple00:09:09
provides an example of a program that00:09:13
capable of being launched by this very00:09:14
a virtual machine, or rather00:09:15
compile and then run00:09:17
here is the compiled version of it all in the end00:09:20
we received a binary file which00:09:22
is just this virtual00:09:23
with a car like this, that is, in this00:09:28
case we have two commands this00:09:30
let's compile and run now00:09:32
Let's copy this file g.p.00:09:36
virtual machines from copy everything here00:09:40
Now we need this file.00:09:42
this is the directory we already need00:09:45
no need, we just need this one here00:09:47
file to compile and00:09:48
run everything now what we do we00:09:51
create a file00:09:52
let's call our language as or others glorious as00:09:57
she is for the captive HIV this language he will00:10:01
functional and it will be, let's say,00:10:04
be based only on expressions then00:10:06
there will be a sheet of similar language00:10:08
programming or will have00:10:10
be a dialect of English so well00:10:13
let's create a file let's say considered .00:10:18
sen in this case he is talking about00:10:20
what language is this?00:10:22
programming you say that00:10:24
this is a translator of this language00:10:25
C programming says this00:10:27
that the implementation of this translator00:10:31
created in the C programming language00:10:33
how in principle and family we all created00:10:36
this file is now what we need00:10:37
make this file will be exactly00:10:40
just like in00:10:41
families will have a virtual machine00:10:43
interface file, that is, this file in00:10:48
sorrows and a new form will speak of00:10:50
then it would be more accurate to give the user well00:10:55
let's say this is the file we need00:10:57
necessary00:10:59
broadcast well, let’s say the build and further00:11:01
let's say main there. what file is it in?00:11:04
let's say mine. Navy is basically like this00:11:07
us this will happen let's all00:11:10
in this case we need to write00:11:12
use the library stage next00:11:14
we will also need00:11:16
shame on them to use the library00:11:18
and we will need to use00:11:19
with the string library we further define00:11:23
possible errors that may occur00:11:26
when broadcasting our program here00:11:30
we will have these mistakes00:11:32
6 and let's define them, that is, etc.00:11:35
further we write mouths here as well00:11:39
root tm here we first define that00:11:42
that there is no error00:11:44
then we determine what was indicated and00:11:49
not a certain number of arguments00:11:51
namely what is acceptable in this case00:11:54
when we wrote let's say I thought00:11:58
build and mine.00:12:00
[music]00:12:02
in this case we need a minimum00:12:04
three arguments if there are no three arguments00:12:07
then we get this error even for us00:12:10
there will also be error commands in this00:12:15
case it will arise00:12:19
when we when was not determined00:12:22
let's say some other team00:12:24
we will have a team for this place next00:12:26
more00:12:27
be determined by i'm open error00:12:31
this is when the file is not opened for reading00:12:34
there is, accordingly, a more powerful file and the00:12:36
main. it will be determined by us too00:12:38
out open air error00:12:40
this error will be determined if we do not00:12:44
were able to open the touch and create a file00:12:46
which will already be broadcast00:12:49
file, that is, represent yourself with00:12:52
engineering code here00:12:54
and then the last mistake will be00:12:56
translate.ru00:12:58
well this error will represent00:13:00
from oneself in fact incorrectness00:13:04
translation of the code in this case there00:13:07
May be there may be various errors allowed in00:13:12
the junction was supposed to be a lot00:13:14
values one way or another00:13:16
the virtual machine will return us an error and00:13:18
we made this mistake in front of him as a broadcast, well00:13:21
means very much from the virtual machine here00:13:25
I already forgot about the virtual machine then00:13:26
it doesn't depend it depends on itself00:13:29
broadcasts, that is, we will allow00:13:31
write a certain command incorrectly00:13:33
And00:13:36
well, let's say there you know, let's skip it00:13:38
some bracket came out and so on00:13:39
in the end you see this is the mistake00:13:41
broadcasts, we figured it out00:13:43
now we need to determine how these00:13:48
errors will be named00:13:50
static then we write const char00:13:56
here we write airus errors in this case00:14:00
this is Hernan and here we write firstly she00:14:04
holds but it is correspondingly empty00:14:06
line00:14:07
then we write arc one take or queen00:14:12
error is directly v.n. arks00:14:15
less than 3 then we will have teams I will give birth00:14:19
these are direct commands further in open00:14:28
air00:14:29
but here we just write open input file00:14:33
further here also out put your open00:14:37
output file and the last error is00:14:41
broadcast translate.ru translate00:14:45
file we all sorted it out now what do we have00:14:49
we must first we must00:14:51
be one interface function which00:14:54
will be responsible for the broadcast highly00:14:55
language level to low level in this00:14:58
case we will write and 8 t that is the code00:15:00
errors further read tol we will have00:15:04
this is called but in this case source00:15:06
0 here we write00:15:07
where the result will be placed and from where00:15:11
the code will be read, that is, a Russian cat00:15:16
will we need to speak00:15:18
implement two more functions but they will00:15:23
And appear only for this file00:15:25
functions and they will have the following00:15:28
view firstly this is the translate resource function00:15:33
it will accept names instead of threads00:15:37
files that is const00:15:39
further damn and here output of and far from00:15:43
char input f and the second function it will be00:15:49
just a representation of help, how about it00:15:54
let's say when we describe it as virtual00:15:56
machines in this way is strong00:15:58
we were given this look like this00:16:02
help info00:16:03
we will have the same principle, let's00:16:05
let's try to do this00:16:07
function should return us a string and00:16:09
she doesn't accept anything, it's all us00:16:13
created now we need to create00:16:16
the function we write was given to them here arks00:16:21
then we write all these arguments const00:16:24
then ark here we immediately return 0 and00:16:32
here first of all we will do00:16:35
require the charred code will equal00:16:39
we initially have a lie00:16:40
that is, no error was detected00:16:44
further if the number of arguments is less00:16:48
three then display this same error red00:16:51
hat equals ark damn well in this case00:16:54
in case don't kick me don't throw me00:16:57
Are slippers something like that?00:16:59
I'll use Klaus's head and00:17:01
here we will indicate everything and when Klaus00:17:05
we indicated here klaus here to us00:17:07
it is necessary to analyze the code if red00:17:11
hot will not equal our hero this00:17:15
will report an error accordingly00:17:16
Well, and accordingly we00:17:18
output to standard stream00:17:21
error output and here we will write00:17:23
the next one like this and so on00:17:26
also dreams here we write first what00:17:32
the error was detected i.e. red hot and00:17:35
secondly, we write help, that’s basically it00:17:40
All00:17:41
further we need here more00:17:43
determine what team we need00:17:46
arrived but in this case we just00:17:48
do washing m.p.00:17:51
further or kv-1 and here we compare00:17:55
build if bells is zero then00:17:57
we need to do the following differently00:18:00
If00:18:01
build was not detected then it says00:18:03
that the command was not found let's go00:18:07
then if the number of arguments00:18:09
greater than or equal to 5 and that is in00:18:15
in this case greater than or equal to five00:18:17
this means that here let's00:18:19
copy this says that here00:18:23
another such argument is worth windows this is00:18:26
there is output file & main . what kind of navy00:18:31
it is the file that is needed00:18:33
compare 5 arguments we have00:18:35
and then what we do is we compare00:18:37
washing m.p.00:18:38
then or kv-3 and compare with minus it00:18:44
if so then we do the following00:18:46
action00:18:47
that is, we call the translate function00:18:50
become here source tags00:18:54
source yes then we specify the file arch in 400:19:01
then specify the input file and here00:19:06
let's specify the error more precisely00:19:09
error code in red hot and here it is00:19:14
this code is the most transferable red hot00:19:19
this way we will compile our00:19:21
directly the program00:19:23
more precisely, we compile from broadcast differently00:19:26
what do we do if this one is not specified?00:19:29
the very argument is that it will talk about00:19:31
what we will use00:19:33
the standard name in this case in00:19:35
as standard name we will make00:19:37
main. vms then specify the file and00:19:41
indicate the error code in this case as well00:19:45
use the head wire ucoz everything now00:19:48
we only need to determine these00:19:50
two extern functions will be derived from00:19:52
another file00:19:54
so now in this case, come on00:19:59
first we implement help it's easier00:20:01
Total00:20:02
statics further char help in this case00:20:06
writer00:20:07
write next write next run00:20:12
let's get this structure in its entirety right away00:20:14
let's take it like this, then like this00:20:25
so let's do one two three 4 5 here 600:20:32
0 what will we do and this is what we will try00:20:35
It’s more accurate to give the company right away though00:20:41
we take this before complain and ran and write00:20:44
we gave00:20:46
here it will be the second action and here00:20:48
the first action will be00:20:50
translate trance but in this case too00:20:54
we indicate instead of seven counted00:20:57
and here we indicate main navs here in00:21:00
in principle, what is not main navy e-mail floor00:21:03
that is, as our programming language00:21:05
everything is called with this we00:21:08
but here, in principle, you still need dc00:21:11
of course put it everywhere let's do it00:21:13
let's do it and here they are everywhere like this00:21:18
brackets brackets00:21:23
bracket here too. , that's all for us now00:21:26
you need to define a translate file00:21:29
source let's try to do this and00:21:33
here we just need to open00:21:36
these two files are basically everything00:21:38
input equals fill up in next00:21:41
we indicate to them here and then we indicate00:21:45
reading and if the path was zero00:21:50
then return it more precisely yes here red hot00:21:56
will equal i'm open error and00:21:59
will return just exit from functions yes I00:22:03
we will do exactly the same with but then00:22:06
here we write output further here00:22:10
out put off next here output here out00:22:15
a pen error, then we call this one00:22:20
function 1 equals repton source00:22:26
send here the spider out put and send00:22:29
here and here by the way in00:22:32
you need to write in and now further with in00:22:39
in this case we now need00:22:40
close these files in claus put input and00:22:44
then f claus output we put it and00:22:49
accordingly we check if the rice is not00:22:53
equals zero this indicates an error00:22:56
that is, this function should give us00:22:58
return 0 to fact if returned mute then00:23:02
accordingly we have00:23:03
rap code will be equal to translate.ru00:23:06
Well, basically everything is like this00:23:09
wrote the first part00:23:11
the question is about the interface component00:23:14
now we need to define everything00:23:17
this very function and let's do it00:23:19
let's try to do it in this case for00:23:21
we already have definitions of this function00:23:23
you need to create a separate file00:23:25
which will be broadcast like this00:23:29
go here and create a file under00:23:32
Let's say the name is ride at all.00:23:36
everything is like this and so on00:23:40
what we're doing here first of all let's get started00:23:42
let's connect all the libraries we00:23:44
we will use these otherwise this00:23:46
first stage library next this00:23:48
library etc.00:23:49
int is then a library for working with00:23:51
in strings this is a library00:23:54
count . we will need more00:23:58
one let's say third-party library00:24:00
you can call it so let's do it00:24:02
let's try to create a folder here x silver00:24:06
we'll write here and we need it00:24:08
copy this stack, that is, the stack.00:24:11
systick. let's go on and on00:24:13
let's try to do it right away00:24:15
go to Vertova machines further exquisit00:24:18
and from here we will copy all this and00:24:21
Let's move it to excel and that's all in theory00:24:26
moved00:24:28
then sit xtreme vs yes moved everything00:24:31
It's just not displayed here, that's okay00:24:34
now we delete everything first00:24:37
hash tables of hashtags because they help us00:24:41
not needed then delete accordingly00:24:43
all the trees00:24:44
because we don't need them we don't need them00:24:46
you just need a step on the facts further like this00:24:55
let's get virtual machines here right away00:25:02
ritual it's me with ter00:25:05
ok let's get the file here in a moment00:25:07
Let's edit the Mike file further first00:25:11
we will remove 3 and hashtab from here00:25:13
0 here also 3 and delete the hashtag here00:25:18
also delete, then save everything and now00:25:23
let's compile everything we all compile and00:25:26
Now we have an excel file. He00:25:29
which will be used for our00:25:32
directly goals and00:25:33
accordingly in this case we can00:25:34
let's even write another mike file00:25:38
let's try to do it here in this case00:25:40
will00:25:41
there will be the following arguments firstly this00:25:43
bill secondly and let's ram right away00:25:46
we'll write, I'll take it00:25:47
what will he take first?00:25:49
in this case we need00:25:50
use build for yourself of course00:25:53
we indicate00:25:54
current and considered considered00:25:57
given build here we indicate00:26:01
the original file, that is, my . wolf00:26:04
further minus about mine. The Danish Navy is here for us00:26:07
it is necessary to indicate the wine with mine. V00:26:10
m.s. well, they gave it accordingly00:26:12
the virtual machine needs this all00:26:14
run main.00:26:15
v.n. and in this way here00:26:19
By the way, let's do this rand here too00:26:24
default operations we will write as default00:26:27
here is the default built from here by the way00:26:35
Of course you can do it a little differently00:26:38
in fact, that is, we can do this00:26:40
so on here00:26:42
register Jessie compiling further00:26:45
mine. more precisely we do not have. SEO considered . sim further00:26:49
excel excel ip .00:26:52
he considered this a minus in principle00:26:57
here you can even do it like this00:26:59
still equals jessie and here files00:27:04
equals these files we indicate here00:27:10
right away that we use some00:27:12
files are they moving here to whether we are here00:27:15
must be indicated by mine .00:27:18
further here we indicate considered with a Jew00:27:22
and here, in principle,00:27:27
we wrote everything this way00:27:32
a fairly simple script purely for00:27:35
compilation now what are we doing let's00:27:38
Let's write it down again here00:27:39
deleted it all in cloud stadio.00:27:43
further incubus std im. right up to her in the cloud00:27:50
string . consider h&m club00:27:53
retinue as much as but further of course00:27:57
is included in the include library itself00:27:59
excel and pc00:28:00
further text more precisely further stack.00:28:04
We've sorted it all out, now what?00:28:07
we will do more first to us00:28:10
it is necessary to identify three main00:28:13
constants first 1 constant is the stack00:28:15
says stack site will talk about that00:28:17
How many00:28:18
maximum number of arguments00:28:20
valid functions in this case00:28:22
let's let this be equal to 1600:28:24
Next we will change the buff site, that is, we will00:28:31
we'll use one of them00:28:33
use a smaller measure, let's say 25600:28:36
in this case, baksis is more accurately a buffer00:28:41
there will be a class exactly all different00:28:44
functions of all different variables and so on00:28:46
further this is purely temporary00:28:49
storage and accordingly in this00:28:52
In this case, 250 ml will be in principle00:28:54
enough00:28:55
let's go further further we need00:28:57
determine both the number of instructions and00:29:00
in this case we will have 4 of them00:29:02
instructions to us and give them right away00:29:04
we will define pdf for us and here we write ems00:29:10
instruction then here also instruction00:29:13
pace and in this case, first of all, we00:29:16
there will be a define instruction00:29:20
this instruction will say that00:29:24
so by the way here I am for us yes these are instructions00:29:30
will talk about creation00:29:32
functions directly if you know00:29:35
roughly what language is like00:29:37
lisp programming00:29:38
well, let's say some kind00:29:40
dialect scheme and common lisp00:29:43
then you most likely know what it is00:29:45
define is just a function definition00:29:47
as in a programming language00:29:48
python dev this function definition is here00:29:51
example the same thing further we should00:29:54
be another if instruction00:29:57
we write them but this instruction is the limit for00:29:59
in order to actually create threads00:30:03
is we can move from one to00:30:06
I act to another and so on and00:30:08
accordingly, thanks to these already 200:30:10
we can create instructions after the fact00:30:12
full-fledged programming language00:30:13
no but we will make one more boost00:30:16
stage we will create two more instructions in00:30:19
first, these are instructions in the cloud, let's00:30:22
so let's write the instruction code00:30:24
this instruction will load us00:30:26
other files are the same, that is, the same00:30:31
programming languages that we00:30:33
we will implement it and then we should have more00:30:35
one instruction called loop00:30:37
instruction it will load into itself00:30:39
assembler files and use them in00:30:42
high-level environment, well, let's say00:30:45
we can implement00:30:46
addition instruction as a function because00:30:50
which is based on a high level language00:30:53
this instruction will not be possible in any way00:30:55
implement accordingly we implement00:30:57
at a low level this addition instruction00:30:59
further and we will tinker into the highland language and00:31:03
we will use it as usual00:31:05
function of this language, this is the approach we take00:31:09
we will use it after the fact and00:31:10
accordingly, any addition operation00:31:12
multiplication and division subtraction she will00:31:15
the default is normal functions then00:31:17
it can also be transferred to00:31:19
her arguments can also be00:31:21
return as the result of another function00:31:23
that is, it will not be any different from00:31:27
the usual functions that we follow00:31:29
we will implement it using this00:31:30
high level programming language00:31:32
that's all, this is how we are00:31:35
we implemented basically 4 instructions and00:31:37
we will write the last instruction as a pass00:31:39
instruction00:31:40
just like a virtual machine does not00:31:42
we did the pass code, basically everything is now00:31:47
what do we need to do00:31:48
it is also necessary to determine all these00:31:52
instructions write const chart further here00:31:55
we are writing00:31:56
from capital letter instruction onwards00:31:59
here we write00:32:00
in scary we were given here define will00:32:05
look like just define further iv00:32:11
instruction will look exactly the same00:32:12
as further in cloud instruction will be00:32:16
look like hawking loud00:32:18
and lot instruction will look like00:32:21
lord everyone in this way so opportune00:32:26
I forgot here:00:32:28
so now we need to do00:32:31
following00:32:32
Well, in principle, we can now immediately00:32:36
start implementing this00:32:39
interface function let's immediately00:32:41
imported so this is the exact function00:32:45
imported and what will it do with us?00:32:48
first of all we need00:32:50
initialize the entry point to00:32:52
program, that is, in this case our00:32:54
programming language touch our dialects00:32:56
language sheet will suggest a point00:32:58
input as let's say the main function00:33:00
in the C programming language in the language00:33:02
programming column there in the language00:33:04
programming husky not so much more this00:33:05
this will be our entry point into the program00:33:08
function we directly but also let's00:33:10
let’s initialize this, that is, in this00:33:12
case we write a new function and no00:33:15
entry here we will pass on our experience in this00:33:19
in case let's just write it00:33:21
there will be a static fractional function00:33:23
and here and there is no entry file output well and in00:33:29
in this case we write in our00:33:34
directly file directly label00:33:36
further start what is it directly00:33:40
start all marks00:33:43
further here we will write immediately here00:33:48
in this way mascara 0 that is this00:33:51
initial let's say argument00:33:53
because the original argument00:33:56
will always be for all functions even if00:33:58
the function doesn't take anything into itself00:34:01
there is if she doesn't take any00:34:02
arguments as quality and default00:34:05
the argument is always a function00:34:07
there is always at least one argument for00:34:11
why is this done because every00:34:12
function she always comes back00:34:14
any result even the main function00:34:15
it will return a the result and accordingly00:34:18
this result will be the decisive functions00:34:20
it is worth saying it does not apply to00:34:23
to some separate class of some00:34:25
you know there are no special functions for sure00:34:28
will also be implemented like everyone else00:34:30
other functions and exactly the same00:34:31
accept arguments, that is, in00:34:33
in this case, this is the argument she00:34:35
accepted and will also return the argument in the given00:34:39
In our concept there will be no such00:34:40
functions that do not accept anything and00:34:42
they don't return anything they just won't00:34:44
Accordingly, this is such a pure concept00:34:47
pure functions we go further further here we00:34:51
indicate coleman hill and then this00:34:56
the function will directly return00:34:57
result here in this area00:34:58
memory and accordingly this result00:35:01
we have to pay to put her in00:35:04
virtual machine local variable00:35:07
and then we need to output this00:35:09
the result is to stop working00:35:14
the translator is more precise than the translator00:35:16
stop the interpreter00:35:18
virtual machine and output the result and00:35:20
silk is basically all of us in this00:35:23
case we can still do we hear everything00:35:27
this is the first thing we need to do00:35:30
now the second one is already immediate00:35:32
interpretation of all the code we00:35:35
wrote00:35:36
Well, let's write the code right away00:35:37
some in this case let us00:35:39
will be acceptable. regiment so sorry00:35:44
Let's rename it a little in this case too00:35:48
what will it roughly look like?00:35:49
first we implement let's function00:35:52
main let's load the syntax here00:35:56
We'll upload the diagrams further here00:36:00
the simplest program let's say 2 + 3 in00:36:03
As a result, we should output00:36:05
print the number 50 it is worth saying what it has00:36:08
we have no function plus that is our language00:36:12
no default programming00:36:14
understands what this one imagines00:36:15
the most plus accordingly necessary00:36:17
will implement even more accurately load00:36:20
assembly code which will be just00:36:23
imagine yourself this very operation00:36:25
plus, accordingly in this case,00:36:27
there will be some more of us00:36:30
let's directory here00:36:31
new folder in cloud and Denmark in this00:36:34
directory we will create another one00:36:36
directory called like00:36:40
I have an IUD, it doesn’t work here, I have this one00:36:44
yourself00:36:45
let's go to in cloud here00:36:52
then let's move on to the Navy and here we are00:36:54
let's create a file from . navy and give00:37:00
so we'll try it later00:37:01
he will edit accordingly00:37:03
connect in cloud. further in m son.00:37:09
vms so we connected the function00:37:13
plus and in the end we can already do it00:37:15
use this is basically the minimum00:37:18
code for this language00:37:20
it is also worth saying that every every00:37:23
expression00:37:24
it always accepts a function and arguments00:37:28
there is nothing that doesn't happen here00:37:31
there won't be any here00:37:33
let's say functions like this00:37:34
this can't happen or something like this00:37:37
it can't be00:37:39
from similar programming languages here00:37:42
This syntax is quite acceptable, that is00:37:44
in the end it will come back to us in others more precisely00:37:48
in languages the construction will return, but we will have it00:37:50
we will do it a little differently like this00:37:52
way, that is, we will do some00:37:55
operation is allowed 0 so that the result is not00:37:57
changed and let's print three00:37:58
that is, necessarily always necessarily00:38:01
at least some00:38:03
let's say the function in fact we can00:38:06
write a function in assembly language00:38:08
which will simply return us this very00:38:09
let us give the function and it will return more precisely00:38:13
value and in the end it will simply return this00:38:15
the top three one way or another as00:38:17
first argument is always required00:38:21
functions we figured it all out00:38:23
let's go back to the source code00:38:26
this is the file we will basically use00:38:29
broadcast to them and, accordingly, what00:38:31
we next do we do read the crowds00:38:34
internal, let's say ritual function00:38:37
source and enter output here and00:38:40
enter input everything now give it00:38:43
let's try to implement static further an-800:38:47
so-called00:38:48
then we write ride the source here we write00:38:52
file, by the way, let's have this function00:38:55
let's do it straight up as an externa function00:39:01
this is how the file is received here00:39:06
input and00:39:07
more precisely, let's copy the question now00:39:13
let's go to the valleys first we need00:39:16
read character by character all this code which00:39:20
we will write and in the end we should also00:39:24
return some result00:39:25
Initially the result will be equal to00:39:27
zero, but as we analyze the code we00:39:31
we will discover or not discover that the result00:39:34
will be something else, well00:39:37
we will count directly00:39:38
character by character ch equals then we write g00:39:41
from where we will read this input and while00:39:43
does not equal the end of the files further that we00:39:47
do we immediately return this ngc00:39:51
ch into the stream from which we read00:39:57
this must be done because00:40:00
subsequent functions they will be00:40:01
analyze start and end 7 characters00:40:05
Well, in this case the symbol of the beginning is00:40:07
the opening bracket character at the end is00:40:09
closing parenthesis when we read that00:40:13
this symbol has simply been missed for us00:40:15
needs to be done on these translators00:40:18
so that this symbol comes back00:40:19
but basically we are so we00:40:21
done00:40:22
let's go further next we have to call00:40:24
the following function called pars cop00:40:27
it will already accept its output00:40:30
further it will accept input and into00:40:33
in this case she will accept herself00:40:34
stack nose because initially we will say00:40:37
there won't be any00:40:40
further we will have this function at the junction00:40:43
on tachai met us arguments are stored00:40:46
as you remember, next we will have root00:40:50
directories but initially there is none00:40:53
no root directory00:40:54
what is he talking about, let's say00:40:56
add + 200:40:59
more precisely 2 plus 3 and in the end here we have00:41:02
definite result and which one is pink00:41:04
the directory for this expression is gelik00:41:06
Itachi doesn't have a directory function it's00:41:08
main function and no matter how deep we go00:41:10
there let's say you know here we can still00:41:12
let's say 522, then let's say 11 here00:41:18
and so on we will always have labor00:41:20
function this is mine by the way it’s worth saying00:41:22
that the difference between our language and all00:41:26
the rest of the faces of languages is what we are not00:41:29
we can do it like this, that is, we have00:41:31
there must be a final one00:41:33
number of arguments in this case00:41:35
this is exactly the same quality00:41:37
simplification that is, not to do there00:41:39
some individual cases and so on we00:41:41
we put everything under one criterion00:41:44
that is, under one criterion of functions and not00:41:46
Moreover, we are not trying to do the same00:41:48
make more advanced languages00:41:50
trying to fix a certain error00:41:51
We are not trying to optimize this language00:41:53
and then I'm all with this stage we too00:41:55
we figured it out now let's move on to this00:41:59
case we also need a pointer00:42:01
two arguments the first argument is00:42:03
nesting, that is, let's say that00:42:05
mobility is understood here, let's say00:42:07
nesting starts with with00:42:12
the number of joints, well, let’s say here00:42:14
us00:42:15
argument x cannot be its functions00:42:18
but nevertheless here are the arguments x and00:42:21
nesting starting from one if here00:42:24
y scissors starts with 2 what00:42:26
represents itself nesting00:42:29
nesting it will simply be00:42:31
signal about what00:42:32
quantity in00:42:34
assembler listing we need00:42:37
move to take this one00:42:39
argument well, let's say in this case x00:42:41
how much do we need to move from00:42:44
current position reading00:42:45
to get this value but in this00:42:48
In this case, this is exactly the situation, let’s say00:42:51
so let's go further and the last argument is00:42:54
count that is, this is the counter the counter will be00:42:57
analyze exactly you know jump that is00:43:00
let's say jump mole jump one jump 2 and00:43:03
so on, that is, where exactly should we go00:43:05
necessary assembler new listing then00:43:08
there is just go that is either this00:43:11
there will be a conditional transition or an unconditional transition00:43:12
it doesn't matter here00:43:13
we just need to generate labels00:43:16
labels can be generated using00:43:18
using a counter00:43:19
there let's say the main counter is mine, that is00:43:24
label00:43:25
play balmain 0 next we will have the label00:43:28
main 1 will also be further00:43:31
label let's say main two and so on and in00:43:35
in the end we have if it is here00:43:37
certain nested conditions are allowed00:43:40
if i've i've and so on we will have00:43:42
generated thanks to a counter such00:43:44
numbers that is 0 1 2 3 4 5 and so on00:43:48
everyone with this in this case we00:43:50
figured it out and accordingly this00:43:53
the function will have to do the following00:43:55
if rest is not equal to zero that is00:43:59
accordingly, if we received at00:44:00
parsing a certain error then we have00:44:02
the same error should return00:44:04
after all, he grew up and, in principle, we immediately00:44:06
let's finish reading because further00:44:08
there will be no meaningful reading anymore because00:44:10
that an error has been detected00:44:12
and accordingly all subsequent00:44:14
actions are not just undefined00:44:15
that is, they can either cause an error like this00:44:18
and not cause an error and accordingly00:44:19
better just don't do anything right away00:44:23
stop working and report an error00:44:25
we are all with this directly00:44:28
we figured it out now let's move on00:44:29
Accordingly, it is necessary to understand that00:44:32
is this function of pairs00:44:33
cattle and let's try to do it00:44:39
let's declare right here that is00:44:42
static we write further we write and 8 t further00:44:46
write a couple score00:44:48
let's get her, yeah, basically, couples scott00:44:50
further here we have00:44:55
file output file input exactly the same00:44:58
further accepted here00:45:01
stack accepted00:45:03
further arguments we take here00:45:08
directory root, more precisely directory a00:45:11
root function00:45:12
Next we accept nesting00:45:15
instinct let's call it00:45:16
and we accept this very counter00:45:20
count everything in this way and00:45:23
now we will try this function00:45:26
implement here00:45:30
she first she what does she first00:45:37
must skip all possible00:45:40
comments that is the groove cummins and00:45:44
space, that is, there may be spaces00:45:47
a few there you know limitless00:45:49
number of spaces and we can also00:45:51
be certain comments00:45:52
your comments will begin with .00:45:56
comma like this00:45:59
accordingly we should skip00:46:01
comments and space space is input00:46:05
Well, in principle, this function will be00:46:09
implemented as follows let's do it00:46:10
we will immediately implement strikes further and pass00:46:15
cummins and in this case the input file00:46:20
further here00:46:21
int ch further while sage equals ges00:46:25
input does not equal j do next00:46:30
next we check if it is a space00:46:33
then we need to skip that is00:46:38
continue00:46:39
Next we need to understand if ch00:46:42
equalize symbols00:46:43
. a comma then we need00:46:46
skip the entire next line00:46:47
that is, we make the following comment00:46:50
and in this case ch we further do00:46:53
input and here we all do cantinas and00:46:55
accordingly, if you did not have any00:46:58
space no comment accordingly we00:47:00
we interrupt this cycle and, in principle, everything and00:47:03
return ch, let's give this function00:47:08
Let’s also write down that is, in this case00:47:09
static and was coming00:47:14
here we take the current symbol00:47:16
then inter is accepted further if ch00:47:23
equals ; then what are we doing we will00:47:29
to reach the end, that is, to tears00:47:33
not yet00:47:35
file endings sash equals input and in00:47:41
basically everything is far away00:47:43
let's return like this now00:47:47
what next we will do first of all00:47:51
you need to understand which symbol is on which00:47:54
we stopped if these are symbols of WWII00:47:56
speaks of the end of the file, that is, the writer00:47:58
0 further if this character is not equal to the beginning00:48:04
that is, the beginning of reading00:48:06
expressions then this indicates an error00:48:09
re-therm 1 that is, this means not a symbol00:48:13
space means not a comment00:48:15
accordingly, if this is not the beginning of reading00:48:18
accordingly it's something else00:48:19
symbol that expresses an error everything00:48:23
Next we create another door, two arrays00:48:28
in fact, the procedure is a reading procedure00:48:31
current in this very expression but00:48:33
Let's say in this expression the current00:48:35
the procedure is a plus by the way in papal rice00:48:39
terminology00:48:40
often functions are not named as functions but00:48:42
how are the procedures00:48:43
such an ironic component because00:48:46
that in C language this is actually a procedure but00:48:48
referred to as functions in down language00:48:50
on the contrary, that is00:48:51
are called procedures are in fact00:48:54
functions one way or another let's00:48:58
we can call it different things like this00:49:01
First of all, we create a procedure on00:49:04
in this case we update this and further00:49:07
create a buffer, that is, a temporary buffer00:49:11
in this case, the site will be exactly the same00:49:13
and reset it exactly the same way00:49:14
Next we need to read from input00:49:19
on procedure name, that is, it is possible00:49:23
done using the read function00:49:25
simple00:49:27
then we make them fun then where do we go00:49:30
we will place and what is the size in says after that what we00:49:35
we will have to do we will have to determine00:49:38
what we will have to determine00:49:40
instructions, that is, does this apply?00:49:43
here is the procedure00:49:44
here are these instructions if it doesn’t apply00:49:48
then let's return the seal of that return00:49:51
pass instruction otherwise return some00:49:54
one of these00:49:55
well, this can be done accordingly00:49:59
as follows, that is, in this00:50:01
in case of surgery or instructions00:50:03
equals ripd df about well, that is, operations00:50:08
default and read from buffer00:50:11
Well, in this case, let's try00:50:13
implement these two functions like this00:50:17
here let's go straight away00:50:18
let's try to implement that is static00:50:20
further damn it here rip percent let u00:50:27
there will be us then this takes of course input00:50:29
then takes the buffer ball buffer and00:50:32
takes say'st size and is acceptable here00:50:35
site in this case what we will have00:50:38
we will do exactly the same00:50:39
read to the limit00:50:41
that is, we will skip all characters00:50:43
space all characters00:50:45
comments and so on until we00:50:47
let's get to some other symbol00:50:49
Next we will do the following with us00:50:53
will be directly00:50:55
counter that is, thanks to which we00:50:57
we will place all the characters in the buffer further00:50:59
Bye00:51:00
and the character is not equal to the spaces in the given00:51:04
case and while and in less says -1 and00:51:10
ch does not equal the start character and00:51:15
ch does not equal the end character then we are in00:51:19
we always put these same values in the buffer00:51:21
we make a workshop and then here ch00:51:24
equals dc input, that is, take this00:51:28
the symbol itself and place it again in00:51:32
buffer at the next iteration further and further00:51:35
we compare if ch equals character00:51:37
start or ch equals end character00:51:40
we need to bring these back00:51:42
characters into the stream from which we read then00:51:46
there is he gates sage and they gave them everything here00:51:50
entered and now we return the buffer00:51:52
this way now let's try00:51:54
implement the relapse function let's00:51:57
static next instruction tempo00:52:01
reed is defaulted and she only accepts00:52:05
line that is, this very buffer in fact00:52:07
let's put it on the buffer themselves further00:52:10
what are we doing first of all we need00:52:14
just go through all these instructions00:52:16
let's say the here00:52:18
and equals zero or less instruction00:52:22
us it here + + and further if strcomp in00:52:31
in this case we will write it as a buffer and in00:52:36
in this case the instruction will be00:52:39
equal to zero then return the record and in00:52:43
in this case, how we do extraction and00:52:46
everything is fine, otherwise we will have a pass back in fact00:52:50
instruction00:52:51
everything is like this, we'll say this00:52:56
implemented these two operations now we00:52:59
we need to go further what is here now00:53:01
we need to implement00:53:03
after we got the operation to us00:53:07
it is necessary to include this very thing in the procedure00:53:10
buffer and indicate here as if in the site00:53:14
to do this procedure directly00:53:16
remembered everything for further action00:53:19
now we need to define00:53:21
operation, that is, this very instruction00:53:24
because it will be define instruction00:53:27
either it will be their destruction because it is00:53:30
there will be influence truction00:53:32
for it will be lord instruction but otherwise00:53:35
we will have a default default that's all00:53:37
other functions that we will do and how00:53:39
either implement or create00:53:41
how to call everything in this case00:53:45
What do we mean by definitions?00:53:47
define is one of the most important parts00:53:49
of this code it will define the functions00:53:52
and further these functions00:53:54
will be able to indicate one way or another00:53:56
and be used accordingly in this00:54:00
case to us for each new function to us00:54:02
it is necessary to allocate a stack stack equals00:54:05
until in this case penalties we write further00:54:08
indicate the joint says that we made and00:54:12
this will be a string type, that is00:54:15
each each function argument will be00:54:19
represent a specific string that is00:54:21
let's say arguments x y z there nbb and so on00:54:26
further that is, one way or another this is all00:54:28
are arguments and they will have00:54:32
type string and further after00:54:36
using the joint we need it00:54:38
it is necessary to release it so that it does not happen00:54:41
no00:54:42
well let's just say no memory leak00:54:45
Well, then we have to return SRS we00:54:49
we will get from here, that is, in this00:54:51
case, let's int 8 tr. s equals and00:54:55
here we will write define or scary define00:54:59
with truction here we will transfer a00:55:01
We will further transfer the experience here and input00:55:03
let's pass it here let's rename it00:55:07
a little differently it will be new arguments00:55:09
newark sleep or just n arks let's call it00:55:13
so we pass these arguments here00:55:16
Next, we’ll pass the buffer here and pass00:55:18
here is the current procedure that we will say00:55:23
so we basically use everything like this00:55:28
I’m wondering how this procedure will work for us and00:55:31
hereinafter referred to as all of us00:55:34
done in this case by the way00:55:37
open brackets because here we have00:55:40
all variables are initialized00:55:45
we did this first, then let's00:55:47
let's immediately define all other instructions00:55:49
riter further iv instruction00:55:53
we'll write here here we'll have oops here00:55:57
further we will have input here as well00:56:00
arguments will be passed to us further00:56:02
Sleeves and directory will be transferred00:56:03
attachments will be transferred and will00:56:05
transfer the count00:56:06
everyone let's move on here we will have in00:56:10
principle very little that is, it is an experience input i iv00:56:14
the buffer is also here, same thing, because it’s here00:56:20
By the way00:56:21
the incubus is the same here, that is, here00:56:25
let's do it here through the lower ones00:56:28
here is the lot instruction00:56:31
here output input and buffer are all now00:56:37
here we need to understand that we00:56:39
we do but in this case we'll call it00:56:40
how to process instruction00:56:43
here we also do out input00:56:47
then we pass the arguments here00:56:49
we pass argun so we pass the argument00:56:52
they gave us a buffer here, we send it here00:56:54
the called procedure is then passed to ru00:56:57
we even transmit such a procedure00:57:00
investment and count counter are all in this00:57:05
case, there is no need to be surprised by what is here00:57:08
there are so many arguments because it is00:57:09
the function is in fact the main one and00:57:12
evaluates all expressions this instruction00:57:15
she creates functions this is instructions she00:57:18
creates threads, that is, there00:57:21
allow 1 1 thread 2 threads so on00:57:25
but in the club laut this is purely loading00:57:27
code and nothing more00:57:29
in this case it will be easiest00:57:32
implement in cloud and lot of instructions00:57:34
let's try to do just that00:57:37
write static then int00:57:39
8 t further in construction00:57:43
and in this case we will have a file like this00:57:50
output then the input file and here we have00:57:54
there will be another char buffer channel we will also00:58:00
put00:58:01
int ch next what we do we must00:58:04
indicate00:58:05
index is zero to read the buffer00:58:07
further until the king00:58:13
input does not equal the end of the files then we00:58:17
do the following action first00:58:19
need to skip everything00:58:22
white that is if it is a space ch then00:58:26
we let him through first, then we00:58:29
you need to skip all the characters00:58:32
which follow the comment that is00:58:34
if ch equals comment then we00:58:38
skip the comments, that is, the groove00:58:40
comment in this case we write ch input00:58:45
Well, we do it exactly the same way in the picture00:58:47
further here we should have answers in00:58:51
a new buffer must be created each time00:58:53
symbol that is Yandex plus equals00:58:55
and here when we say so00:59:00
skipping spaces this may indicate00:59:02
two meanings00:59:04
first of all the words were read in full00:59:07
Well, let's say look at the first word it all00:59:11
out then the second word is in this case00:59:14
by words we will understand everything without00:59:16
space characters in this case are not00:59:19
Navy whip of this n.s.00:59:21
but besides everything else, we can also00:59:23
so let's do it there, let's say saab further00:59:27
here we say and so on, that is00:59:30
accordingly after we00:59:33
detected a space character or a symbol00:59:36
completion with an expression we need00:59:39
do the same actions with what you read00:59:43
line accordingly in this case00:59:45
what do we do well first of all if00:59:48
check if the index is not zero00:59:50
but this is to skip all these things00:59:54
variations when we have simple here00:59:56
characters are spaces then we must00:59:59
add a final index to the buffer01:00:03
the symbol was given the index to be immediately reset and01:00:06
after that we need to open the file01:00:08
that is, in this case the file is equal to01:00:12
movie file equals fiab and further here01:00:17
we indicate the buffer, that is, read01:00:19
line and then we open this file at01:00:22
reading given here immediately and taste files to01:00:25
win and further here in principle immediately01:00:30
the cantina will go next what do we need01:00:33
needs to be done here but first of all we01:00:35
We need to understand the files are zero01:00:39
that is, this means that our file01:00:41
it just didn't open01:00:42
accordingly we must return one01:00:45
let's move on after we opened01:00:50
this file we need to do everything01:00:53
the same thing we would do with our usual01:00:57
the specified file here, that is, we01:01:00
should just call the same one01:01:03
fact procedure but not pars procedure but01:01:05
procedure he let's find it procedure01:01:09
lithol we need to call her let's01:01:12
let’s do this, that is, the source ritual and01:01:14
here we specify output but as01:01:17
input parameter we specify the file then01:01:20
there is a bottom line we have to read this01:01:22
the very file that is listed in included in01:01:25
in this case it will look like in01:01:26
cloud then we do the same actions01:01:30
do it with the symbol if we meet it01:01:33
ending symbols, that is, we are exactly the same01:01:39
indicate if the index is not zero01:01:42
exactly the same buffer but except that01:01:45
what are we doing here instead of what bricks?01:01:49
that is, the conditions were completely completed01:01:52
that is, nothing further is needed01:01:55
read we all agree with this in principle01:01:58
figured it out and here we will just return 001:02:03
this is how easy it is in principle01:02:05
young lad procedure and give it right away01:02:07
let's put it up here somewhere01:02:12
the mode instruction is done in exactly the same way, but01:02:15
It’s even easier here, let’s even say this01:02:18
instruction01:02:19
then copy this instruction directly01:02:23
insert the whole thing here, change it to the forehead01:02:28
instruction and what it will represent01:02:31
it's just reading the code, that is, reading01:02:33
line by line and nothing more is not even necessary01:02:36
nothing, no function, this is a ritual01:02:38
cause and so on and so forth to us01:02:39
you just need to read it line by line, that is01:02:41
file in g01:02:43
write further indicate01:02:46
buffer somewhere, that is, it will all be01:02:47
rush around and indicate the file not yet01:02:50
equals zero while we can read01:02:53
we will simply enter these same lines01:02:56
lines01:02:57
that is, we indicate the buffer in output, so01:03:00
we delete all this and we do the same thing01:03:03
we do it here01:03:05
everyone, in this way we have already implemented 201:03:08
in fact functions that can either01:03:12
otherwise apply01:03:13
that is, these are the lightest ones01:03:15
let's put them here as well01:03:19
and here I have already contributed everything and now we01:03:23
it is necessary to proceed to three main01:03:25
instructions that precisely determine01:03:29
our program01:03:30
Well, of course, we’ll start with the instructions01:03:33
let's define define scary because01:03:35
it just determines all subsequent01:03:37
functions and an expression without a function they are not01:03:39
will be performed more accurately we will have01:03:42
a certain error is immediately called01:03:45
and let's immediately define this here01:03:47
this very file, or rather this very one01:03:51
function by the way to further and 8 times here01:03:54
indicate define is not scary, well01:03:56
it takes this function file output01:04:02
next file input next stack arcs01:04:09
then takes the buffer and accepts01:04:14
procedure01:04:16
everything else starts the same way for us01:04:19
en en sage further we have exactly the same wild01:04:23
Sasha equals dc input does not equal yet01:04:27
after eating we will have to do exactly this01:04:30
all subsequent actions are exactly the same01:04:31
we write space age and further here01:04:35
do continue01:04:37
further in the same way if ch equals01:04:39
symbol01:04:41
comments then do the same01:04:43
skip comment pascal and01:04:48
and then continue that is continue01:04:52
this is how we did it now01:04:55
what do we need to do first01:05:00
after more precisely we need01:05:03
define explicitly01:05:05
Let's just say what the procedure was01:05:09
analyzed i.e. what procedure01:05:10
has been read, we need all these in01:05:13
first procedures and read that is, how she01:05:15
this will be determined by us01:05:19
let's function Ren TV she returned it to us01:05:22
give up and moved the pointer here01:05:24
that is, at the beginning01:05:27
main functions then we need everything01:05:30
Read the next ones yourself01:05:32
Accordingly, we need first01:05:34
determine the name of this very function01:05:37
secondly, we need to determine everything01:05:40
subsequent arguments to this very function01:05:42
and thirdly, we need to call01:05:45
these are all the expressions that are found01:05:47
in this function all these are basic01:05:50
tasks directly and give them01:05:52
Let's try to solve this case in01:05:55
As a result, we will try to create one01:05:58
function called let's here01:06:00
iv define construction state that is01:06:05
setting the state in this case we01:06:08
let's pass the arguments here, that is, the stack01:06:10
next we will pass the buffer here before this01:06:13
procedures here and here we will create more01:06:16
let's say in fact there are two components of this01:06:23
procedure found01:06:24
that is, the procedure was not found then01:06:28
there is this01:06:29
naming the one found or not found yet01:06:32
further we still need to determine01:06:34
index in this case we are Yandex01:06:36
plays exactly the same role as here01:06:37
that is, purely for accumulating a buffer and01:06:40
no more Well, accordingly, what are we doing here?01:06:42
we simply pass found here and pass01:06:46
Yandex here, well, let's define this01:06:48
the static function itself further01:06:51
will return exactly the same int 8 t and so on01:06:54
define extraction speed01:06:58
here we will have a file oh more precisely a file01:07:03
stack stack arcs01:07:07
next char buffer next chart percent and here01:07:13
will be the process and say'st and index here01:07:21
By the way, we check everything further01:07:25
if the index is not equal to zero in principle01:07:29
as you have we will do it in principle01:07:32
similar action to start with is01:07:35
index + + t7 inn express press simply01:07:38
index equals pa to the terminating character01:07:44
Further01:07:46
index is zero here by the way01:07:49
pointer go further next if01:07:52
the procedure has already been announced it will be01:07:56
talk about next steps to us01:07:58
Now you need to enter all the arguments01:08:01
this very procedure on the stack, that is01:08:04
make a push stack, then specify arcs and01:08:08
we indicate this very argument in this01:08:13
case the buffer stores arguments01:08:16
Next we need to understand that is01:08:18
side step01:08:20
we write further here we indicate arcs and if01:08:24
stack equals stack says it says about01:08:27
stack overflow accordingly we have01:08:29
will return one otherwise if the procedure is not01:08:33
was found, this indicates that we have01:08:35
procedure read accordingly we01:08:38
must be copied into the procedure, that is01:08:41
here in this array of ours01:08:44
read procedure we indicate the buffer from01:08:47
buffer and how much to read buff site well01:08:49
and then we indicate that the procedure was01:08:52
found everything here return 0 at once well01:08:57
and here we have a unit returned like this01:09:00
this is how we move on now01:09:03
accordingly, here we have by the way if01:09:06
this is fulfilled when we return01:09:09
units let's move on01:09:11
further if ch equals the beginning that is01:09:16
in fact the expression was found for us01:09:20
needs to be analyzed01:09:21
was this expression caused by reading01:09:24
procedures or was this expression a reading01:09:27
the body of this very procedure in this01:09:30
case we do the following if percent01:09:32
found01:09:33
then we have to do certain things01:09:38
action otherwise just skip01:09:40
certain actions that we will01:09:42
mean firstly we immediately and that01:09:44
we return the same symbol, that is, here01:09:46
this boss01:09:48
the beginning of the expression and enter it into the flow01:09:53
read more what we do we determine01:09:56
first time label01:09:59
our procedure, that is, in this case01:10:01
what are we doing we are in and the experience is out01:10:05
we put the thread, that is, the label further from the gigin01:10:11
that is, this is the beginning of our marks and here01:10:14
under our marks we will be01:10:16
imply this very procedure and01:10:18
after that we will call steam scott01:10:21
that is, here we pass output here we01:10:24
we pass the input I need to pass it here to you01:10:26
we pass the arguments to the procedure until01:10:29
transfer the amount of arm01:10:32
more accurately, nesting is conveyed by nesting01:10:35
and we pass the count equals zero, that is01:10:38
we just initialize the counter counter01:10:40
everyone go further further if Sasha equals01:10:46
completion it will talk about01:10:49
next upon completion we definitely01:10:52
we need to complete our execution01:10:55
procedures what we do first we01:10:58
for now we are doing exactly the same thing, that is,01:11:01
we will have to read the procedure01:11:04
because there may not be any here01:11:07
spaces as this implies01:11:10
accordingly we can have it like this01:11:12
accordingly we again define01:11:14
procedure further further what we do we01:11:21
specify side step01:11:22
arks, that is, we indicate how much01:11:26
arguments01:11:29
how many arguments are on our stack01:11:31
located01:11:33
and then we do the following if01:11:36
procedure was not found just not01:11:39
found01:11:40
then we create procedures for the first time here01:11:43
this label only indicates the beginning01:11:45
procedure actions while here01:11:48
the following marks we will write01:11:50
they will point to the beginning of the arguments01:11:53
this very procedure is what we are doing here01:11:55
First of all, we do exactly the same in01:11:57
printf here is output and here we pass well01:12:01
firstly we can indicate the quantity01:12:02
arguments01:12:03
that is, we indicate the ldn and transmit it here01:12:07
arts01:12:08
further we can also indicate exactly01:12:10
current indicate already and create a variable01:12:12
that is, create a label and send01:12:16
here procedure the name of the procedure that01:12:19
we read with the help of these here01:12:23
this function go further so on here01:12:28
we are creating a certain pace that will01:12:31
equal arts01:12:34
what are we doing so far the more unity we are01:12:39
we will have to download the value from01:12:43
memory that is f printf further and experience and01:12:47
here we will have01:12:49
let's do it here right away01:12:53
it was beautiful01:12:54
and from where we should load i.e. into01:12:56
in this case minus ld.01:12:58
and in this case it is unloading01:13:04
arguments will simply go under + 101:13:07
arks and all why + 1 because like me01:13:11
I said earlier we always have at least one01:13:14
argument i.e. functions without arguments01:13:16
we simply will not exist in01:13:21
in this case, so far all these arguments01:13:23
directly01:13:25
are isolated here tempo -1 everything and further01:13:31
here we need to do more01:13:32
do the following f printers exactly like this01:13:35
same out put and here we need01:13:37
point jump jump to run run and here you go01:13:44
here we indicate the percentage that is01:13:46
Jenkinson and this is the very beginning after01:13:49
after we unloaded all the arguments we01:13:51
she started jumping and that is on the body01:13:53
procedures01:13:54
Well, what else are we doing here?01:13:57
we can, in principle, indicate the symbol of the new01:14:02
lines and everything further if after all01:14:05
procedure was found process found01:14:08
then what do we do we if procedure01:14:13
was found, this means that we01:14:16
read everything in this function because01:14:20
couple scott he says that we are all01:14:23
expressions inside this very function01:14:25
read accordingly we found01:14:26
this very symbol is because I myself01:14:29
the procedure has already been found, that is, this01:14:31
symbol we respectively skip and01:14:33
accordingly we have reached the very end01:14:36
accordingly in this case we are01:14:37
do we indicate the end of our01:14:40
procedures oh here and further here we create a label01:14:44
label with and as called and we are here01:14:50
indicate the procedure further if01:14:53
number of arguments is not zero01:14:56
then we make the following offset01:14:58
output here we write 100 and here01:15:05
firstly minus ld -1 that is minus 101:15:09
will indicate the result of this very01:15:11
functions, that is, what result we take01:15:13
ld will indicate the offset itself01:15:16
is there somewhere we should put this one01:15:19
the result and this is actually a memory area01:15:25
where should we put it is calculated01:15:27
according to the following formula we need to01:15:29
add two arts01:15:31
multiply by 2 about this01:15:35
let's say so you can say so I01:15:38
this one incl.01:15:42
I found this formula empirically but01:15:45
in fact, you can do it yourself01:15:48
analyze its essence of work and there01:15:51
indeed the arguments are always01:15:54
pressed, or rather, always even in01:15:56
the fact is otherwise that we are doing this unloading01:16:03
unload the storm here that is, if01:16:07
arguments01:16:08
still equals zero then it is01:16:10
default is 3 minus 3 that is01:16:16
why -301:16:17
because first we will start first01:16:20
argument further we subtracted my pointer01:16:23
to the label and as the third argument01:16:25
this is the argument itself that was submitted in01:16:30
this very function, respectively, these are three01:16:34
this is how we are already here01:16:37
done now let's move on here01:16:41
you need to immediately push from this01:16:43
value functions, that is, we indicate pop01:16:46
so that we don't have any leakage01:16:48
memory and then we will do this01:16:51
look, that is, the tempo is equal to arcs01:16:54
and further for now the more of us are here for now01:17:01
the more units we do what we do01:17:04
in the same way we unload all the values of a01:17:06
experience pop and here the temp minus is equal to 1 o01:17:12
what does this mean what does this mean01:17:14
every time we do laut we01:17:18
fill the stack accordingly all these01:17:20
the lots we made we need01:17:22
release from because01:17:23
that's all therefore in this case for01:17:26
This is exactly what we are using, and01:17:29
next what we do is return01:17:33
result and what we return control with01:17:35
calling function that is, it is red01:17:38
and here it’s simple and butt out put symbol01:17:44
new line and further after we01:17:49
I finally got to the end of the expression01:17:54
we need to take back control01:17:56
calling function01:17:57
writer 0 and further what else do we need01:18:04
to do this, let's say, to understand more precisely in01:18:12
In this case we need to do more01:18:15
one variable called what will it be01:18:19
percent peephole equals01:18:23
in this case one here here by the way01:18:29
I'm sorry, I made a mistake here01:18:31
found a process Klaus must be given01:18:36
here should be proc clouseau you and her01:18:39
will be indicated here will serve01:18:40
equals one and here continue percent01:18:43
the closet will just say that01:18:45
this procedure was completely closed01:18:47
that's it and then in the end what else are we01:18:53
do next if percent closet01:18:58
when we return record error01:19:03
otherwise buffer index plus plus equals01:19:07
ch what does it say what does it say01:19:10
define should never be read01:19:12
all subsequent characters are the essence01:19:15
define is to01:19:17
read the procedure and read everything01:19:19
arguments01:19:20
everything that comes next is by no means01:19:22
should read exactly what it says01:19:24
about this if the procedure was closed then01:19:27
there is if there was an end to this01:19:28
character and we are trying to read more01:19:31
new symbol then this indicates an error01:19:33
accordingly, return the error and that’s it01:19:36
after all we are here01:19:39
return not 0 but one01:19:42
because in this case it’s below zero01:19:44
this is just the argument here01:19:46
that is, that the procedure was successful01:19:49
closed and if a symbol was found01:19:54
line endings and the procedure was not01:19:56
closed this also indicates an error01:20:00
that's basically all there is and this one01:20:02
we finally described the function given01:20:04
massive but she is let's say01:20:08
the basic function is enough for us01:20:12
we now needed to implement01:20:13
two more functions need to be implemented01:20:15
this is firstly this is firstly a function01:20:21
f and secondly this function is percent well01:20:24
let's try to implement the function01:20:25
percent because she’s not very like them01:20:28
important for execution, that is, we of course01:20:32
we can’t make conditions there, but still01:20:34
less here is such a performance we are quite01:20:35
we can do it without her and let's do it01:20:38
let's try to do this, come here and01:20:43
we declare this very function, that is, in01:20:46
in this case static then int 8 topics and01:20:48
here we will have01:20:49
iv instruction this function also01:20:52
accepts the following arguments then01:20:54
there is firstly this is output then this is01:20:56
also input further is a stack that is01:21:02
arguments more precisely take me if a I'm sorry01:21:07
prostration instruction which we01:21:09
we create directly further what we need01:21:14
we need a buffer buffer01:21:17
Next we need an indication of the procedure01:21:20
current and we need to indicate the root01:21:23
procedures further we need instructions01:21:26
investments site investing and we need01:21:29
account and account for everyone in this way01:21:34
then we do exactly the same with next01:21:36
file ch equals gds they are not here01:21:41
equals and a file then exactly the same01:21:44
skip if01:21:45
and space Sasha when in this case01:21:49
continue write 0 and if01:21:51
[music]01:21:53
if ch equals comment character01:21:56
in the same way here continue we write a01:21:59
write a comment here01:22:03
sash input further here we are exactly the same01:22:07
create the sst variable01:22:08
index is 0 it is exactly the same here01:22:12
buffer index plus plus equals ch01:22:16
Well, that is, we are already in such an architecture01:22:18
basically done in all previous ones01:22:20
functions now what we need01:22:23
What we need to do here is something like this01:22:27
the same as with define and call your01:22:30
function perc instruction01:22:32
and here is this function needed for this01:22:37
to determine what values we need01:22:41
must be placed directly into01:22:43
the virtual machine in this case is01:22:46
not necessary for arguments like this01:22:48
there are two three these values we need01:22:50
insert into the joint into this one in the stack exactly01:22:53
virtual machine accordingly is01:22:55
let's just try to do that01:22:58
we have here what we should have at all01:23:02
transmitted firstly is out put where01:23:04
should go to bed01:23:06
then these are all the arguments that should01:23:10
Let's say it's checked, it's a buffer then01:23:16
is in this case from the buffer just01:23:19
takes arguments next is index next01:23:26
and this is another arx variable01:23:29
let's define the Stan Arts site here too01:23:33
And01:23:34
equals 0 this indicates the quantity01:23:37
arguments in this expression, that is, in01:23:39
in this case, two arguments we all are01:23:44
definition now let's function01:23:46
Let's implement static further in this case01:23:49
howl percent strashinsky01:23:53
and here is the output file next to the stack01:24:00
arks dalia buffer01:24:05
investing website01:24:08
then here we have it and here we have it and here it is01:24:16
further arks01:24:17
We have a buffer and here we’ve been wearing sting for a long time01:24:19
let's try to implement this01:24:21
investing index rts 0 here we go01:24:25
say'st and Yandex and side-step Arks in well and01:24:36
here is exactly the same if the index is not01:24:38
equals zero we make the following buffer01:24:42
index plus plus equals slash 0 further01:24:48
index value like this index equals01:24:54
zero and further soloists and and here to us01:24:58
need to check is not in01:24:59
stack this same or read argument01:25:01
that is, in this case, what can we do?01:25:03
do if the function accepts01:25:05
certain argument we need01:25:07
understand there is this argument01:25:09
x on the stack and accordingly if01:25:11
exists then we need to download01:25:13
this argument to a specific address01:25:17
the address is indicated to the virtual machine all01:25:20
further accordingly if they stack further01:25:24
indicate arcs01:25:25
buffer and indicate and and it will be01:25:32
return this very address in fact, well01:25:36
more precisely the address relative to the current one01:25:38
positions because now we will find out01:25:41
how to calculate the real address of a cell01:25:43
memory in this case is specified in printf01:25:46
gave oh here and here we indicate t lot then01:25:51
there is a load from a memory cell minus ld01:25:54
and load using the following formula01:25:57
arks en plus listing minus and in fact01:26:01
this formula was also found01:26:02
empirically but she is quite herself01:26:06
functions what we do next next01:26:09
we are here in the printer doing further out and01:26:11
here we do push push and01:26:14
indicate the buffer in this case01:26:18
Let's just say why is this needed at all?01:26:22
in this case the number two and the number 3 are not01:26:26
are arguments01:26:27
accordingly, they will fluff in addition to01:26:29
everything else can even fluff01:26:31
function we'll talk about this later01:26:33
because thanks to this we can01:26:35
implement the concept01:26:37
so let's say the functions that are capable01:26:40
accept a function or return01:26:42
function that is quite useful01:26:45
Well, let's try to do this further01:26:48
fax and accordingly after01:26:50
we extinguished the values we have quantity01:26:54
arguments01:26:55
arcsin is added plus equals 1 now01:27:00
let's move on further so here we are all01:27:05
this has already been done, so if01:27:08
Sasha equals the beginning of the expression that we01:27:11
we must do everything we do01:27:14
did in Bethany, that is, sage questionnaires01:27:16
input then we call steam in the same way01:27:19
scott couple scott let's say stooop here01:27:23
we pass it here01:27:24
input pass here arcs pass here01:27:26
root rights01:27:27
well and further here only with the exception of01:27:30
what we convey here is not just01:27:32
nesting and we pass on missing plus arts and01:27:35
so that this is the offset it is always01:27:38
replenished in this specific function01:27:41
so that all other functions01:27:44
so that all these arguments are capable01:27:46
were finding themselves01:27:47
that's all, well, then we do transmit01:27:51
count the cautery hasn't changed yet01:27:53
will only change in the if statement01:27:55
Well, further in this case, arcs is a plus for them01:27:58
equals 1 we add again01:28:00
because let's say for this01:28:04
expressions this expression is like01:28:09
one argument01:28:10
they are like here, let’s say 2 respectively01:28:12
we only need to add one01:28:14
everyone let's move on further we need01:28:19
understand and if symbol01:28:21
equals the end of the expression well and in01:28:25
in this case, what do we do, well, first of all01:28:27
we do exactly the same thing, call this one01:28:28
the very function of the instruction is worth01:28:31
called and then we need01:28:34
determine the number of arguments arcx and01:28:36
on equals zero if the shares are on01:28:39
equals zero then what we do is01:28:42
indicates that the function has no arguments01:28:44
but as I said earlier each function01:28:46
has at least one argument01:28:47
accordingly, here we push the furs, let's go01:28:53
next next we do01:28:55
and by the way, we haven’t implemented this one yet01:28:58
here's the function itself, let's give it in principle01:29:02
then let's try to implement it, I think not01:29:06
so complicated let's get here right away01:29:09
I will define statics further here01:29:12
bull in stock next here stack arcs01:29:17
further char buffer and further here say'st and01:29:21
Yandex01:29:23
then we have to sort through 32 you and01:29:28
is very much zero and01:29:31
Well, yes, in principle, let’s do a side step right away01:29:35
and equals zero or less01:29:38
side-step arcs and further + + and further if01:29:45
string was found string m.p.01:29:49
Arx will start bad stack Arx and . string with01:29:59
buffer equals zero then we go to01:30:03
index we add current with ours, this is the same01:30:06
meaning and and return what the value was01:30:08
found 0 otherwise 0 here we are in principle01:30:12
we have implemented this function now01:30:14
you need exactly the most accurate and the same01:30:17
let's call the function again01:30:19
let's try to call if it's already on the stack01:30:23
there is a certain value of arcs then01:30:25
yes if there is a procedure on the stack01:30:28
procedure name what are we doing01:30:33
we call this very procedure like this01:30:36
in general it may be in this case01:30:37
maybe as follows, that is, here01:30:42
so let's say so here maybe01:30:46
there must be a certain procedure and01:30:49
here are some arguments to go01:30:51
Accordingly, this procedure should01:30:53
be called upon that's all let's move on tags01:30:57
Arks further here we will have because01:31:02
and here we indicate minus ld.01:31:06
that is, each procedure in fact also01:31:08
have your own address, that is, to which we01:31:10
should contact this address as well01:31:12
we calculate using the same formula01:31:13
arsen plus missing minus and well, otherwise if01:31:22
countries the procedure is zero and no01:31:26
I'm sorry and here when I did this01:31:29
in this way, that is, when we have01:31:30
a certain procedure was returned and01:31:32
here the X game was performed here01:31:34
this is the code like this and this is the code and it’s like this01:31:41
yes it is executed if this procedure01:31:43
is in the arguments in theory, that is01:31:46
if right here is in01:31:48
arguments this procedure then it01:31:49
everything works with this it seems01:31:53
we figured it out, let's change it here to01:31:57
defaulted so the building we held here01:32:00
f printer we do further here and experience01:32:03
here by the way also out01:32:06
we must not forget further here we are01:32:10
call further01:32:12
ld and here the formula will be simply arcs01:32:17
and because it's just an argument number01:32:20
and nothing more01:32:21
then we go as follows, that is01:32:23
out put01:32:24
and here we need to unload01:32:28
know load values that is l d n01:32:33
minus 1 that is01:32:37
arks and and further as the second01:32:39
we specify the following arguments01:32:44
minus equals 1 that is, if the argument01:32:48
number of arguments 0 or equal to one01:32:51
then return one anyway01:32:53
Well, otherwise, in principle, we can do this01:32:57
in the same way there is nothing here01:32:58
will change, and then return the arcs and01:33:01
-1 all this is, in this case, like01:33:06
some result of this very call01:33:09
we will have this very function, but otherwise01:33:11
if not this is not this we have not fulfilled01:33:13
that is, if y and process equals01:33:17
zero by the way why am I here he just01:33:19
equals 0, the whole point is that01:33:21
when we do this, we have a reading01:33:24
here, that is, the functions between the beginning01:33:28
expressions and the end of the expression is 0 that is01:33:31
We didn’t read any procedure, but the whole one01:33:34
the point is that with this expression we01:33:36
return some other procedure and01:33:40
we put it here basically01:33:44
so let's just say this is all01:33:47
implemented01:33:48
go further further here in printf01:33:50
here we have output and here we do01:33:55
ordinary call that is, count and so on01:33:57
we pass here the procedure percent but in this01:34:02
In this case, let's say this in fact01:34:06
a regular call to another procedure01:34:08
let's say there's some kind of ark procedure01:34:11
just called01:34:12
that is, it is not used as arguments01:34:14
not as some kind of return01:34:15
there are meanings and so on, it’s just itself01:34:18
in fact, that's all it is01:34:23
return value it is needed let's say01:34:25
we write here re-therm ark and some01:34:29
another function just returns01:34:30
here and she uses these two01:34:33
argument when she's completely there01:34:35
the other one, well, we'll talk about that later01:34:38
these functions that are capable of themselves01:34:40
there to accept yourself which you which01:34:45
can accept other functions that01:34:47
can return other functions like this01:34:48
further and similar we will talk about this more01:34:50
let's talk, basically we're all here01:34:52
we figured it out and now all we need is01:34:54
All that's left to do is clear the stack then01:34:57
There is file arx in more than one we will do01:35:01
just f printer output01:35:03
and under we indicate because here we are01:35:11
in fact they scored01:35:12
certain meanings and here we are01:35:14
scored certain values01:35:15
accordingly, all the values that we01:35:17
they should have used it, let's put it this way01:35:21
leave here and we write everything here01:35:25
more01:35:26
arcs and minus equal de all return 001:35:31
Well, otherwise, of course it’s coming back to us01:35:33
unit01:35:34
if everything is over with us but at the same time01:35:38
expression is not completely about01:35:41
was analyzed so now everything we need01:35:45
All that's left to do is implement the function01:35:47
f instructions01:35:48
let's try to implement it, that is01:35:50
in this case we write it like this: static01:35:55
right away by the way kent 8 then if in01:35:59
terrible and in this case exactly the same01:36:02
output file01:36:05
next file input next stack arcs01:36:11
then the ore directory is accepted and then01:36:14
attachment accepted01:36:16
nesting and apply accepted01:36:19
the counter here is exactly the same01:36:23
int ch by the way there is inter everywhere here01:36:28
then the sachet file is equal to dc input01:36:33
does not equal it we will do it in fact01:36:37
all these operations are of the same type and space ch01:36:41
then we continue if ch equals01:36:46
skip the comment accordingly01:36:50
comment sage input further exactly the same01:36:54
continue to register further here we01:36:59
Of course, we put the index plus in the buffer01:37:02
plus equals as much as and accordingly here01:37:04
We01:37:09
so yeah01:37:14
or even a buffer buffer we have even in01:37:16
basically it won't be needed here01:37:18
look at the interesting feature01:37:20
concluded that is, we first read all the characters01:37:24
Next we need to understand that is, if01:37:27
ch ch equals the beginning of the expression then this01:37:31
indicates that the conditions in fact01:37:33
begins and we need to analyze01:37:37
have we read the terms and conditions or is it already01:37:40
expression and we have it look like01:37:42
it will look like01:37:43
those. in this case iv here is some01:37:46
condition let's say there 0 equals 5 and go01:37:51
two arguments that is, if zero equals 501:37:55
then return 1 otherwise return 201:37:59
we will have it so we need it01:38:02
read this first01:38:04
the conditional expression was given already read here01:38:06
these two01:38:07
enemies under the expressions let's say so, well01:38:10
Accordingly, our task is precisely to01:38:12
this is concluded01:38:13
those. in this case what do we do in01:38:16
first for us we always have01:38:20
only two arguments that is01:38:23
air conditioning arcs01:38:25
equals two well, that is, as I said01:38:27
previously there is the first and second expression and01:38:31
further we must have more conditions01:38:34
was not closed01:38:36
the first expression that is responsible for01:38:39
condition low z equals 0 and01:38:44
accordingly we do the following01:38:46
first we need to remember01:38:48
current counter, that is, this contour01:38:53
then we do the following if air conditioning01:38:56
closet then we need to define01:39:00
the original mark in fact, that is01:39:02
do output then put the label here and01:39:07
here we indicate with and here we indicate01:39:10
l.d.01:39:12
well, by s we mean sleeves and01:39:14
directory a under ld.01:39:16
we will understand the current counter01:39:19
account but here we have to01:39:21
subtract he arcs that is, we initially01:39:28
account let's add a two here01:39:30
deuce01:39:32
further here accordingly we will have01:39:33
subtract first 0 will be the counter next01:39:36
then there will be 1 0 in the next expression01:39:39
By morning there will be four of us equal to then01:39:41
the counter will be equal to 3 and then 4 and01:39:44
so on and accordingly that's all01:39:46
initially we do it and then here01:39:49
we have air conditioning arts minus equals 1 and so01:39:54
Next we need to do the following01:39:57
that is, execute the expression that is, he01:40:00
gch waist input and expression we must01:40:03
execute and everywhere be it conditional01:40:05
expression be it meaningful expression01:40:08
accordingly we make the next bar01:40:10
Scott and let's do it, that is, out here01:40:13
further input arks root nesting but here already01:40:19
we transmit because under that is the counter01:40:21
increase for a specific procedure01:40:23
which we call next if01:40:26
air conditioning closet01:40:31
if that is the conditions have already been completed01:40:34
and condition arcs equals one then01:40:37
we do the following in printf given01:40:39
out here we put jump here and here and then01:40:52
yes in this case we need it01:40:54
so that the knife in this case is01:41:00
necessary for our meaning01:41:02
air conditioning arcs closed01:41:04
alternative expression that is when01:41:06
we did, let's allow them there01:41:10
condition x y when this condition is allowed01:41:16
it will be carried out there in fact01:41:19
another value is acceptable there if not01:41:22
equal to zero, that is, if the conditions are not equal01:41:24
is not equal to zero then we go to01:41:27
X, otherwise we move on to Igor here01:41:30
this is otherwise possible only under the condition01:41:31
condition arcs equals one01:41:34
because we have already read this01:41:36
read the second one and that's it01:41:38
accordingly, it is possible for us only with01:41:41
Kadish narc equals dice let's move on01:41:43
next now if candychan arks not01:41:46
equals zero01:41:48
that is, to be more precise, not orcs from lost01:41:51
sorry lost01:41:53
if the condition was not closed then we01:41:57
what do we do first we push the values01:42:01
a mole to which everything will be compared01:42:05
because 0 is the default in ours01:42:07
language will fall we took what we do01:42:10
here we do the same via output01:42:12
Then we compare if the final result is this01:42:17
here's an expression we didn't make01:42:20
equals zero then it is true01:42:23
accordingly what we do we must01:42:25
for jumpy c01:42:26
that is, in this case ld.01:42:30
we have to get hooked people and here it is01:42:33
counter must be specified counter -2 then01:42:38
there is minus 2 indicates the very first01:42:39
expression01:42:40
well otherwise it should be pointed to the first01:42:44
expression and here we will simply have01:42:45
jiang that's all in this way and that's it01:42:52
here we have continue in this case01:42:54
I don't need to do anything because01:42:56
that these functions are more accurate than instructions01:42:59
they eat two arguments by default01:43:02
that is, they don’t return them back to back and that’s it01:43:04
Well, then what do we do, we check01:43:07
if condition arcs is zero then01:43:12
with us everything ends successfully differently01:43:15
ends with one well in this01:43:19
case as you already understand01:43:24
the conditions will no longer be met because01:43:26
What is air conditioning OJSC RKS01:43:30
there are only two conditions in fact01:43:33
if candychan arcx is not zero01:43:35
this indicates an error01:43:38
Well, basically everything is this way we01:43:43
Really implemented all the functions01:43:46
now let's take out their prototypes01:43:48
to the top that is, in this case include01:43:51
laut further here if in is scary for us01:43:54
necessary before fiennes is scary01:43:55
register ax we are looking for water fiennes01:44:00
scary and we need more percent01:44:07
construction let's write01:44:09
the percentage is scary copy and paste01:44:15
tags in theory we've done it now let's01:44:18
let's try to compile compile01:44:22
that is, we write make build so more precisely01:44:26
come back here we'll write a Mike build and01:44:31
let's see so first of all let's01:44:33
let's check, oh yeah here arks01:44:38
we have to establish and check now01:44:41
39 before counted 3901:44:46
Arks, yes, orcs, of course, orcs further01:44:50
what else are we doing? thought it was 42 a01:44:55
By the way, I didn’t forget to indicate this here, yes01:44:58
Of course I forgot the ritual. si us01:45:02
Of course you still need to compile01:45:04
so on here01:45:08
translate resource of course, so let's do it01:45:11
let's run it like this, let's check all the errors01:45:15
which we had first is a ritual01:45:18
184 let's check 18401:45:23
this is Arts Arks with us, of course01:45:27
tags yes01:45:31
arcs we don't have here we need01:45:35
Arks of course, let’s register further01:45:38
Further01:45:39
tax 255 let's go like this 255 255 argument but01:45:49
there's no escape here01:45:51
park let's move on so passing argument a01:45:57
[music]01:46:00
well yes 274 so let's move on there's still left01:46:11
a little like this 379 let's go like this output here01:46:19
remove this update like this 49601:46:28
496 what do we have here declare that arcs01:46:35
here before01:46:36
on the house arts paint of course tags01:46:40
compile further 505 like this01:46:56
so wait we have something else01:47:00
directly assumed let's01:47:05
let's try to look at it, but yes here01:47:09
there is simply no need to indicate it01:47:14
so on, let's compile again01:47:19
and here 52301:47:21
so with wrong porn and expression yes01:47:26
of course here?01:47:29
we compile everything here01:47:31
compiled I hope I hope we have01:47:34
everything will work now, so what if it doesn’t01:47:37
it works, I'll try to figure out why it is01:47:39
didn’t work so well first of all01:47:41
let's define this file01:47:45
that is, in this case we go to in01:47:49
cloud then go to VMS and then write01:47:54
this is the navy and let's try to describe it in01:47:58
in this case what are we doing we are the label01:48:00
do further label plus it speaks about01:48:03
function as it will be called below01:48:06
need to load two lauth arguments01:48:08
-3 in this case what is it why exactly01:48:13
-3 address the whole point is that01:48:15
the first argument is what address it is at01:48:17
there is 1, that is, we skip the address01:48:20
associated with this very mark gave two01:48:23
this is the second argument and 3 is the first01:48:25
the argument is exactly the same with the second one, that is01:48:27
1 2 and 301:48:28
that is, we take the second argument further01:48:30
we use the ap operation that is01:48:32
we add these two values and the result is this01:48:35
operation in this case this operation01:48:40
returned only one value01:48:41
accordingly this value is for us01:48:43
must be saved, that is, indicate01:48:46
minus 4 minus 1 why minus 4 that is01:48:48
this is 1 then 23 skip the second01:48:51
argument and 4 Matt the fourth argument we save then01:48:54
there is all conservation will occur01:48:56
only on the first argument, well01:48:59
accordingly, what do we do next?01:49:00
that is, we release this stored01:49:03
meaning and01:49:04
return the result of the function all01:49:07
save and now let's try01:49:09
run that is clear01:49:12
further let's here as here through us01:49:16
when this is all done, well, let's try01:49:20
so indicate in a moment tags01:49:24
we have 0 back, well let me try01:49:27
see what we need of course01:49:33
let's try to start it again01:49:35
Let's check that we have returned the value 501:49:42
finally we have already developed something01:49:45
ok now let's check it out01:49:48
does it work with big big01:49:50
humidity, let's say we'll be here, well01:49:53
more precisely01:49:54
first on initial nesting01:49:56
check the question 244 plus 37 works01:50:00
then we check another nested like this01:50:03
let's get more nested here01:50:05
let us have deuces everywhere so that01:50:08
easier to check check 14 times two three01:50:13
4 5 six 7 before this 14 next we can01:50:16
nesting somewhere else here01:50:18
do check 18 times two three 4 5 6 701:50:24
8 9 9 multiply by 8 us is correct and look01:50:28
what are the interesting features of this one01:50:30
the very function from well that we wrote01:50:32
in assembly language directly it01:50:36
it works quite normally, that is, it01:50:39
works like normal function of this01:50:41
the language itself is not01:50:44
do you know a separate operation like01:50:46
let's say in imperative languages where there01:50:49
let's say the operation is built in by default01:50:51
plus by default stitched operations01:50:53
multiply and divide subtract and so on01:50:55
in this language these operations are01:50:57
ordinary functions and we can also01:50:59
how to connect a regular function but it’s true01:51:01
the only exception here is that these01:51:04
operations can only be implemented if01:51:06
using assembly language, that is, more01:51:08
low level but nevertheless their01:51:10
Can be connected as normal functions01:51:13
and let's see how we have this code01:51:16
at all transferred to01:51:19
assembly language representation01:51:21
that is, in this case, look we01:51:24
created01:51:25
label label start which is01:51:28
the beginning but in this case we are under the beginning01:51:30
as you understand, did the following wherever01:51:34
this mark was not there let's find it already01:51:37
in the end so stop start yes there you go01:51:44
she is a mark and we made her first01:51:46
then we connected this one01:51:48
the assembly code that we indicated is like this01:51:51
let me restart this01:51:53
we forget that everything can be seen there01:51:56
everything here is finally working for us01:51:59
then so and this is the same code it’s simple01:52:03
how copied let's go here01:52:05
again turned on, it was simply copied01:52:08
Next, what do we do? We call the function.01:52:11
mine and here it started01:52:13
that is, by the way, let's do this operation01:52:16
let's make pop more beautiful01:52:17
where we have here pop pop yeah right here01:52:21
hear you do and here also hear you and01:52:25
here red hear01:52:28
or compile back and look at the code01:52:33
like this again somewhere no means no01:52:37
that place right here you can hear again01:52:43
piri-piri we compile more and more than me01:52:49
it's beautiful here as you see all these01:52:51
operations are collected in this case as well as01:52:53
you see this translator here already01:52:56
able to analyze quite well01:52:58
action must be performed in what01:53:00
okay, that is, he is capable in the first place01:53:05
process the entire linear01:53:06
subsequence01:53:07
given if the media follower is01:53:09
linear it is already distributed between01:53:11
look at how you can these01:53:13
sequences linear and nonlinear01:53:14
let's do this in this case01:53:16
removing here let's say 2 and 201:53:19
let's compile and check the result and here it is01:53:23
two plus two01:53:24
that is, in this case, everything is yours01:53:26
Fine01:53:27
countries merged let's go further further we01:53:29
we can make it linear01:53:30
the sequence is like this and01:53:34
we are pushed push push push and then this01:53:37
the transmitter remembers what we had01:53:39
some meanings and these meanings were01:53:41
it will be nested accordingly01:53:43
perform a certain task every time01:53:44
withers procedure01:53:46
but at the same time if it is not01:53:48
linearity01:53:49
that is, in this case it’s not01:53:51
is linearity, let's see what happens01:53:54
us here01:53:55
22 plus gave 2 plus because01:53:59
impact first calculated this01:54:01
passed this was calculated together with this and here it is01:54:05
so that's how it is and in the end that's basically it01:54:08
we can already do the expression now01:54:11
let's try to implement everything01:54:14
a list of ordinary khaman is acceptable there01:54:16
add multiply and divide subtract this01:54:19
we must do everything with the help of language01:54:21
assembler, but nevertheless, by the way, you can01:54:25
to say that we are multiplying in fact01:54:27
we can do it through addition and let's01:54:29
We'll try to do this later, of course.01:54:31
this is all01:54:32
let's translate it into assembly language so that it is01:54:34
more efficient because multiplication01:54:37
of course you can do this through addition01:54:39
but still we can do it01:54:40
let's do it, we multiply here01:54:43
this is how we will call it01:54:45
here x y and what we will do in01:54:48
first we will check the example if y01:54:52
will be equal to tea or and will be01:54:56
dress01:54:58
let's say zero then return 0 that is01:55:04
this is 0 0 otherwise if we have y here01:55:12
less than 0.01:55:17
let's do it the other way around here y is greater than 0 we01:55:22
multiply x by x by x principle then01:55:30
multiply x by here x and then this is more accurate01:55:36
add apologies here when01:55:37
give him the pressure01:55:39
perform this operation x and here we are01:55:42
subtract one from the game01:55:45
y is one otherwise we return one01:55:51
01 well let's try this me now01:55:54
To be honest I haven't checked this code01:55:56
we'll try to make it but we need it for this01:55:58
I need another operation to do this01:56:00
let's try to do it ourselves and describe it01:56:04
sub navy and here we change the minus sign01:56:09
and here we further connect here with us01:56:20
there will be a garden01:56:22
let's do sap like this and here01:56:26
we will be here again by the way01:56:29
to say what we will have here01:56:30
Hitler you01:56:31
We will also have more equality, well01:56:36
that is, we will have conditions, let's give them01:56:39
Let's also add that in this case and01:56:41
qual. we will do a naval force and then we will have01:56:45
also glitter. navy01:56:51
if I'm not mistaken then we are we greed01:56:54
or we use this yes yes we use01:56:57
grid let's try to implement them01:56:59
directly that is in this case01:57:00
what are we doing we are creating a label01:57:02
equals equality further load01:57:05
first argument load second01:57:06
argument01:57:07
further if that is in this case if01:57:16
they are equal these two arguments then we01:57:18
should go to this very label label01:57:22
equals 0 otherwise here we also have01:57:25
there should be another mark01:57:26
which will be equal to one and also01:57:29
we also have to have it otherwise01:57:33
label called like label and here01:57:38
like this here she will just take01:57:40
the result and put it into the value minus 401:57:44
we'll have it here01:57:45
Herod further here we are what are we doing01:57:51
unit and Jenkins on n that is01:57:55
equals m, otherwise here we push mole and01:57:59
basically everything is like that until we push it says01:58:12
about the fact that our value does not equal that01:58:15
there is accordingly here john equals01:58:17
1 everything is like this, that is, if01:58:21
these two values are equal then it will return01:58:23
units if these values are not equal01:58:25
when will mine come back everything is like this01:58:27
usually we copy exactly the same way01:58:29
insert oh .01:58:31
sorry to grid we translate here01:58:34
there will be more further here more more01:58:38
here we change everywhere this is a sign more01:58:43
more and here is Jack Ritter in principle01:58:47
that's all we do now let's get here01:58:49
let's connect this dream mushroom and then here01:58:56
there will be more of us, so come on01:58:59
let's check if we have it at all01:59:01
first of all let's just run it like this01:59:04
us01:59:05
translation error translation error could01:59:08
and let's remove it like this accordingly01:59:11
somewhere there is a mistake here let me01:59:15
I'll try to analyze it now01:59:17
I'll be back so I fixed the mistake, I'm here01:59:21
even in a row who is this code but the error01:59:23
It happens01:59:24
the main thing was not that they were here01:59:27
certain mistakes made in the code01:59:30
translator firstly I added air conditioning01:59:33
claus equals one in if statement01:59:37
that is, they were here secondly01:59:40
also mistakes made in define01:59:43
instructions let's find them a year ago01:59:46
the file the larger the unit became wild n01:59:49
more than zero here was the same thing wild n01:59:52
the more one became the more 001:59:55
that's all, that is, these are the main ones01:59:58
mistakes I made sadly from the rules and02:00:03
now let's check and here we have02:00:05
how the algorithm works it doesn't work with02:00:07
odd numbers but nevertheless he02:00:09
work with black numbers here02:00:11
checked if y equals zero then02:00:15
and return 0 further if y is greater02:00:19
units02:00:21
then what do we do we from and we02:00:27
add X to the result of this one02:00:29
recursive function that is, we refer02:00:31
on itself in this recursive02:00:33
function we also add x that is x02:00:36
does not change but is subtracted from the game02:00:38
one and further if y is still not02:00:43
greater than one and not equal to zero02:00:46
this means that y is equal to one02:00:49
we return x that is to zero02:00:52
add x and check what we have02:00:54
it turns out 15 that's right now let's02:00:57
let's try some other value02:00:58
well let's say 10 in the end we have to02:01:02
get 50 get 50 try 100002:01:06
we get 5 thousand, everything works but02:01:09
this algorithm, as you understand, is not02:01:10
effective because it is in this case02:01:12
uses multiplication through addition02:01:15
respectively for a similar02:01:18
optimization we what can we do02:01:21
we can just move this multiplication02:01:24
from high level language to low level language02:01:27
level thereby optimizing our02:01:29
source code final more precise code let's02:01:32
let's try to do it enough02:01:33
easy, that is, we'll just make a mule.02:01:36
VMS and here we simply add multiplication02:01:40
here we change it for us02:01:41
because our virtual machine is02:01:44
supports multiplication operation02:01:46
Well, accordingly, what do we do?02:01:47
we delete all this, we delete it in fact02:01:50
that's all, that is, we are now just02:01:53
change us check here we get that one02:01:57
the same result and this is basically the case02:01:59
we are all successfully functioning and working02:02:03
now let's try it all02:02:04
you lose with such operations then02:02:07
yes let's add02:02:08
subtraction and we have already done subtraction02:02:11
let's add a div division. we do naval forces here02:02:17
div here do deep added let's02:02:21
Let's turn it all off here and concentrate02:02:27
only with this code now what02:02:31
we can still add02:02:33
we still have it, let's add it here02:02:36
operations02:02:37
more and not equal even less and not equal02:02:42
VMS further add here let us02:02:46
will not be equal02:02:48
fact not equal not exactly not equal we all02:02:54
it's all added here02:02:55
g not equal we change all this we don’t02:03:01
let there be quality and we should too02:03:05
be a lawyer well let's change that02:03:07
number . Navy here we have this sign02:03:12
let's try to change it to the opposite02:03:14
we directly change it all with us02:03:20
there is a new feature now that we02:03:23
more we can do here we can by02:03:25
in fact02:03:26
write this function that will02:03:31
return other functions to us because02:03:32
by default our language does not do this02:03:35
capable but let's try it02:03:37
we'll do the next label02:03:40
then we indicate the ricker and here we are02:03:45
we do we load the first argument02:03:47
and we return the same argument02:03:51
-1 do for red in the end this way02:03:55
we will be able to return it ourselves02:03:58
functions as the result and this is02:04:02
quite useful because it's us02:04:04
can be used in these very02:04:05
arguments let's try this02:04:07
directly done using02:04:10
eterno let's have it here02:04:12
define let's say it x y let's say x here02:04:18
plus y let's add this right away02:04:23
So02:04:24
in cloud navy and . navy02:04:27
Well, let's also add this same red02:04:31
Danish Navy02:04:33
let's also add a comparison operation02:04:37
navy02:04:38
and qual. Danish Navy what we do we02:04:41
we can multiply here02:04:43
values that is, we can make mun02:04:47
do it like this we will have it02:04:49
function definition look like so on02:04:52
what can we do we can do02:04:54
the following make conditions if let's02:04:59
although we’ll do it you know how through a separate one02:05:02
let's say the function will be with us for a year02:05:06
and here we will have some02:05:07
parameter x further if x equals02:05:11
zero then we will have to return02:05:13
functions02:05:14
otherwise it will come back in the face of a mule02:05:18
and see what crazy things we can do02:05:21
g let's here my grandfather that is this02:05:27
addition and we now apply this02:05:30
operation that is, we return from and02:05:32
we can do the following let's say 5302:05:35
let's check if we have it02:05:37
function we got the result02:05:40
8 that is, the function from now we is returned02:05:43
we can change this to one let's check02:05:45
we returned the value 15 and at the same time02:05:48
we can use the same02:05:50
returned result as result02:05:53
another function as argument another02:05:54
functions that is define let's say set f x02:05:57
y and what we'll do we'll just apply02:06:00
f by x y and see what we have in02:06:03
plus let's even do this02:06:05
let's say plus 1 and here we will do more02:06:10
so we check plus 2 as an example02:06:16
the result was 35 and added 6 402:06:20
added to three added 2 that is02:06:23
further here we got 5 here y02:06:26
we got it more precisely here02:06:28
it turned out 6 here it turned out 5 next we02:06:31
applied function f and function f is02:06:34
multiplication and in the end we multiplied 6 again02:06:37
multiplied by 5 and got the result 3002:06:39
this is basically how we02:06:42
constructed higher order functions then02:06:44
there is a function that can accept02:06:48
includes other functions and which are capable02:06:50
return other functions i.e. this02:06:52
called higher order functions02:06:53
quite an interesting concept and it’s in02:06:56
basically makes programming easier02:06:57
very much so and so we are02:07:02
done only with the help of the fact02:07:04
the main functions are like this02:07:08
reacts like this:02:07:09
returns another function02:07:10
well now let's do some more02:07:12
any other functions that are already02:07:15
will find which will already be02:07:17
be these functions of this very02:07:19
language let's call it here under loading as02:07:23
let's say gender is part of this language02:07:26
well here's what we're going to do let's02:07:30
here we will immediately delete it and here we will be02:07:35
do the following let's say here02:07:40
let us have no logical02:07:42
operations that is, we do not have operation and02:07:44
it's a sour note let's try them02:07:47
implement and let's say here hall and02:07:52
and can be implemented as follows02:07:54
so here we have plus will be define02:07:58
let's include the schema syntax here02:08:04
this can be implemented quite easily02:08:06
that is, we take two arguments x and y02:08:08
further if x is not equal to zero then02:08:15
check the following condition02:08:17
otherwise we return 0 further if y is not02:08:23
equals zero then we return here02:08:29
0 and here we return units this is an operation02:08:33
and we can, in principle, even02:08:34
try to do it, that is, let's02:08:36
let's dive into the cloud further02:08:38
[music]02:08:40
include all and .02:08:43
and also don’t forget about these same ones02:08:47
Let's just say these functions are not02:08:49
will show the automatic VMS does not load02:08:52
functions according to the necessary fax02:08:55
again nothing is loaded here02:08:57
it's expensive, we need to load02:09:00
additional functions, that is, no02:09:01
equals and plus well let's do it02:09:04
let's try to do this IUD further, but you02:09:08
qual and exactly the same, we also change the IUD02:09:13
and then that’s all, use the and no function02:09:19
1 and 0 let's say so here we have what02:09:28
that's not true02:09:33
well, let me try to go back and02:09:35
check error02:09:37
Well, of course I stepped, I loaded02:09:42
high level language to low level02:09:45
languages Lord we have this low level02:09:48
languages accordingly we do in the cloud02:09:49
and load this function now02:09:51
everything is checked by the writer 0 everything is more correct02:09:57
let's try with one liqueur one all02:10:00
that's right, next we'll try with zeros02:10:03
0 everything is correct, that is, in the end we have02:10:06
the and operation works successfully now02:10:09
let's try with other operations02:10:11
we implement other operations in the same way02:10:13
here we will add about .02:10:16
all and try this very operation02:10:18
implement that is in this case02:10:20
define well, let's go without backlighting02:10:23
syntax for x and y and we will have here02:10:26
the following if x is not zero then02:10:33
we add one, that is, then02:10:36
the mass is returned directly02:10:37
units otherwise what do we do if y is not02:10:42
equals zero then we return02:10:47
unit02:10:48
otherwise we return zero zero that is, otherwise02:10:51
this will indicate that x is 0 and02:10:54
y is equal to 0 and that’s all, now let’s dive02:10:57
the same operation02:10:58
and check02:11:03
unit02:11:04
true 0 here we have units02:11:07
that's also true yes I'm here let it be 0102:11:10
true and check with zero true here02:11:14
so we have implemented now02:11:16
let's try the laptop operation02:11:17
implement all these operations for him now02:11:20
let's say we implement it and our language will be02:11:22
to have at least some kind of02:11:24
library and in this case define further02:11:27
not x this is what happens if x equals02:11:32
zero then accordingly we have02:11:34
[music]02:11:36
returns units that is how back02:11:39
otherwise it returns 0 that's all and now02:11:44
let's try02:11:46
let's implement it right away02:11:51
By the way, these are all the functions so that they don’t exist02:11:53
no problems there02:11:54
and qual further under detailed functions logo02:11:58
bath for other functions glitter and02:12:02
other functions02:12:03
addition, multiplication, subtraction, and so on02:12:05
further further02:12:09
and div than all these functions02:12:14
cut directly and further from us02:12:18
there will be more flux and come on, here it is02:12:21
takes only one argument02:12:22
check one if we are one02:12:26
we transmit 0 all the lightest logical ones02:12:31
we completed the operations what about who02:12:33
that is, as you know in languages02:12:35
programming in addition to operation and02:12:38
or but there are no logical ones02:12:41
Still such an operation is like rubbish, it is very02:12:43
often used on certain02:12:45
numbers but nevertheless let us give it02:12:47
implemented in the form of a logical02:12:49
The operation is not a bit one, but a logical one02:12:52
let's try to do this too02:12:54
It's somewhat easy to do, but more difficult02:12:57
here we will try let's use02:12:59
comments and syntax highlighting here02:13:01
in principle, it will be useful for us, let's quarrel and02:13:05
further here we will define variety x02:13:09
or in this case to determine02:13:11
function cos x y02:13:13
need to do the following first02:13:15
apply an operation on two arguments then02:13:18
there is first argument both must argument02:13:22
about going through02:13:23
and but here we have business next in02:13:25
first notes x y02:13:27
and secondly, here x is a raccoon y that’s all02:13:31
accordingly we need this02:13:33
implement that is, in this case it’s time02:13:34
next and let's go here02:13:37
and end we will do here not x y02:13:42
and here x0 y0 all this is the whole operation02:13:48
give it away and import it but to02:13:50
import we need to connect02:13:53
operations about which she is from02:13:58
depends and directly in fact we02:14:00
we can do all these clubs in these02:14:02
files, that is, which depending on02:14:05
some other files, that is, nothing02:14:07
such02:14:08
Let's just say there's nothing criminal about it, but02:14:11
nevertheless, in this case we are all this02:14:13
let's do it here now let's do it02:14:16
what does ksor do if these are numbers?02:14:21
different that is, if the bits are different it means02:14:23
will return ones if the bits are the same02:14:26
it means it will return 0 let's check the make02:14:29
and returned 0, then check with zeros02:14:32
returned 0, then check with one and 102:14:36
returned to the bath units, check here02:14:39
the unit returned, we sold everything according to02:14:42
fact in sight now let's get down to it02:14:44
some other functions are allowed02:14:46
modulo division is very common02:14:50
function is often used and very02:14:52
useful firstly it is often used02:14:55
in certain algorithms similarity02:14:57
greatest common divisor but in addition to02:14:59
everything else it is used for02:15:01
definitions of numbers are neither even02:15:03
or odd02:15:05
and let's try to implement this02:15:07
the function itself and and we can implement02:15:08
using division after the fact, subtraction and02:15:12
multiplication and let's try this02:15:15
do that is, in this case we create02:15:18
new feature called like mod.02:15:24
so here right away this is nothing we are not02:15:27
we will use here we will have02:15:29
stick further and here mod.02:15:32
let's try to do it in this02:15:34
case we can make a mod let's say02:15:37
groan, well, let's say 20 let's say 27 302:15:43
give 0 here we define mod mod will be02:15:48
be determined as follows, that is02:15:50
x y equals x minus y times02:15:55
by x divided by y this formula is02:16:00
modulo division accordingly we02:16:02
we can easily implement that is mod x y02:16:05
we continue to do what we do first02:16:08
subtraction that is, x is subtracted from to02:16:11
multiplication by y and what we do next x02:16:15
we divide everything by y in this way02:16:18
it's implemented now let's try it02:16:22
we check and we have returned the value 8 in02:16:28
in this case, of course it is enough02:16:31
it’s difficult to edit although what am I talking about here02:16:34
there is always a calculator at hand groan02:16:38
divide modulo by 23 8 everything is correct as you02:16:41
see we really already have it02:16:43
it works and we implemented it as you can see02:16:45
functions in fact from scratch, that is, we02:16:47
we use only the basis of the language02:16:50
programming we use its core02:16:52
and here the important principle is functional02:16:55
language they are good at they always have the core02:16:58
very small, that is, I don’t really know02:17:00
let's take the same sheet core02:17:03
just minimally that is, well, as you can see02:17:05
indeed this is so next let's take that02:17:08
same husky core if you look at it02:17:10
the core is just as minimal, that is02:17:12
it defines certain02:17:14
basic functions basic instructions but02:17:16
thanks to them these instructions are very helpful02:17:19
grow, that is, let’s say from three02:17:22
basic instructions we can hundreds of others02:17:24
give rise to this very useful property02:17:27
and in this case we apply the same02:17:29
the most criterion let us now thanks02:17:31
mod functions we implement functions02:17:34
[music]02:17:36
so let's say the receiving function is02:17:39
number02:17:40
whether the number is even or odd02:17:43
let's try to do this, that is02:17:44
even number first02:17:47
it will be implemented as follows02:17:48
define Ivan Tax define ln x and in this02:17:54
case, what do we do if mod x by 202:17:59
will be equal to zero this is all Ivan in02:18:02
basically let's chop him down02:18:05
of course, mode dependence is used02:18:07
that's why we don't remove it anywhere and now02:18:09
let's check lm-100 whether it will be up to02:18:14
units02:18:15
Well, let's say there's 124 multi it up to if02:18:20
we will do 125 will definitely come back mine02:18:23
as you can see everything works for us02:18:25
let's go and further we can also chop02:18:28
from that is, not parity in this case02:18:32
we can express from via Ivan either02:18:34
express it in exactly the same way only not equal02:18:37
register and in principle this is accurate with us02:18:40
should also work, that is, in this02:18:41
in case we just change to from and now02:18:44
checking02:18:46
now we should return unit a02:18:49
if we do 124 should right should02:18:52
return 0 that's right right now let's go02:18:54
further further we can do the construction02:18:57
exponentiation well exponentiation02:18:58
it's quite easy to do02:19:00
that is, let's have a floor here. let's do a wolf02:19:04
and here we will write the construction function02:19:06
to the power, that is, x y, let’s raise02:19:09
in the chicken cap next what we have02:19:11
done here02:19:12
if y is less than one then we do02:19:18
next we return one otherwise we02:19:21
multiply02:19:22
x to the result of this very function x from y02:19:26
minus 1 is actually like multiplication02:19:29
the most was y minus 1 now let's02:19:33
let's check what it is, that is, multiply02:19:37
let's say 2 by 10 here we connect the floor and02:19:44
basically there seems to be no dependencies02:19:47
No Let's check so the units are back now02:19:53
if y is less than one then something is here02:20:04
obviously not true, so let's check additionally02:20:06
us and02:20:07
x y if y is less than one then return02:20:12
1 so let me see, I'll come back02:20:18
looked around and came back here we need02:20:21
I just had to transfer the tax here02:20:24
forgot there was a g-grip here02:20:26
I have now applied to so here we don't have02:20:31
no more mistakes like this gin you02:20:34
qual next02:20:39
it seems there were no such errors and here we are02:20:41
This function doesn’t seem to exist anywhere else02:20:45
used yes if I'm not mistaken of course02:20:47
in theory, it seems like nowhere else02:20:49
used ok now let's check02:20:52
returned 1024 everything is correct that is two02:20:55
evolved to the power of 10 here we also02:20:59
we can let him have 5th degree there02:21:01
let's say 5 returned such a number 5 in02:21:04
power 2 we can through this function02:21:07
let's express another function as under02:21:09
name like square x and then we just02:21:11
Can02:21:12
raise pix to the power of 2, let's do it02:21:15
let's try to do it here02:21:16
square 5 check it turned out 251102:21:23
it turned out to be 120, that is, in this case,02:21:25
it all works correctly for us02:21:28
now let's continue02:21:30
we can also do negative things02:21:32
number, that is, just change the sign of it02:21:34
the very date let's try it02:21:36
make nickname02:21:37
and in this case it will look like02:21:39
define nickname x as follows and here02:21:42
this is all done quite easily minus02:21:44
0x we are all checking whether we will have it02:21:49
work let's say nickname 11 the same02:21:51
the number here is a sign by others we check like this02:21:56
but for some reason it didn’t happen here anymore02:22:01
why so nick nick02:22:05
x Well, in theory, everything is correct here, if not02:22:09
I'm wrong02:22:10
of course, let me check02:22:12
again what is the problem02:22:14
well, the problem is quite enough again02:22:17
I'm stupid, I'm just Agnes, Nick VMS, let's do it02:22:21
Here we define this not as a book.02:22:23
further here vms here delete this file02:22:27
to all my friends now let me be here02:22:30
Nick 11 experimented a little here and02:22:33
insert that here we have 11 here we have02:22:36
maybe some other number02:22:38
well, and accordingly if the number is minus02:22:40
she is also considered a plus02:22:42
but in this case we can also minus02:22:44
express it a little differently, well, let’s say02:22:47
minus 0 and then minus by minus gives02:22:50
directly plus so now let's go02:22:55
further we basically have more functions02:22:58
there is little left so we02:23:00
we can implement them and well, first of all02:23:02
let's try to implement the function02:23:03
max and y that is, in this case it’s simple02:23:06
take the maximum number from two numbers02:23:08
define further max x y and further if x02:23:15
more y and this means that we02:23:18
need to return them accordingly02:23:19
do plus 0x otherwise we do plus 0 y02:23:23
and in principle all this is max02:23:25
now we are making a meme that is. him and her02:23:30
we write exactly the same way, that is, died02:23:31
only here we make a minus and in principle02:23:34
everyone now what else can we do we02:23:39
we can implement the function less or02:23:41
equal to or greater than or equal to02:23:44
functions that we don’t have by default02:23:47
in a virtual machine the edge of the virtual02:23:48
there are only 4 conditional02:23:51
function this is not equal to less than or02:23:53
there is no longer a function less than either02:23:56
equals and there is no function anymore either02:23:58
anyway, but in fact we can02:23:59
implement this in a high-level language and02:24:02
let's try to do it easily, that is02:24:04
let's implement the function let's call it as02:24:11
greater than or equal to equol.02:24:16
and here we will do the following that is02:24:19
define further done x y and further here02:24:25
we'll make the next one if it's bigger02:24:30
x is greater than y or x is equal to y02:24:35
then we return directly02:24:38
one otherwise we return 0 that's all02:24:42
that is, in this case we did02:24:44
let's try to see the next one02:24:47
be it for us to work g aqua in02:24:52
in this case greater than or equal to 5502:24:55
let's check what happened here02:25:02
let's see if x is greater than y and x02:25:10
and here I apologize, I got confused here02:25:14
let's restart so confused here02:25:18
define is greater than or equal to x y danin02:25:21
if here let's do it right away like this02:25:23
we'll do it if we write it down here right away02:25:28
here x is greater than y and x is equal to y then we02:25:33
we return one otherwise we return 002:25:38
let's check like this02:25:43
sorry here we have it coming back02:25:47
-1 so let's see what we have02:25:51
Here's the problem and I'll come back again02:25:55
how I discovered the problem02:25:57
Well, of course, this problem is also not in my mind02:26:00
shines like the previous problem, here I am02:26:02
I just forgot to connect it, that is, by02:26:08
fact or operation and nothing more02:26:10
let's check here we get02:26:13
one was given if 5 is more than either02:26:16
equals 10 mass will return of course 002:26:19
and if 5 is greater than or equal to three y02:26:23
unit will return us, that is, in this02:26:25
in the case of the north, based on this we also02:26:28
let's try to make the operation smaller or02:26:30
equal, that is, in this case we will do02:26:33
lawyer and qual. v.m. Itachi's02:26:36
I'm sorry and I tried it again here02:26:39
make a laurel and a qual here.02:26:43
he and here we will try to do this02:26:47
is less than or equal to02:26:48
and further here we can do the following02:26:51
that is, both and02:26:54
well, here we just change the sign02:26:57
and nothing more02:26:58
now we check here we do we check02:27:04
here 5 is less than or equal to three no02:27:08
accordingly we will return returned 002:27:10
further 5 5 unit returned further 5 and 1102:27:16
came back alone while here with us02:27:19
will return directly 0 so a jay02:27:25
glitter will come back my that is in02:27:32
In this case, in fact, everything is correct02:27:34
now now we can in theory02:27:39
let's implement some algorithm02:27:41
let's try to make it easy there, let's say02:27:43
factorial algorithm greek well there02:27:45
fibonacci greatest common divisor02:27:47
maybe and so on let's do it02:27:49
let's try to do it right away in this case02:27:52
we will simply assume factorial in other ways.02:27:54
floor and here we will implement it all02:27:57
let's say factorial of 10 in this case02:28:00
if you remember that factorial is only02:28:02
multiplication several times defined02:28:04
numbers to yourself in this case02:28:07
this is a fact x and equals further02:28:10
compares if x is zero for you02:28:15
will come back02:28:16
units otherwise we will continue02:28:18
factorization that is in this case02:28:20
needs to be multiplied02:28:22
x to the result of the function fact x minus 102:28:27
that's all, now we check 0 in this02:28:30
case factorial and here we do not have02:28:32
no dependencies used02:28:34
checking the libraries, here we are back02:28:38
the result is, in principle, the factorial is correct02:28:40
is it equal to this then we can there02:28:42
reduce the value let's say to 502:28:44
us factorial is now equal to such and such in02:28:48
in principle, we can, by the way, besides everything02:28:50
other things if we suddenly need02:28:53
you know some kind of optimization because in02:28:57
In this case we have tail recursion02:28:58
tail recursion is used02:29:00
ordinary linear recursion linear02:29:03
recursion or even tree-like02:29:04
recursions they are not optimized started02:29:07
linear recursion capable of tail02:29:09
redo and then using the tail02:29:11
optimization of this very recursion has already02:29:14
optimize into a loop02:29:16
but nevertheless our high-level language02:29:18
it does not support so we can by02:29:20
in fact, rewrite this very factorial to02:29:22
low-level language that is, a language02:29:24
assembler and then run the same function02:29:26
let's try to do that in02:29:27
in this case we are for including now02:29:29
only loot navy. fact . vms and copy02:29:33
this is due to the benefit of virtual machines02:29:34
this virtual machine already exists02:29:36
function that is, here it is simply and and02:29:38
copy and paste here02:29:40
Let's create more precisely a fact file. bms leave02:29:45
and in this way and now let's02:29:48
let's run let's try to run mike and02:29:51
exactly the same 120 that is, as you see we02:29:54
already02:29:55
connected this file but at the same time this02:29:59
the file is more optimized because in02:30:01
in this case there is no recursion here02:30:02
we are not there, unlike this you know02:30:05
how can we even check this in this02:30:08
there is no point in checking here02:30:10
of course, but here we can have02:30:13
it makes sense to check here let's check here02:30:15
we will register the gender here we will register it here02:30:18
us fact of childhood it also works but02:30:20
now we'll just go to the directory02:30:22
We will connect this VMS file here next02:30:28
assembly listing and further see02:30:30
as we do here it’s more accurate to include all02:30:34
let's clear my everything here in theory02:30:40
owes us02:30:41
file so oh sorry not that file02:30:47
I see we should have it now02:30:51
see the following code here02:30:54
factorial and it now calls itself02:30:57
that is, in fact these are recursive calls02:30:59
the same factorial on the very02:31:00
himself and only then does he collect all these02:31:05
results and multiplies them like this02:31:08
this way we actually get recursion but02:31:11
she, as you understand, is enough02:31:14
bad let's say and a view that is not02:31:17
optimized normally and so on02:31:19
let's try something else and02:31:20
Fibonacci will not allow implementation02:31:22
fibonacci but that's already a movie give me02:31:25
aol and let's try to do this, that is, in02:31:29
in this case02:31:31
Fibonacci 0 is connected here fib and in02:31:36
in this case define given fibonacci from x02:31:40
further if x equals zero or x the02:31:45
matter minus less than one then02:31:48
return x otherwise02:31:51
what do we have to return by the way here iv i02:31:53
of course I forgot, let's lock here02:31:56
it is very easy to get confused in fact in these02:31:58
foliage expressions well one way or another02:32:01
fibonacci x then if02:32:06
Let us further assume that if x is less than one then02:32:12
and return x otherwise what are we doing this by02:32:15
the fact of addition, that is, Fibonacci02:32:19
let's do the same here again02:32:24
then fibonacci from x minus 2 x02:32:29
minus 1, in theory, I’m checking to see if it will work02:32:34
We generally check how it works02:32:37
1002:32:38
we launch the reader like this -55 why is that so02:32:45
Why do we have a minus? Well, if x02:32:52
and if x is less than two glues up to a year with us02:32:55
55 now we can, well, let's say there's 802:32:58
check if it will be 22 next with us02:33:02
2221 more precisely 21 + 13 should be 3402:33:07
let's check here 34 yes that is with us02:33:11
in this case it all works successfully02:33:13
and 21 plus 34 equals 55 here in02:33:16
basically everything is like this02:33:18
we actually implemented the language02:33:20
programming as you see it is quite02:33:22
he works while he is clean02:33:25
functionally high programming in02:33:26
we can't bring any arguments here02:33:29
put from a standard stream of water we02:33:32
we can't get any arguments02:33:34
standard output because we02:33:35
we produce this conclusion through another02:33:38
program, namely through a virtual02:33:39
car02:33:40
the virtual machine gives us the result:02:33:42
the language itself it is not capable of this language itself yes02:33:46
and in principle that concept of virtual02:33:50
she can't do anything with a car02:33:51
produce02:33:52
input-output therefore the language is so clean02:33:55
functional purely mathematical and02:33:57
got it, in principle it is possible to solve02:34:00
enough but as you noticed enough02:34:03
there are a lot of tasks and that’s probably all02:34:06
I hope I explained more or less clearly how02:34:08
this is implemented like this is all02:34:10
reproduced as much as possible02:34:12
improve this language02:34:14
to infinity we can still do a lot02:34:17
a considerable number of different functions02:34:19
add mathematically that works02:34:21
with numbers because our language is02:34:23
capable of working in fact only with02:34:25
numbers but one way or another all the links I02:34:30
Of course I leave it in the description there with02:34:32
link to the virtual machine you are02:34:34
you can download there and a link to this02:34:36
the most programming language you can02:34:38
you can check it02:34:39
you can analyze it02:34:41
edit well and that's it for now02:34:43
everyone good luck everyone byeDescription:
Исходники: Виртуальная машина: https://github.com/Number571/CVM Язык программирования: https://github.com/Number571/ALLang Таймкоды: 00:00:00 - Введение 00:08:23 - Интерфейс программы 00:23:28 - Начало написания 00:32:28 - Функция readtall_src (интерфейсная функция) 00:44:28 - Функция _parse_code (главная функция анализа кода) 00:57:37 - Функция _include_instrc (подгрузка файлов расширения .all) 01:02:12 - Функция _load_instrc (подгрузка файлов расширения .vms) 01:03:30 - Функция _define_instrc (создание функций в языке all) 01:20:24 - Функция _proc_instrc (чтение выражений в языке all) 01:35:44 - Функция _if_instrc (условное выражение в языке all) 01:44:20 - Исправление ошибок компиляции 01:47:30 - Создание функции сложения 01:54:24 - Создание функции умножения методом сложения, добавление функции вычитания 01:56:30 - Создание функций условия на равенство 01:59:18 - Исправление ошибок в функциях _if_instrc и _define_instrc 02:01:08 - Перенос функции умножения на низкоуровневый код 02:02:02 - Добавление функций деления, равенства, возвращения функций 02:04:10 - Пример функций высшего порядка 02:07:11 - Создание логических функций and, or, not, xor 02:15:15 - Создание функций mod, even, odd 02:18:54 - Создание функции возведения в степень 02:21:30 - Создание функций neg, max, min, (больше или равно), (меньше или равно) 02:28:00 - Функция вычисления факториала 02:29:20 - Оптимизация факториала 02:31:18 - Функция вычисления чисел фибоначчи 02:33:15 - Завершение
Preparing download options
* — If the video is playing in a new tab, go to it, then right-click on the video and select "Save video as..."
** — Link intended for online playback in specialized players
Questions about downloading video
How can I download "// Алгоритмизация #9 // Язык программирования //" video?
http://unidownloader.com/ website is the best way to download a video or a separate audio track if you want to do without installing programs and extensions.
The UDL Helper extension is a convenient button that is seamlessly integrated into YouTube, Instagram and OK.ru sites for fast content download.
UDL Client program (for Windows) is the most powerful solution that supports more than 900 websites, social networks and video hosting sites, as well as any video quality that is available in the source.
UDL Lite is a really convenient way to access a website from your mobile device. With its help, you can easily download videos directly to your smartphone.
Which format of "// Алгоритмизация #9 // Язык программирования //" video should I choose?
The best quality formats are FullHD (1080p), 2K (1440p), 4K (2160p) and 8K (4320p). The higher the resolution of your screen, the higher the video quality should be. However, there are other factors to consider: download speed, amount of free space, and device performance during playback.
Why does my computer freeze when loading a "// Алгоритмизация #9 // Язык программирования //" video?
The browser/computer should not freeze completely! If this happens, please report it with a link to the video. Sometimes videos cannot be downloaded directly in a suitable format, so we have added the ability to convert the file to the desired format. In some cases, this process may actively use computer resources.
How can I download "// Алгоритмизация #9 // Язык программирования //" video to my phone?
You can download a video to your smartphone using the website or the PWA application UDL Lite. It is also possible to send a download link via QR code using the UDL Helper extension.
How can I download an audio track (music) to MP3 "// Алгоритмизация #9 // Язык программирования //"?
The most convenient way is to use the UDL Client program, which supports converting video to MP3 format. In some cases, MP3 can also be downloaded through the UDL Helper extension.
How can I save a frame from a video "// Алгоритмизация #9 // Язык программирования //"?
This feature is available in the UDL Helper extension. Make sure that "Show the video snapshot button" is checked in the settings. A camera icon should appear in the lower right corner of the player to the left of the "Settings" icon. When you click on it, the current frame from the video will be saved to your computer in JPEG format.
What's the price of all this stuff?
It costs nothing. Our services are absolutely free for all users. There are no PRO subscriptions, no restrictions on the number or maximum length of downloaded videos.