PROGRAM -1: Write a C program to swap the contents of two variable using pointers.
/**
--------------------------------------------------------------------------
Write a C program to swap the contents of two variable using pointers.
----------------------------------------------------------------------------
*/
#include <stdio.h>
// function prototype
void swap(int *x, int *y);
int main() {
int a, b;
// Input values
printf("Enter two numbers: ");
scanf("%d %d", &a, &b);
printf("Before swapping: a = %d, b = %d\n", a, b);
// Call swap function
swap(&a, &b);
printf("After swapping: a = %d, b = %d\n", a, b);
return 0;
}
// Function to swap two variables using pointers
void swap(int *x, int *y) {
int temp;
temp = *x; // store value of x
*x = *y; // put value of y in x
*y = temp; // put temp (original x) in y
}
C.N. PRACTICAL 1
OUTPUT:
C.N. PRACTICAL 2
PROGRAM -2: Write a C program to extract each byte from a number, store them in separate
variable and print the content of those variable.
/**--------------------------------------------------
C program to extract each byte from a number,
store them in separate variable
and print the content of those variable
-----------------------------------------------------
*/
#include <stdio.h>
int main() {
unsigned int num;
unsigned char *ptr;
// Input number
printf("Enter a number: ");
scanf("%u", &num);
// Point to the address of num
ptr = (unsigned char*)#
// Print each byte (system dependent => little-endian or big-endian)
printf("Byte 1 (LSB) = %u\n", ptr[0]);
printf("Byte 2 = %u\n", ptr[1]);
printf("Byte 3 = %u\n", ptr[2]);
printf("Byte 4 (MSB) = %u\n", ptr[3]);
return 0;
}
C.N. PRACTICAL 3
OUTPUT:
C.N. PRACTICAL 4
PROGRAM -3: Write a C program to check whether the host machine uses little endian or big
endian.
/**
---------------------------------------------------
C program to check whether the host machine
uses little endian or big endian.
---------------------------------------------------
*/#include <stdio.h>
int main() {
unsigned int num = 1; // store 1 in 4 bytes
char *ptr = (char*)# // treat it as a byte array
if (*ptr == 1) {
printf("Machine is Little Endian\n");
} else {
printf("Machine is Big Endian\n");
}
return 0;
}
C.N. PRACTICAL 5
OUTPUT:
C.N. PRACTICAL 6
PROGRAM -4: Write a C program to create TCP server that will send a message from server to
client.
/*
---------------------------------------
CREATE A TCP ECHO SERVER
--------------------------------------
*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netinet/ip.h>
#include<unistd.h>
int main(){
int sd,b,l,nsd;
ssize_t r,w;
char data[100];
socklen_t len,lenc;
struct sockaddr_in my_addr,client_addr;
//define socket
sd = socket(AF_INET,SOCK_STREAM,0);
if(sd == -1){
perror("SOCKET :");
exit(1);
}
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(5001);
//inet_aton("192.168.1.2",&my_addr.sin_addr);
my_addr.sin_addr.s_addr = INADDR_ANY;
len = sizeof(my_addr);
//bind socket
b=bind(sd,(struct sockaddr *) &my_addr,len);
//listen
l=listen(sd,5);
C.N. PRACTICAL 7
lenc = sizeof(client_addr);
printf("\n-------------------------------------\n");
w=write(1,"Waiting for clients : ",23);
printf("\n-------------------------------------\n");
while(1){
nsd = accept(sd, ( struct sockaddr *) &client_addr,&lenc);
r = read(nsd,data,100); // read from the socket
printf("***********************\n");
printf("\n Recieved from client :\n");
printf("***********************\n");
w = write (1,data,r); //write to the console
printf("\n***********************\n");
// reverse the data read
printf("\n---------------------\n");
printf("Send to client :");
printf("\n---------------------\n");
w = write (1,data,r); //write to the console at server end
write(nsd, data, r); // send back to client
close(nsd); // close client connection after response
}
close(sd); // close the socket
return 0;
} // end of main function
C.N. PRACTICAL 8
OUTPUT:
C.N. PRACTICAL 9
PROGRAM -5: Write a C program to create TCP client that will send a message from client to
server.
/*
------------------------------------------
CREATE A TCP ECHO CLIENT
------------------------------------------
*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netinet/ip.h>
#include<unistd.h>
int main(int argc, char *argv[]){
int sd,c;
ssize_t r,w;
char data[100];
socklen_t length;
struct sockaddr_in server;
//Define socket
sd = socket(AF_INET,SOCK_STREAM,0);
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[1]));
inet_aton(argv[2], &server.sin_addr);
length = sizeof(server);
c = connect(sd,(struct sockaddr *) &server,length);
//c = connect(sd,'127.0.0.1',length);
w = write(sd,"Welcome to MCC\n",15); // write to the socket
r = read(sd,data,100); // read from the socket
w = write(1,data,r); // write to the console
printf("\n");// write new line to the console
close(sd);
return 0;
C.N. PRACTICAL 10
OUTPUT:
C.N. PRACTICAL 11
PROGRAM -6: Write a C program to create TCP client-server program that will send a string
from client to server, Server display the string on server console reverse he string at server side
and send back to its Client.
/*
-------------------------------------------------------------
CREATE A TCP ECHO SERVER THAT WILL REVERSE THE STRING
---------------------------------------------------------------
*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netinet/ip.h>
#include<unistd.h>
void reverse_string(char *str, int len); // function declaration
int main(){
int sd,b,l,nsd;
ssize_t r,w;
char data[100];
socklen_t len,lenc;
struct sockaddr_in my_addr,client_addr;
//define socket
sd = socket(AF_INET,SOCK_STREAM,0);
if(sd == -1){
perror("SOCKET :");
exit(1);
}
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(5000);
//inet_aton("192.168.1.2",&my_addr.sin_addr);
my_addr.sin_addr.s_addr = INADDR_ANY;
len = sizeof(my_addr);
//bind socket
C.N. PRACTICAL 12
b=bind(sd,(struct sockaddr *) &my_addr,len);
//listen
l=listen(sd,5);
lenc = sizeof(client_addr);
printf("\n-------------------------------------\n");
w=write(1,"Waiting for clients : ",23);
printf("\n-------------------------------------\n");
while(1){
nsd = accept(sd, ( struct sockaddr *) &client_addr,&lenc);
r = read(nsd,data,100); // read from the socket
printf("***********************\n");
printf("\n Recieved from client :\n");
printf("***********************\n");
w = write (1,data,r); //write to the console
printf("\n***********************\n");
// reverse the data read
reverse_string(data, r);
printf("\n---------------------\n");
printf("Send to client :");
printf("\n---------------------\n");
w = write (1,data,r); //write to the console at server end
write(nsd, data, r); // send back to client
close(nsd); // close client connection after response
}
close(sd); // close the socket
return 0;
}
C.N. PRACTICAL 13
/**
Define string reverse function
*/
void reverse_string(char *str, int len) {
int i;
char temp;
for (i = 0; i < len / 2; i++) {
temp = str[i];
str[i] = str[len - i - 1];
str[len - i - 1] = temp;
}
str[len] = '\n'; // add newline
len++;
C.N. PRACTICAL 14
PROGRAM -7: Write a C program to create TCP client program that will send a string from
client to server.
/*
----------------------------------------------------------
CREATE A TCP ECHO CLIENT SEND STRING TO SERVER
---------------------------------------------------------
*/
#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<netinet/ip.h>
#include<unistd.h>
int main(int argc, char *argv[]){
int sd,c;
ssize_t r,w;
char data[100];
socklen_t length;
struct sockaddr_in server;
//Define socket
sd = socket(AF_INET,SOCK_STREAM,0);
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[1]));
inet_aton(argv[2], &server.sin_addr);
length = sizeof(server);
c = connect(sd,(struct sockaddr *) &server,length);
//c = connect(sd,'127.0.0.1',length);
w = write(sd,"Welcome to MCC\n",15); // write to the socket
r = read(sd,data,100); // read from the socket
w = write(1,data,r); // write to the console
printf("\n");// write new line to the console
close(sd);
return 0;
C.N. PRACTICAL 15
OUTPUT:
C.N. PRACTICAL 16
PROGRAM -8: Write a C program to create TCP server program that will receive an array from
a client program, print the array, and perform the following operations:
Array Sum, Array product, Array max, Array min, Array average,
/*
---------------------------------------
TCP SERVER – Perform Array Operations
---------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
struct ArrayData {
int operation;
int size;
int array[100];
};
// Function to handle various operations
int handle_operation(struct ArrayData data) {
int result = 0;
switch (data.operation) {
case 1: // sum
for (int i = 0; i < data.size; i++)
result += data.array[i];
break;
case 2: // product
result = 1;
for (int i = 0; i < data.size; i++)
result *= data.array[i];
break;
C.N. PRACTICAL 17
case 3: // max
result = data.array[0];
for (int i = 1; i < data.size; i++)
if (data.array[i] > result)
result = data.array[i];
break;
case 4: // min
result = data.array[0];
for (int i = 1; i < data.size; i++)
if (data.array[i] < result)
result = data.array[i];
break;
case 5: // average
for (int i = 0; i < data.size; i++)
result += data.array[i];
result = result / data.size;
break;
default:
printf("Invalid operation received\n");
result = -1;
}
return result;
}
C.N. PRACTICAL 18
int main() {
int sd, nsd;
socklen_t len;
struct sockaddr_in my_addr, client_addr;
struct ArrayData recv_data;
int result;
// Create socket
sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd == -1) {
perror("Socket creation failed");
exit(1);
}
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(5002);
my_addr.sin_addr.s_addr = INADDR_ANY;
len = sizeof(my_addr);
// Bind
if (bind(sd, (struct sockaddr *)&my_addr, len) == -1) {
perror("Bind failed");
close(sd);
exit(1);
}
// Listen
if (listen(sd, 5) == -1) {
perror("Listen failed");
close(sd);
exit(1);
}
printf("\n============================================\n");
printf("Server is running. Waiting for client...\n");
printf("\n============================================\n");
while (1) {
socklen_t client_len = sizeof(client_addr);
nsd = accept(sd, (struct sockaddr *)&client_addr, &client_len);
if (nsd == -1) {
perror("Accept failed");
continue;
C.N. PRACTICAL 19
}
printf("Client connected.\n");
// Read structure from client
read(nsd, &recv_data, sizeof(recv_data));
// print the received array
printf("\n-----------------------------------\n");
printf("Received array from client:\n");
printf("\n-----------------------------------\n");
for (int i = 0; i < recv_data.size; i++) {
printf("Element %d :%d :\n",i+1, recv_data.array[i]);
}
printf("\n");
// Print operation type
printf("\n----------------------\n");
printf("Requested Operation: ");
switch (recv_data.operation) {
case 1: printf("Sum\n"); break;
case 2: printf("Product\n"); break;
case 3: printf("Maximum\n"); break;
case 4: printf("Minimum\n"); break;
case 5: printf("Average\n"); break;
default: printf("Not Defined Operation.\n"); break;
}
printf("\n----------------------\n");
// Handle operation
result = handle_operation(recv_data);
//print the result at server side
printf("The result is = %d \n",result);
// Send result back
write(nsd, &result, sizeof(result));
close(nsd);
printf("\n=========================\n");
printf("Client disconnected.\n\n");
printf("\n=========================\n");
}
close(sd);
return 0;
}
C.N. PRACTICAL 20
PROGRAM -9: Write a C program to create TCP client program that will read and send an array
to a server program, print the array, and perform the following operations:
Array Sum, Array product, Array max, Array min, Array average,
/*
------------------------------------------
TCP CLIENT – Send array and operation
------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MAX 10
struct ArrayData {
int operation; // 1: sum, 2: product, 3: max, 4: min, 5: average
int size; // Number of elements
int array[MAX]; // Data array
};
int main(int argc, char *argv[]) {
// handle segmentation fault error
int sd;
struct sockaddr_in server;
struct ArrayData send_data;
int result;
// Create socket
sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd == -1) {
perror("Socket creation failed");
exit(1);
}
server.sin_family = AF_INET;
server.sin_port = htons(atoi(argv[1]));
inet_aton(argv[2], &server.sin_addr);
C.N. PRACTICAL 21
// Connect to server
if (connect(sd, (struct sockaddr *)&server, sizeof(server)) == -1) {
perror("Connect failed");
close(sd);
exit(1);
}
// ==== Prepare Array and Operation ====
printf("\n-------------------------------------------------------------------
-------\n");
printf("Enter operation code (1: sum, 2: product, 3: max, 4: min, 5:
average): ");
printf("\n-------------------------------------------------------------------
-------\n");
scanf("%d", &send_data.operation);
// error handle for MAX no. of element in array
printf("Enter number of elements in array (max %d): ",MAX);
scanf("%d", &send_data.size);
printf("Enter %d elements:\n", send_data.size);
for (int i = 0; i < send_data.size; i++) {
scanf("%d", &send_data.array[i]);
}
// Send struct to server
write(sd, &send_data, sizeof(send_data));
// Receive result
read(sd, &result, sizeof(result));
printf("Result from server: %d\n", result);
close(sd);
return 0;
}
C.N. PRACTICAL 22
OUTPUT:
C.N. PRACTICAL 23
PROGRAM -10: Write a C program to implement CRC.
/**
------------------------------------------------------------
Write a c program to calculate CRC for a given bit stream at
SENDER end also check CRC at Receiver end.
--------
INPUT :
--------
1.)Enter data: 100100
2.)Enter divisor (generator polynomial): x^3+x^2+1 write it as =>1101
--------
OUTPUT:
--------
Code word : Data bit stream + CRC3
CRC: 001
Transmitted Data (Data + CRC): 100100001
------------------
Receiver Side:
-----------------
Enter received data: 100100001
No error detected in received data.
---------------------------------------------------------------
*/
// Include headers
#include<stdio.h>
#include<string.h>
// length of the generator polynomial
#define N strlen(gen_poly)
// data to be transmitted and received
char data[28];
// CRC value
char check_value[28];
// generator polynomial
char gen_poly[10];
// variables
int data_length,i,j;
// function prototype
void crc();
void XOR();
void receiver();
C.N. PRACTICAL 24
int main()
{
// get the data to be transmitted
printf("==============================================\n");
printf(" : PROGRAM FOR CRC : \n");
printf("==============================================\n");
printf("Enter data to be transmitted M(x): ");
scanf("%s",data);
printf("-----------------------------------------------\n");
printf("Enter the Generating polynomial G(x): ");
// get the generator polynomial
scanf("%s",gen_poly);
// find the length of data
data_length=strlen(data);
// appending n-1 zeros to the data
for(i=data_length;i<data_length+N-1;i++)
data[i]='0';
printf("----------------------------------------------\n");
// print the data with padded zeros
printf("Data padded with n-1 zeros : %s \n",data);
printf("---------------------------------------------- \n");
// Cyclic Redundancy Check
crc();
// print the computed check value
printf("CRC or Check value is : %s \n",check_value);
// Append data with check_value(CRC)
for(i=data_length;i<data_length+N-1;i++)
data[i]=check_value[i-data_length];
printf("----------------------------------------\n");
// printing the final data to be sent
printf(" Final data to be sent : %s \n",data);
printf("----------------------------------------\n");
// Calling the receiver function to check errors
receiver();
return 0;
}
C.N. PRACTICAL 25
// function that performs XOR operation
void XOR(){
// if both bits are the same, the output is 0
// if the bits are different the output is 1
for(j = 1;j < N; j++)
check_value[j] = (( check_value[j] == gen_poly[j])?'0':'1');
}
// Function to check for errors on the receiver side
void receiver(){
// get the received data
printf("Enter the received data (CODE WORD): ");
scanf("%s", data);
printf("-----------------------------\n");
printf("Data received: %s \n", data);
// Cyclic Redundancy Check
crc();
// Check if the remainder is zero to find the error
for(i=0;(i<N-1) && (check_value[i]!='1');i++);
printf("====================================\n");
if(i<N-1)
printf( "ERROR DETECTED ! MESSAGE IS REJECTED\n" );
else
printf( "NO ERROR, SO MESSAGES IS ACCEPTED \n" );
printf("====================================\n");
}
void crc(){
// initializing check_value
for(i=0;i<N;i++)
check_value[i]=data[i];
do{
// check if the first bit is 1 and calls XOR function
if(check_value[0]=='1')
XOR();
// Move the bits by 1 position for the next computation
for(j=0;j<N-1;j++)
check_value[j]=check_value[j+1];
// appending a bit from data
check_value[j]=data[i++];
}while(i<=data_length+N-1);
// loop until the data ends
}
C.N. PRACTICAL 26
OUTPUT:
C.N. PRACTICAL 27
PROGRAM -11: Write a C program to implement Checksum.
/**
----------------------------------------------------
Write a c program to implement the CHECKSUM
Error detection technique
-----------------------------------------------------
*/
#include <stdio.h>
#include <string.h>
//function declaration
void intToBinaryString(int value, char *output);
void calculateChecksum(char data[], char checksum[]);
int binaryToDecimal(char *bin);
//begin main programm
int main() {
printf("==========================================\n");
printf(" :SIMULATE THE CHECKSUM: \n");
printf("==========================================\n");
char data[17], checksum[9], received[25];
printf("------------------------------------------\n");
printf("Enter 16 bits Data :");
scanf("%16s", data);
printf("--------------------------------------------\n");
//function call calculate the checksum
calculateChecksum(data, checksum);
printf("CheckSum :%s \n", checksum);
printf("-----------------------------------\n");
// Append checksum to data
strcpy(received, data);
strcat(received, checksum);
printf("Send Data :%s\n", received);
// Receiver side: extract 3 blocks of 8 bits
int byte1 = binaryToDecimal(received);
int byte2 = binaryToDecimal(received + 8);
int byte3 = binaryToDecimal(received + 16);
C.N. PRACTICAL 28
int receiver_sum = byte1 + byte2 + byte3;
// Wrap around carry
if (receiver_sum > 0xFF) {
receiver_sum = (receiver_sum & 0xFF) + 1;
}
char binarySum[9], binaryComplement[9];
intToBinaryString(receiver_sum, binarySum);
int complement = ~receiver_sum & 0xFF;
intToBinaryString(complement, binaryComplement);
printf("-----------------------------------\n");
printf("Receiver sum :%s\n", binarySum);
printf("-----------------------------------\n");
printf("Receiver sum complement :%s\n", binaryComplement);
printf("-----------------------------------\n");
if (complement == 0) {
printf("Data receive correctly\n");
} else {
printf("Data receive with error\n");
}
printf("-----------------------------------\n");
return 0;
}
C.N. PRACTICAL 29
// Convert 8-bit integer to binary string
void intToBinaryString(int value, char *output) {
for (int i = 7; i >= 0; i--) {
output[7 - i] = ((value >> i) & 1) + '0';
}
output[8] = '\0';
}
// Calculate 8-bit checksum for 16-bit binary input
void calculateChecksum(char data[], char checksum[]) {
int byte1 = 0, byte2 = 0;
// Convert first 8 bits
for (int i = 0; i < 8; i++) {
byte1 = (byte1 << 1) | (data[i] - '0');
byte2 = (byte2 << 1) | (data[i + 8] - '0');
}
int sum = byte1 + byte2;
// Wrap around carry
if (sum > 0xFF) {
sum = (sum & 0xFF) + 1;
}
// One's complement
int chksum = ~sum & 0xFF;
intToBinaryString(chksum, checksum);
}
int binaryToDecimal(char *bin) {
int value = 0;
for (int i = 0; i < 8; i++) {
value = (value << 1) | (bin[i] - '0');
}
return value;
}
C.N. PRACTICAL 30
OUTPUT:
C.N. PRACTICAL 31
PROGRAM -12: Write a C program to implement UDP server that receive message from UDP
client.
/**
-------------------------------------
UDP SERVER PROGRAM
-------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> // for close(), write()
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MAX 100
int main() {
// Variable declarations
int sd, b;
socklen_t clen;
char data[MAX];
ssize_t r, w;
struct sockaddr_in caddr, myaddr;
// Create UDP socket
sd = socket(AF_INET, SOCK_DGRAM, 0);
if (sd == -1) {
perror("SOCKET ERROR");
exit(1);
}
// Assign server address parameters
myaddr.sin_family = AF_INET;
myaddr.sin_port = htons(40000);
myaddr.sin_addr.s_addr = INADDR_ANY;
// Bind socket to address
b = bind(sd, (struct sockaddr *)&myaddr, sizeof(myaddr));
if (b == -1) {
perror("BIND ERROR");
close(sd);
exit(1);
}
C.N. PRACTICAL 32
printf("===============================================\n");
printf("UDP Server is running... Waiting for messages : \n");
printf("===============================================\n");
// Communication loop
while (1) {
clen = sizeof(caddr);
memset(data, 0, MAX); // Clear buffer before receiving
// Receive message from client
r = recvfrom(sd, data, MAX - 1, 0, (struct sockaddr *)&caddr, &clen);
if (r < 0) {
perror("RECVFROM ERROR");
continue;
}
data[r] = '\0'; // Null-terminate the received string
printf("----------------------------------------------\n");
printf("Client [%s] says: %s\n", inet_ntoa(caddr.sin_addr), data);
printf("----------------------------------------------\n");
// Echo the same message back to the client
sendto(sd, data, r, 0, (struct sockaddr *)&caddr, clen);
}
close(sd);
return 0;
}
C.N. PRACTICAL 33
PROGRAM -13: Write a C program to implement UDP client that send message to UDP server.
/*
-------------------------------------------
UDP CLIENT PROGRAM
-------------------------------------------
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h> // for close(), write()
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MAX 100
int main(int argc, char *argv[]) {
// variable declaration
int sd;
socklen_t len;
char data[MAX];
ssize_t r, w;
struct sockaddr_in server_addr;
// Create UDP socket
sd = socket(AF_INET, SOCK_DGRAM, 0);
if (sd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
// Configure server address
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], &server_addr.sin_addr) == 0) {
fprintf(stderr, "Invalid IP address format\n");
close(sd);
exit(EXIT_FAILURE);
}
C.N. PRACTICAL 34
len = sizeof(server_addr);
// Send message to server
const char *message = "Welcome to MCC\n";
w = sendto(sd, message, strlen(message), 0,
(struct sockaddr *)&server_addr, len);
if (w < 0) {
perror("sendto failed");
close(sd);
exit(EXIT_FAILURE);
}
// Receive message from server
r = recvfrom(sd, data, MAX - 1, 0, (struct sockaddr *)&server_addr, &len);
if (r < 0) {
perror("recvfrom failed");
close(sd);
exit(EXIT_FAILURE);
}
data[r] = '\0'; // Null-terminate the received data
// Output the received message
printf("Server reply: %s", data);
// Close the socket
close(sd);
return 0;
}
C.N. PRACTICAL 35
OUTPUT:
C.N. PRACTICAL 36
