) '

~fU:IT - 5)

ru eJJ..Xn.J ru di.v &t.x ~ ,ee.yi ~ · : ~ ru riJ ~ .: ·

. ' \

~
'\

- (,7f.xi.Jfr2,/oa IIJu.nwJl A J ~.·,.

... ' ' l ~ ... ' 't ' • I \'•, .\) \' ·1• ' )'·\_·.

~~
'•

•, --: ~ .r u ~ ' Adl..ve-::vL ~~ ,. ,,~' ·

--) ~ J • • I

-~ - 8.aLK \ ~~ ·~ e:xIJJvy, .·\ . \ ' I q I-

£J<U(l ~ :'. \•~ f '., I \ \

.
', . ' I )

.
-~ ~
 Intro to Artificial
neural network

(LLLl.1UJ.i. ndu,tlt.X. ( AftJ ttJ).

~ mo.In ~ ,1.,, 1s x,,:,1,e ~ , ~ .tl,ur1 .and ~a:.t,,,,

..an .s.dp.ul t}aJ Lan Ju LUt.tf 161' to~u llJa L.lobb•1«a~

~ ~1c·1:(~0 l llw.,.ar,A .au .umncdt.d. :ls'ldALx ;,, ~~ :ls

-G"m . ~ ndtel!1b ~ 4 ~ . .Acvul-

Input Weights

Activation
function

Network Input
ne~
0,
r, • Activation

Transfer
function

'•
Thrnhold
value
ll] lnputs(x 1 ; i x2 ; ••• ,_i:; xn)
• Inputs are the raw data or features sent to the neuron.

Each input carries information (like age, size, price, etc.).

• Inputs can come from the outside world or other neurons.

These are the starting point of the neuron·s decision-making.

IIJ Weights('l'.J,j ~i..w j,

2 .,.,.:, ..,w nj)
Weights decide how important each input is.

Each input has its own weight.

Larger weights make Inputs more influential on the output.

Weights are adjusted during learning to improve the network's performance.

II Transfer Function (I)

Adds all the Inputs after multiplying each by its weight.

• The total sum is called net input ( net1 ).

It prepares the Input for the next decision step.

Formula:

netj = X 1W ii + X2 W2 ) + --- + XnWn j

II Threshold Value ( ej )
A fixed value the total Input must reach or exceed.

Helps decide If the neuron should activate.

Acts like a cutoff or decision boundary.

Makes the neuron selective about when to "fire."

Iii Activation Function ( ip)

• Takes the net Input and threshold into account.

• Decides whether the neuron will activate or not.

Common functions: Sigmoid, ReLU, step function.

Converts input into the final output value (usually between O and 1 or another range).

II Output ( O; )
The final result produced by the neuron.

Used as input for the next neuron or as the system's answer.

• Can represent decisions like YES/ NO, Class A/B, or numerical values.

Output depends on the activation function's result.

• Why is it Called a Neural Network?
Because it's inspired by how our brain works!
In our brain:

• Neurons are connected by synapses.

They pass signals to each other.

In an ANN:

Neurons (nodes) are connected by weights.

They pass numbers or signals forward.

ft Structure of a Neural Network

A typical ANN has 3 types of layers:

1. Input Layer:
Takes the raw data {like image pixels or numbers from a file).

2. Hidden Layer(s):
These layers process the data. There can be one or many hidden layers. Each layer
helps the network "learn' better.

3. Output Layer:
Gives the final result or prediction (e.g., yes/no, cat/dog, etc.).

• Example:
If you're feeding a photo of a fruit, the Input layer might take In the image pixels, the hidden
layers process the color and shape, and the output layer might say 'This is an Apple."

~ How Does ANN Work?

1. Data is fed Into the Input layer.

2. It is passed through hidden layers, where each neuron:

Multiplies the data with a weight.

Adds a bias.

Applies an activation function to decide the output.

3. The result comes out from the output layer.

.. The ANN learns by adjusting the weights using a process called backpropagation
during training.

@ Where Do We Use ANN?

• Face & voice recognition

Medical diagnosis

stock market prediction

Self-driving cars

Spam email detection

Language translation
 Intro to neural network

t j Definition of Neural Networks:

A Neural Network ,s a computer system designed to work like the human brain
It uses layers of art1f1c1al neurons to process information. learn from examples, and make
pred1ct1ons or dec1s1ons - without being programmed with fixed rules Neural networks
are part of Artificial Intelligence (Al ) and help machines solve real -world problems like
humans do

Main Points of Neural Networks:

• Neural Networks are inspired by the human brain and ,ts way of thinking

• They help solve complex problems like image detection. speech recognition. and
pred1ct1on

• Neural Networks learn from examples rather than following fixed rules.

• They are structured in three types of layers Input Layer. Hidden Layers. and Output
Layer

• Weights control the strength of connections and are adjusted while learning

• Activation functions decide whether to pass a signal to the next neuron or not

Biological neuron Inputs Artificial neuron

Dendrites

y
Output

Nucleus
e
•••
linear
function
Activation
function
t ~ Basic Concepts of Neural Networks:

• Neurons:

The smallest working units of the network.

They receive input, apply calculations, and send output forward .

• Layers in a Neural Network:

Input Layer: Accepts raw data (like numbers, images, or tert).

Hidden Layers: Process data, learn patterns, and do calculations.

Output Layer: Produces the final answer or prediction.

• Weights:

Numbers assigned to the connections between neurons.

They determine the importance of input data.

Adjusted during training to Improve accuracy.

• Activation Function:

Decides whether a neuron should activate or stay silent.

Helps the network handle comple,c patterns.

• Feedforward Neural Networks (FFNN):

Data flows only in one direction:

Input• Hidden • Output.

Simple but widely used for basic classification tasks.

• Backpropagation:

A training process where the network learns from its mistakes .

Error Is calculated and sent backward to correct the weights.

Helps the network Improve with each training cycle.

• Training and Learning:

Training: Giving data to the network and adjusting weights based on the prediction
error.

Learning: The process of improving performance by continuously adjusting weights,

reducing errors over time.
 * Representation of Neural Network
A Neural Network 1s like a group of connected layers, where each layer has neurons
(nodes) tha t pass 1nformat1on from one to another - Just like how people pass messages
1n a chain ■ · ■ a ■ 11

• Basic Structure {Layer-by-Layer):

1. Input Layer
• This 1s the first layer
It takes the raw data like numbers, images. or text
Example If you·re predicting 1f a person 1s healthy, the input layer may take height.
weight. and age

2. Hidden Layers
O These are the middle layers that do the thinking •
Each neuron takes inputs, does math (using weights and bias), and passes output to
the next layer
More hidden layers = deep neural network

3. Output Layer
This gives the final result of the network
Example It might say "Healthy" or "Not Healthy", or 1t could be a number like a price

pred1ct1on

input layer hidden layer 1 hidden layer 2 output layer

V Summary:
• Neural Networks use layers of neurons to learn and solve problems like humans

• Feedforward Networks allow data to flow from input to output

• Backpropagation and Train ing help the network learn from its mistakes

• Learning improves the network over time. making 1t smarter with more data
# Appropriate Problems for Neural Networks
Neural Networks are super smart models that can learn from complex, messy, and large
data. They're perfect for tasks where regular rules don't work well. Let's look at where they
really shine:

0 1. Image Recognition

Problem: Recognizing what's in a photo (like cat or dog 3 f!S ).

Why NN is great: It learns from pixels and patterns that are hard to describe with
rules.

~ 2. Speech Recognition
Problem: Understanding what someone Is saying from their voice r"•.

Why NN is great: II can handle accents, noise, and variations in speech.

~ 3. Natural Language Processing (NLP)

Problem: Understanding and generating human language {like translating, chatbots,

spam filters • ).
Why NN is great: 11 can learn meaning from thousands of words an d phrases.

~ 4. Predicting Trends
Problem: Forecasting stock prices Ill. weather ~, or sales.

Why NN is great: It finds hidden patterns In data that changes over time.

~ 5. Medical Diagnosis

Problem: Identifying diseases from symptoms, images (X-rays), or reports !il.

Why NN is great: It can spot tiny details a human might miss.

~ 6. Self-Driving Cars
Problem: Making the car understand roads, tra ffi c signs, people ..-.. I .

Why NN is great: It processes vi suals, sensors, and situations quickly and smartly.

~ 7 . Fraud Detection
Problem: Finding fake transactions or cheating behaviors i i .

Why NN is great: It learns the difference between normal and suspicious behavior.
• Perceptron:

• It Is the smallest building block of an AN N

• Like a single brain cell In the network

• It has one layer. and gives only a binary output I like O or 1)

• It can only solve simple problems (like linearly separable problems)

• Example Think of a perceptron as one Lego block

• Perceptron - Key Points in Simple Words

1. Perceptron is the smallest unit of a neural network.
Think of It like a single brain cell ,n t~e net·.-.ork

2 . It takes input s and give s one output either O or 1)

It's used for binary class1f 1cation (like Yes or No. True or False)

3. Each input ha s a weight. .-.h,ch sho.-.s hov. important that ,nput ,s

More 1111por t Jnt input O higher weight

4 . It add s up the weighted input s then checks ,f the total Is h,gh enough

5. If the totJI ,s Jbove J certain lirrnt ,called J threshold ·,. ,t outputs 1

otherwise. ,t gives 0

6 . Perceptron s use an activation function (like step function) to decide the output

7 . It can only solve simple problems (where data can be separated by a c.tr a,gh t line)

8 . It learns using training data - by ad1ust1ng the weights until the output becomes
correct

9 . It's the foundation of all dee p learning model s

Bigger networks are Iust many perceptrons connected together

10. Introduced by Frank Rosenblatt in 1958 - so ,ts been around a long time but Is still
important'

* Simple Example:
If you re t rying to decide whether to wear a Jacket

• Input Is ,t cold 7 I 1 or 01

• Output Wear IJcket O

1. Don t O
0

• Perceptron learns to make that dec1s1on I

Weights
Constant 0 -
\.:_J-----.. WO

inputs

Source
Single-layer Perceptron

Single Layer Perceptron has just two layers of

input and output. It only has single layer hence the
name single layer perceptron. It does not contain
Hidden Layers as that of Multilayer perceptron.

Input nodes are connected fully to a node or

multiple nodes in the next layer. A node in the next
layer takes a weighted sum of all its inputs

Multi-Layer Perceptron (MLP)

A multilayer perceptron is a type of feed-forward

artificial neural network that generates a set of
outputs from a set of inputs. An MLP is a neural
network connecting multiple layers in a directed
graph, which means that the signal path through
the nodes only goes one way. The MLP network
consists of input, output, and hidden layers. Each
hidden layer consists of numerous perceptron's
which are called hidden layers or hidden unit.

0
 I r· ' ; I : •. ' 'I •

BA<:~ £..RDPAGiATION ru~T lOD~

BPrU , .
1 \ I) ) \ " ' ' • J ..
I
' '
,. I rnuiax.. th
:l.t.uu Al n,t,, o. l n ~at. x. iJia1 : ~ U"
hDm
\ ~ -1
.db
},_1) 1) 1. I ll
\ \1
(ff -, ""1f, I t,, 1
II q • " '' I} •I 1\ t \ } • •
11
11 •

oi~ rn-..a• - JJ ba.£.x..p ~~9lf1~ ·

cl n 7,..g,n, •At" ~ c.ud
.l?u.J _ 8__
. ___ ~ ---0 n
10.a e...r.Tl.0 0- ~,.-

@1RucT u0
-~-~~~~ · ,
• 1 "' ,,, •
·
_ • l ; J, , \ r It', (,
1 • , ·,, )J I"
1
, ·1 ) • • , •

• 1flfl:U.! ~ -4 :u.u wv. :x.o..u9 &afn { ,'matgu. / no~)

• hdd ~ ~ -4 pxcru~ ~ bq 0pfh jn~ W<l J~ ~ a.cLia.i:u:Tr>

~ -
-~~-4 ~~ Pu,-1 o:drw±·
***'k* ~ 1n d<!fl' n'i-HonJ)
~ ~ e ne..tu:rllJc. J:lll.d& e.xJt.EJt .kt< ,.,,'Jo.1..<i ffewm t:X...d:(l,1-d -J.,e lll(U£±

Jn.u
___ ~v«. J
d,.n ,t
a~1 ~
" .a:t t..CLC..h ru.uxun :fe ~,cP .,u, fdv ,u

~.
(Ot ruL D.L t~)
~ Juu n ~ fu.a1 .a.nd_ e:u_d L ( F 11.J<L Ju.,.m,a.ri) .
n"u- II " (! " .JL "
~...,,,,.,.. ... ,~,.,,
~ ~
• __ ./JD.
l'1.0.JLa.J..L ~ , , 'f v,..cJ~ ~ ..u.J(.L ~e .. ~ r a ~ <..a vtr() ,

~e~~­

~~
~ 4~ ~ eiJjea ~

~
t} How it Works (Simple Steps):
1. Forward Pa ss:
Data enters the input layer. passes through hidden layers. and reaches the output
layer to give an initial prediction.

2. Error Calculation:
The network checks how wrong the pred1ct1on 1s by comparing 1t to the correct
answer (called ·error ")

3. Backward Pass (Backpropagation):

The network sends this error backward from the output layer to the input layer.
adjusting the weights at each neuron to reduce future errors.

4. Repeat:
This cycle repeats many times until the network learns to give correct outputs.

Backpropagati on
Error is :ent back to
~ each neuron in backward
Gracknt of error is
\• direction
c:d.ailattd with re:ptd to
eadlweight

(DError - differene2
Error between prcckttd
output and actud.
output

lnputLcrpr Hidden Layer Outpat La-pr

9 Backpropagation Algorithm (Simple
Steps)

II Initialize Weights
• Assign random small values to all weights and biases in the network.

121: Forward Pass

• Input the training data Into the neural network.

• Calculate the output at each neuron layer by layer.

Compute the predicted output.

(31; Calculate Error

• Use the formula:

Error = Actual Output - Predicted Output

IJ; Backward Pass (Backpropagation)

Calculate the gradient of error at the output layer.

• Propagate this error backward through the network.

• Calculate the gradient for each weight.

Ii Update Weights
• Adjust the weights using:

New Weight = Old Weight - (Learning Rate x Gradient)

mt Repeat
• Repeat steps F21: to (51; for multiple iterations (called epochs) until the error is
minimized.

~ Donel

This is the full algorithm in simple, clear steps - easy to write and understand.
 @EE P lE"ARfUC.n)G, .)

T n.JTRODUCTTO I\J:

~ -(UJJd ~ mDdwu ~ .
~ 11 ~ ~ :te .l.t.a:xn ftom .M 4, .da:lo. ~ max.,. unatl dw90fU -

•
~ il ,..,, a• ., • -···~-0
L.ULJ vixz•f ,,af '1.U.l,UU. ne:li.ve~

'- )

~ ~ " ..r..o.11u1 £JU[1 i.La»u-1

J,
(q JJucL:1J.n ~~) .
-4 ~ 1uvuu ~ . a d e ~ .

~ f3ul ¥J ~ .:fm.u .llJ<.J ~ e ~ , ~ ~ ' 1,

orul ~ULUJe ~ ·
~ rvw;h 4 e .a.m.a.vi:I .ff- .da:i:a .1:.e i..uiv> w e.11. _ rrdl.i ~ = 1,Jw(
~ -

- c ru ru { 6d' »n.llff u )
- Rmru ( fill u.qµ.vt.r.u , -Jud, ~ )
_ u,AIU~ { ¥' .awf/n7 cla1.o) .

~ Ubtd JJ) :u...a.1 -.JlJt. .ll{l(I .' l. ~ ,dxl_w"a UVU. , ~ ~ -> t.ha.f 1tetJ. .
----> 31 Lffif"B"" wW, kn, - -n., me:iu .i.l ha,,,,, , -v., Ynax.tv< : ' b,,,,,.,,._I
~ 1:1.
..
,u hatl .ef- rna:l..vu-,
-- -- ·- \
Ar .
- ·'
J
\
.- \ I \ l ~ I I ·' '

rnL

\ I \ \ \~ ·'

\ \ t I

\ • ' 'I ' I

\ \ \ '. . '
@ Why Use Deep Learning?
Because It can:

• Handle huge amounts of data Ill

• Learn very complex patterns ~

• Work great with images, speech, videos, and text

°' Simple Example:

Imagine teaching a kid to recognize a cat t!!S :
• First. they notice the ears

• Then the eyes.

• Then the whiskers.

• Then they say. ·vesi That's a catl"

Deep learning works the same way - 11 learns In steps or layers. from simple to complex.

• Structure of Deep Learning:

A Deep Learning model Is made of

• Input Layer - where data comes In (like images. numbers. etc.)

• Hidden Layers - where learning happens (many of them I)

• Output Layer - where the answer comes out (like ·Irs a cat 1")

Each layer passes the knowledge to the next one. like students passing notes in class ■

••••

Input Layer Output Layer

• Main Points about Deep Learning:

II Inspired by the Human Brain:

Deep learning uses neural networks, which are designed like the human brain - with
neurons and layers.

121: Learns from Large Data:

The more examples you give it (images, text, etc.), the better it learns.
It's like practicing - more practice = better results.

• Uses Many Layers (Deep!):

It's called "deep· learning because It has many hidden layers between Input and output.
Each layer learns something new - step by step.

■ Solves Complex Problems:

Deep learning can handle really tough tasks like:

Recognizing faces 9

Translating languages l@I

Driving cars ·-~

• Needs Powerful Computers:

It takes a lot of computing power to train deep learning models.
They often use GPUs (special computer parts) to learn faster.

II Works Best with Big Data:

If you have a lot of data, deep learning gives amazing results - way better than normal
machine learning.

II Used in Real Life:

Deep learning ls used In:

Voice Assistants (Alexa, Slrl)

Image and face recognition

Self-driving cars

Healthcare (detecting diseases)

Recommendation systems (like Netflix, YouTube)

I What is an Architecture?
In deep learning, an architecture means the structure or type of neural network we use.
Different problems {like images, text, or speech) need different network styles to learn
better.

Here are the main types of Deep Learning Architectures with cute, easy examples fl

Ill: Feedforward Neural Network (FNN)

What it is: The most basic type of neural network.

How it works: Data flows in one direction - from input - hidden layers - output.

Used for: Simple tasks like predictions or basic classification.

Example: Predicting house prices 6' Q .

J2l Convolutional Neural Network (CNN)

What it is: A network for seeing things - like a smart eye 0.

How it works: It scans images In parts to find shapes, edges, and patterns.

Used for: Image recognition, face detection, medical Image analysis.

Example: Telllng if a photo has a dog or a cat &' (BS .

til Recurrent Neural Network (RNN)

What it is: A network with memory.

How it works: It remembers previous inputs to make better predictions for the next
one.

Used for: Time-related data like text, speech, or weather.

Example: Predicting the next word in a sentence or recognizing speech • • .

fi Generative Adversarial Network (GAN)

What it is: A creative network with two parts - one generates data, the other judges
it.

How it works: One part tries to make fake data (like Images), the other tries to catch
it.

Used for: Creating art, fake Images, realistic photos or animations.

Example: Making new human faces that look real fl!ti lil.

l'sl Autoencoders
What it is: A network that learns to compress and then rebuild data.

How it works: It learns to find Important patterns and ignore useless details.

Used for: Data compression, noise removal, and feature learning.

Example: Cleaning a blurry photo or reducing file size :;;: '\, .

 fNeural Network Architectures - Full
Detailed Description

• Feedforward Neural Network (FNN)

Small Description:
A basic type of neural network where information flows in one direction - from input to
output - without looping back.

Structure:

• Input Layer: Takes in the raw input data.

• Hidden Layers: Layers between input and output that process the input using
weighted connections.

• Output Layer: Produces the final output prediction or classification.

Characteristics:

• Data moves only forward, with no feedback loops.

• Simple and easy to implement, suitable for non-sequential, static problems.

Use Cases:

• Image Classification: Classifying images into categories like cat/dog.

• Regression Tasks: Predicting continuous values such as house prices, sales

forecasting.

(F~fD FORWARD
.. '
I •

I) t \ I I .
►
'· I !

►
, , .- •
JI..) '-- , .J
1.
)J , ! ► ,)
\
,,

►
• J ' 'Jl~

\\ ). ► t l ', l ~
►!
\. I
':!'t..'-. \
'
-~ ) ) '
' ' '- ~ur\_. ,_,' .·.h,'&ter,) } · tiutput., .
) J,; \ ; l l
•.
~e..l 4~~
• \) • H ~d --~ ) .
tar-~
\_ r7·, '~'- -~"" ,. .: ( I
I
 • Convolutional Neural Network (CNN)
Small Description:
A specialized network designed to process grid-like data such as images by automatically
detecting spatial features.

Structure:

• Input Layer: Takes raw data (e.g., images).

• Convolutional Layers: Apply filters to extract features such as edges, textures, etc.

• Pooling Layers: Reduce spatial dimensions to simplify data.

• Fully Connected Layer: Connects the extracted features for classification.

• Output Layer: Outputs the fmal classification or prediction.

Characteristics:

• Weight Sharing: Uses shared filters across the image, which reduces the number of
parameters.

• Translation Invariance: The network can recognize patterns regardless of their

position in the image.

Use Cases:

• Image Classification: Identifying objects in images (e.g., dogs vs. cats).

• Object Detection: Detecting and locating objects in images or videos.

• Medical Imaging: Analyzing X-rays, MRls, etc.

coruvoLUTIOru,u nlflJRAL ll.lETWOR(.

u,rNonution + RUJ + mix poolJ1 _ _ _ _ _ ___,.

'------------~
.ft.ahJYe eJXh'o.crlon in rnu.t.tiple h:dden ~e."<~

fu.~ c.onnuhd ~e.Y~

<..IM51fic.o.Bon in 00¥ ~•
 • Recurrent Neural Network (RNN)
Small Description:
A neural network designed to handle sequential data like time-series, speech, or text, by
using its internal memory to store past information.

Structure:

• Input Layer: Accepts data in sequence (e.g., words in a sentence).

• Hidden Layers: Each unit processes data sequentially, passing information from
previous steps (memory).

• Output Layer: Produces output for each time step or the final output after processing
the sequence.

Characteristics:

• Memory: RNNs can store information from previous time steps, useful for sequential
tasks.

• Sensitive to Input Order: The order of the data matters, which is key for tasks like
time-series analysis.

Use Cases:

• Natural Language Processing: Tasks like sentiment analysis, text generation, and
machine translation.

• Time-Series Forecasting: Predicting future values like stock prices or weather.

/ : ---- • J
RfCVRRt=IUT nJEURA L • tU;TWORt
,
lJ ;
(Rroru) ' ,Y , - .,
- - -- ~ ~:..::_!_- - - -/-/~ __,, ~•
'

h, l~' !1l ,,,.,. , /

hidde.o output
•o~e." la~e.Y .
 Generative Adversarial Network (GAN)

Small Description:
A framework where two networks, a Generator and a Discriminator, compete to create
realistic synthetic data from noise _

Structure:

• Generator: Generates synthetic data (e.g., images, text).

• Discriminator: Classifies whether the data is real or fake .

• Adversarial Process: The Generator tries to improve to fool the Discriminator, whi le
the Discriminator improves to correctly identify fake data.

Characteristics:

• Adversarial Setup: The Generator and Discriminator "compete," leading to both

improving during training.

• Data Generation: GANs can create new, realistic samples (e.g., fake images, videos).

Use Cases:

• Image Synthesis: Creating realistic images (deepfakes. Al-generated art).

• Data Augmentation: Generating additional data to train other models when real dat a
is limit ed.

6--------:
''
•
''
'

Generator G Discriminator D Fake/Real?

•••
•
•'

GJ GJ
 Long Short-Term Memory Network (LSTM)
Small Description:
An advanced type of RNN designed to solve long-term dependency problems in sequence
prediction tasks using gates to control information flow

Structure:

• Input Layer Accepts data (e g, text or t1me-ser1es )

• LSTM Cells Contain gates (Forget Gate, Input Gate. Output Gate) to control which
data to remember and which to forget

• Output Layer Produces the final output after processing the sequence

Characteristics:

• Long-Term Memory Overcomes the vanishing gradient problem by maintaining long-

term dependencies

• Gated Mechanism Gates help decide which information 1s important and should be
kept

Use Cases:

• Machine Translation Translating text from one language to another (e g, Google

Translate)

• Speech Recognition Converting speech into text or understanding spoken

commands

• Text Summarization Condensing long documents into short summaries

LONG SHORT...TERM MEMORY

NEURAL NETWORKS
__
Upd;i!odcallatalO,_,
LSTM Recurrent Unit ~.,.,.. tidck.n

- - ~-
__ -···--··-········..
.-···························-···· ............._.... .............
.f c,- 1 __.
-·················•.
c, ·=
.
....................... _............... .............. ... ........... ....... .................... . . ..... ..... . ........ .... .......... ...........................:
•

Hddenatale

•
( ;;;~·;···-··········· ···-····;;;······.1
·•.................. ... ..... ......................

x, ~
bcelcta:e
upda!o
Fogel~ ~
g:ttO pe gale