Experiment -1 Linux Commands

1. ls (List Directory Contents)

 Purpose: Lists files and directories.

 Example:
o ls — List files.
o ls -l — Detailed list (permissions, size, etc.).

2. cd (Change Directory)

 Purpose: Changes the current directory.

 Example:
o cd Documents — Go to the "Documents" directory.
o cd .. — Move up one directory level.

3. pwd (Print Working Directory)

 Purpose: Displays the full path of the current directory.

 Example:
o pwd — Shows current directory path (e.g., /home/user/Documents).

4. mkdir (Make Directory)

 Purpose: Creates a new directory.

 Example:
o mkdir new_folder — Creates "new_folder".

5. rmdir (Remove Directory)

 Purpose: Removes an empty directory.

 Example:
o rmdir old_folder — Deletes "old_folder" if empty.

6. cp (Copy)

 Purpose: Copies files or directories.

 Example:
o cp file1.txt file2.txt — Copies "file1.txt" to "file2.txt".

7. mv (Move or Rename)

 Purpose: Moves or renames files.

 Example:
o mv file1.txt new_folder/ — Moves "file1.txt" to "new_folder".
o mv oldname.txt newname.txt — Renames a file.

8. rm (Remove)

 Purpose: Removes files or directories.

 Example:
o rm file.txt — Deletes "file.txt".
o rm -r folder — Deletes a folder and its contents.

9. touch (Create Empty File)

  Purpose: Creates an empty file or updates the timestamp.
 Example:
o touch newfile.txt — Creates "newfile.txt".

10. cat (Concatenate and Display)

 Purpose: Displays file content.

 Example:
o cat file.txt — Shows content of "file.txt".

11. head (Display Beginning of File)

 Purpose: Shows the first few lines of a file.

 Example:
o head -n 5 file.txt — Displays the first 5 lines.

12. tail (Display End of File)

 Purpose: Displays the last few lines of a file.

 Example:
o tail -n 10 file.txt — Displays the last 10 lines.

13. grep (Search Text in Files)

 Purpose: Searches for a pattern in files.

 Example:
o grep "hello" file.txt — Searches for "hello" in the file.

14. chmod (Change File Permissions)

 Purpose: Changes file permissions.

 Example:
o chmod 755 file.txt — Sets full permissions for the owner, read-execute for others.

15. chown (Change File Ownership)

 Purpose: Changes file ownership.

 Example:
o chown user:group file.txt — Changes ownership of the file.

16. ln (Create Links Between Files)

 Purpose: Creates hard or symbolic links.

 Example:
o ln -s /path/to/file linkname — Creates a symbolic link to a file

3. File Manipulation with System Calls

File Manipulation :- Means there are different types of operation that we can perform in the file.
Example – we create file , delete file, write some content in file , Some update inside the file.

System calls : - System call is a way for a user program to request services from O.S. since user program or instruction cannot directly interact
with hardware or the kernel.
A file descriptor is just a number assigned by the system when you open a file.

How to compile and Run file

Firstly check the GCC installed in your system or not gcc --version

Install the GCC

sudo apt install gcc –y

sudo apt update //for update.

gcc readfile.c -o readfile //Command to compile file

./readfile to executable file.

Gcc Calls the GNU C Compiler to compile C programs.

readfile.c The source code file (your C program).
-o Tells the compiler to specify an output file name.
readfile The name of the output executable file.

Here some common system calls :

1. open() – Open a File

Purpose: Opens a file for reading, writing, or both.

Example:

Int fd = open("file.txt", O_CREAT | O_WRONLY, 0644);

O_CREAT → Create the file if it doesn’t exist.

O_WRONLY → Open for writing only.

0644 → Set file permissions.

2. close() – Close a File

Purpose: Closes an open file to free system resources.

Example:

close(fd);

Always close files after use to prevent memory issues.

3. read() – Read Data from a File

Purpose: Reads data from a file into memory.

Example:

char buffer[100];
read(fd, buffer, 100);

Reads 100 bytes from fd (file descriptor) into buffer.

4. write() – Write Data to a File

Purpose: Writes data from memory to a file.

Example:

write(fd, "Hello, System Call!", 20);

Writes 20 characters to the file.

5. lseek() – Move the File Pointer

Purpose: Moves the reading/writing position in a file.

Example:

lseek(fd, 10, SEEK_SET);

Moves 10 bytes forward from the start of the file.

Useful for editing specific parts of a file.

6. unlink() – Delete a File

Purpose: Removes a file from the system.
Example:

unlink("file.txt");

Deletes file.txt permanently.

7. rename() – Rename a File

Purpose: Changes a file’s name.

Example:

rename("old.txt", "new.txt");

Renames old.txt to new.txt

8. stat() – Get File Information

Purpose: Fetches file details like size, permissions, and last modified time.

Example:

struct stat fileStat;

stat("file.txt", &fileStat);
printf("File size: %ld bytes\n", fileStat.st_size);

Shows the file size in bytes.

9. chmod() – Change File Permissions

Purpose: Modifies who can read, write, or execute a file.

Example:

chmod("file.txt", 0777);

Makes file.txt readable, writable, and executable by everyone.

10. chown() – Change File Owner

Purpose: Changes the owner of a file.

Example:

chown("file.txt", 1001, 1001);

Changes owner and group to user ID 1001.

11. link() – Create a Hard Link

Purpose: Creates another name (link) for a file.

Example:

link("file.txt", "file_link.txt");

Now file_link.txt points to the same data as file.txt.

12. symlink() – Create a Soft Link (Shortcut)

Purpose: Creates a symbolic link (shortcut) to another file.

Example:

symlink("file.txt", "file_symlink.txt");

file_symlink.txt behaves like a shortcut to file.txt.

Example for open , create file and write in system call

#include <fcntl.h> // For open()

#include <unistd.h> // For read(), write(), close()

int main() {
int fd = open("file.txt", O_CREAT | O_WRONLY, 0644); open() is used to create or . open a file.
"file.txt" → The name of the file.
O_CREAT → Create the file if it doesn’t exist .

O_WRONLY → Opens the file in write-only mode (no reading

0644 → File permission //

write(fd, "Hello, System Call!\n", 21); write(fd, buffer, size) writes data to the file.
fd → File descriptor (the file
to write to).
"Hello, System Call!\n" →
The text to write.
21 → The number of bytes
(characters) to write, including \n.
close(fd); // Close file
 return 0;
}

Example read the file in system calls.

#include<stdio.h>
#include <fcntl.h> // For open()
#include <unistd.h> // For read(), write(), close()

int main() {
int fd; // File descriptor

char buffer[100];
// Buffer to store file content, This is an array (temporary storage) to store the file's content while reading.

fd = open("file.txt", O_RDONLY); // Open file in read mode

if (fd < 0) return 1; // If error, exit

// If fd < 0, that means the file couldn’t be opened

return 1; stops the program with an error.

int bytes = read(fd, buffer, sizeof(buffer)); // read(fd, buffer, sizeof(buffer)) reads from the file into buffer.
It stores how many bytes were actually read in the variable bytes.

write(1, buffer, bytes); //write(1, buffer, bytes) writes the read data to the screen.
1 is the file descriptor for the screen to hold data content.

close(fd); // Close file

return 0;
}

OR (If you want to create ,write and read in single program.)

#include <fcntl.h>
#include <unistd.h>

int main() {
int fd;
char buffer[100];

// Create and write to the file

fd = open("file.txt", O_CREAT | O_WRONLY, 0777);
write(fd, "Hello, System Calls!\n", 21);
close(fd);
// Open and read the file
fd = open("file.txt", O_RDONLY);
read(fd, buffer, sizeof(buffer));
write(1, buffer, sizeof(buffer)); // Print to terminal (stdout)
close(fd);
return 0;
}

Example of Lseek

#include <fcntl.h>
#include <unistd.h>

int main() {
int fd = open("file.txt", O_RDWR | O_CREAT, 0644);

//open("file.txt", O_RDWR | O_CREAT, 0644);

  Opens "file.txt".
 O_RDWR → Open for reading and writing.
 O_CREAT → Create the file if it does not exist.
 0644 → Sets file permissions (Owner: Read & Write, Others: Read).
 Returns fd (file descriptor) or -1 if an error occurs //

lseek(fd, 0, SEEK_END); // Move to end of file

//Moves the file pointer to the end of the file.

 lseek(fd, 0, SEEK_END);
 fd → File descriptor of "file.txt".
 0 → Moves 0 bytes from the reference point.
 SEEK_END → Sets position at the end of the file.
 This ensures the next write() appends data at the end.//

write(fd, "XYZ", 3); // Write "XYZ" at the end

// Writes "XYZ" (3 characters) at the end of the file.

 "XYZ" is appended to the existing content.//

close(fd);
return 0;
}

===Delete file In system call=======

#include<stdio.h>
#include<unistd.h>

int main()
{
//FILE *file = fopen("fileum.txt");

unlink("fileum.txt");  file name – “fileum.txt

return 0;
}

====== Rename any file in system call =========

#include <stdio.h>
int main()
{
rename("1.txt", "1new.txt");
return 0;
}

===============Lseek==================
1 Example on lseek.
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
int fd;
char buffer[20];

fd = open("testfile.txt", O_RDWR | O_CREAT , 0666);

write(fd, "Hello, world",13);

lseek(fd, 0, SEEK_SET); // lseek() → Moves the file pointer.

read(fd, buffer,13);

lseek(fd,6, SEEK_SET); //SEEK_SET is a constant used in the lseek() function to set the file pointer to a specific position from the beginning of the file.

write(fd, "chatgpt", 7);

close(fd);
return 0;
}
After running the program, testfile.txt will contain:  Hello ,chatgpt

Example -2 on lseek

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
int fd = open("testfile1.txt", O_RDWR | O_CREAT, 0666);
lseek(fd,0, SEEK_END); //SEEK_END → Moves the pointer relative to the end of the file.
write(fd, "Kumar" ,5);
lseek(fd,5,SEEK_END);

close(fd);
return 0;
}

=======Stat========

#include <stdio.h>
#include <sys/stat.h> //#include <sys/stat.h> → Includes file status information functions, such as stat().

int main()
{
struct stat s; //The stat structure stores information about a file, such as:st_size → File size (in bytes).

stat("testfile.txt", &s);
printf("size: %ld bytes\n", s.st_size); //s.st_size contains the file size in bytes
return 0;
}

========chmod============

#include <stdio.h>
#include <sys/stat.h>
int main()
{
chmod("testfile.txt", 0777); // Set full read, write, execute permissions
printf("Permissions changed.\n");
return 0;
}
=====Hard Link (link() system call)=======

#include <unistd.h>

int main() {
link("original.txt", "hardlink.txt");
return 0;
}

=======Symbolic (Soft) Link (symlink() system call)======

#include <unistd.h>

int main() {
symlink("original.txt", "symlink.txt");
return 0;
}

4. Directory Manipulation using System Calls

Function Description Header

mkdir() Create a new directory <sys/stat.h>
rmdir() Remove a directory <unistd.h>
chdir() Change the current working directory <unistd.h>
getcwd() Get the current working directory <unistd.h>
opendir() Open a directory <dirent.h>
readdir() Read a directory <dirent.h>
closedir() Close a directory <dirent.h>

Open and Read Directory (opendir(), readdir(), closedir())

#include <stdio.h>

#include <dirent.h>

int main() {

DIR *d = opendir("."); //that is used to open directory in c.

struct dirent *e; // that is the pointer which is declare e to store directory entry , in c programming.

while ((e = readdir(d)) != NULL)

printf("%s\n", e->d_name); // e->d_name struct dirent member (field) that store file and folder name.

closedir(d);

}
Change Directory (chdir())

#include <unistd.h>

int main() {

chdir("/home");

Create Directory (mkdir())

#include <sys/stat.h>

int main() {

mkdir("newdir", 0777);

Remove Directory (rmdir())

#include <unistd.h>

int main() {

rmdir("newdir");

Get Current Directory (getcwd())

#include <stdio.h>

#include <unistd.h>

int main() {

char path[100];

getcwd(path, sizeof(path));

printf("%s\n", path);

Question - C Program to Demonstrate the Use of getcwd, chdir, and rmdir System Calls.

#include <stdio.h>
#include <unistd.h>
int main() {
char cwd[1024];

// Get current directory, change to /home, and print the new directory
if (getcwd(cwd, sizeof(cwd)) && printf("Current dir: %s\n", cwd) && chdir("/home") == 0 && getcwd(cwd, sizeof(cwd))
&& printf("New dir: %s\n", cwd) == 0 && rmdir("empty_directory") == 0) {
 printf("Removed empty directory.\n");
} else {
printf("Error occurred.\n");
}
return 0;
}

#include <stdio.h>
#include <unistd.h>

int main() {
char cwd[1024];

// Get current directory, change to /home, and print the new directory
if (getcwd(cwd, sizeof(cwd)) && printf("Current dir: %s\n", cwd) && chdir("/home") == 0 && getcwd(cwd, sizeof(cwd))
&& printf("New dir: %s\n", cwd) == 0 && rmdir("empty_directory") == 0) {
printf("Removed empty directory.\n");
} else {
printf("Error occurred.\n");
}

return 0;
}
#include <stdio.h>
#include <unistd.h>

int main() {
char cwd[1024];

// Get current directory, change to /home, and print the new directory
if (getcwd(cwd, sizeof(cwd)) && printf("Current dir: %s\n", cwd) && chdir("/home") == 0 && getcwd(cwd, sizeof(cwd))
&& printf("New dir: %s\n", cwd) == 0 && rmdir("empty_directory") == 0) {
printf("Removed empty directory.\n");
} else {
printf("Error occurred.\n");
}

return 0;
}

5. Process Management using System Calls

Process Management is an important function of the operating system that helps in creating,exeuting, controlling and ,
executing, controlling and terminating processes.

Process Management is a key function of the OS that controls process creation, execution, and termination.

fork() Creates a new process

exec() Replaces current process with another program
wait() Makes the parent process wait for the child process
exit() Terminates a process
getpid() Returns the Process ID (PID) of the current process
getppid() Returns the Parent Process ID (PPID)
kill() Terminates a process forcefully
nice() Sets process priority

fork()-Creating a New Process

 fork() is used to create a new child process from the parent process.
 The child process is an exact copy of the parent process

#include <stdio.h>
#include <unistd.h>

int main() {
fork(); // Create a child process

printf("Process ID: %d\n", getpid());

return 0;
}

exec() – Replacing a Process

 exec() is used to replace the current process with another program.
 Example: Running the ls -l command from a C program.

#include <stdio.h>
#include <unistd.h>
int main() {
printf("Executing 'ls -l' command..\n");
execl("/bin/ls", "ls", "-l", NULL);
printf("exec() failed!\n"); // This will execute only if exec fails
return 1;
}

getpid() & getppid() – Getting Process ID

 getpid() returns the process ID (PID) of the current process.

 getppid() returns the parent process ID (PPID).

#include <stdio.h>
#include <unistd.h>
int main() {
printf("Current Process ID: %d\n", getpid());
printf("Parent Process ID: %d\n", getppid());
return 0;
}
sleep() – Delaying Execution

 sleep(seconds) pauses execution for the given time.

#include <stdio.h>
#include <unistd.h>
int main() {
printf("Sleeping for 3 seconds...\n");
sleep(3);
printf("Process woke up!\n");
return 0;
}

exit() – Terminating a Process

 exit() is used to terminate a process safely.

 Used to terminate the current process.
 Directly exits the program without sending any signal.

#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Process is terminating...\n");
exit(0); // Successful termination, 0 indicates successful termination.
}

wait() – Waiting for Child Process

 wait() makes the parent wait until the child process finishes execution.
 Without wait(), the parent may finish first, leaving the child as an orphan process.
 If pid > 0, we are in the parent process.
 If pid == 0, we are in the child process.
 If pid < 0, an error occurred (not handled in this code).

#include <stdio.h>
#include<unistd.h>
#include<sys/wait.h>
int main()
{
int pid = fork();
if(pid>0) //If pid > 0, this is the parent process.
{
wait(NULL); //makes the parent wait for the child to complete before proceeding.
printf("child process completed\n");
}
else
{
printf("child process running\n");
}
return 0;
}

nice() – Changing Process Priority

 nice(value) adjusts the priority of a process.

 Lower value → Higher priority.

#include <stdio.h>
#include <unistd.h>
int main() {
int priority = nice(5); // Increases priority value
printf("New priority: %d\n", priority);
return 0;
}

Kill()
 Used to terminate another process.
 Sends a signal to the target process to stop it.
 Can forcefully terminate a process using kill(pid, SIGKILL);.

#include <signal.h>
#include <unistd.h>
#include <stdio.h>

int main() {
int pid = fork();

if (pid == 0) { // Child process

printf("Child running with PID: %d\n", getpid());
sleep(5); // Sleep so parent can kill it
printf("Child process exiting...\n");
} else { // Parent process
sleep(2);
printf("Killing child process...\n");
kill(pid, SIGKILL); // Forcefully terminate the child process
}
return 0;
}

6- Creation of Multithreaded Processes using PThread Library

A Thread is smallest unit of execution in a Process. Process can have multiple threads ,Threads can help the program
run faster by doing multiple things at once.

Single thread = One task at a time.

Multiple threads = Multiple tasks at the same time to improve performance by utilizing cpu efficiently. make programs
faster and more responsive.
pthread stands for POSIX (Portable Operating System Interface) Threads, which is a library used in C and C++
programming to allow a program to run multiple threads at the same time.

POSIX provides facilities for:

 File operations (like opening, reading, writing files)

 Process management (starting, stopping programs)
 Thread management (running tasks at the same time)
 Input/Output (I/O) operations (like printing things to the screen)

Compilation and execute threads.

gcc pthread_create.c –o pthread_create -pthread

-pthread: This is flag , It tells the compiler to include pthread support when compiling the program.

Where is the Main Thread Created?

When we run a C program, the operating system automatically creates the main thread. This thread runs
inside the main() function. So, in a C program, the main thread is the thread that executes the main()
function.

How to Identify the Main Thread?

We can use the pthread_self() function to check which thread is the main thread.
#include <stdio.h>
#include <pthread.h>

int main() {
printf("Main Thread ID: %lu\n", pthread_self());
return 0;
}
Commonly used library functions related to POSIX threads (pthread) :-
1. pthread_create () - Create a new thread

#include <pthread.h>
#include <stdio.h>

void* thread_function(void* arg) {

printf("Thread is running\n");
return NULL;
}
int main() {
pthread_t thread_id;

// Create the thread

pthread_create(&thread_id, NULL, thread_function, NULL);

printf("Created thread ID: %lu\n", thread_id);

 //lu -> print for Unsigned long integer with format specifier.

// Wait for the thread to finish

pthread_join(thread_id, NULL);

printf("Main thread completed\n");

return 0; }
2- pthread_join - Wait for termination of a specific thread
Syntax - int pthread_join(pthread_t thread, void **retval);

3 - pthread_exit()

 pthread_exit() is a command that makes the current thread stop running.

 It doesn't stop the entire program, just the thread that calls it.

#include <pthread.h>
#include <stdio.h>

// Function the thread will run

void* thread_function(void* arg) {
printf("Thread is running!\n");

// Stop the thread here

pthread_exit(NULL);

// This will NOT run

printf("This won't be printed!\n");
}

int main() {
pthread_t thread_id;

// Create the thread

pthread_create(&thread_id, NULL, thread_function, NULL);

// Wait for the thread to finish

pthread_join(thread_id, NULL);

printf("Main thread is done!\n");

return 0;}

4 - pthread_cancel()

It is used to cancel another thread that is running.

It asks the target thread to stop. However, it doesn’t immediately stop the thread, it will stop when
it,reaches a cancellation point (a safe point where it can stop).

#include <pthread.h>
#include <stdio.h>
#include <unistd.h> // For sleep()

void* thread_function(void* arg) { // Function that the thread will run

printf("Thread is running!\n");
sleep(5); // Simulate work by sleeping for 5 seconds
printf("Thread finished!\n");
return NULL;
}

int main() {
pthread_t thread_id;

pthread_create(&thread_id, NULL, thread_function, NULL); // Create the thread

sleep(2); // Wait for 2 seconds

pthread_cancel(thread_id); // Cancel the thread after 2 seconds

pthread_join(thread_id, NULL); // Wait for the thread to finish

printf("Main thread done!\n");

return 0;}

[&thread_id-This is a pointer to a pthread_t variable that will store the thread ID of the newly
created thread.
NULL, it means the thread will use the default attributes.
thread_function -This is a pointer to the function that the new thread will execute.
Null – argument passed to the thread_funtion)]

#include <stdio.h>
#include <pthread.h>

void* thread_function(void* arg) {

static int value = 42; // Static so it stays valid after function returns
return &value; // Return pointer to the value
}

int main() {
pthread_t thread;
int* result;

pthread_create(&thread, NULL, thread_function, NULL);

pthread_join(thread, (void**)&result); // Get pointer from thread

printf("Value returned from thread: %d\n", *result);

return 0;
 }

Create a pthread program to find the length of strings passed to the thread function.

#include <stdio.h>
#include <pthread.h>
#include <string.h>

// Thread function to find string length

void* find_length(void* arg) {
char* str = (char*)arg;
static int len; // static to return pointer
len = strlen(str);
return &len;
}

int main() {
pthread_t thread;
char str[] = "Hello, pthread!";
int* length;

pthread_create(&thread, NULL, find_length, str); // Pass string to thread

pthread_join(thread, (void**)&length); // Get returned length

printf("Length of string: %d\n", *length);

return 0;
}

Experiment 7: Process Synchronization using Semaphore/ Mutex

To compile process synchronization use –lpthread flag.

Synchronization

 Coordination of concurrent threads/processes to ensure orderly execution.

 Prevents inconsistent access to shared resources.

Race Condition

 Occurs when multiple threads/processes access shared resources without proper synchronization.
 Leads to unpredictable or incorrect results due to timing issues.

Semaphore

Definition: synchronization establish between processes or threads, semaphore is abstract data type.
Types:

 Binary Semaphore (0 or 1) – like a mutex.

 Counting Semaphore – allows access to multiple instances.

Functions:

Function Description Syntax

sem_init Initialize semaphore int sem_init(sem_t *sem, int pshared, unsigned int value);
sem_wait Wait (decrement/block) int sem_wait(sem_t *sem);
sem_post Signal (increment/unblock) int sem_post(sem_t *sem);
sem_destroy Destroy semaphore int sem_destroy(sem_t *sem);

Usage: Manages critical sections, prevents race conditions.

Mutex (Mutual Exclusion)

Definition: Ensures exclusive access to a shared resource – synchronization establish between threads.

Types:

 Recursive Mutex: Same thread can lock multiple times.

 Non-recursive Mutex: Deadlocks if locked multiple times by the same thread.

Functions:

Function Description Syntax

pthread_mutex_init Initialize mutex int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
pthread_mutex_lock Lock mutex (wait) int pthread_mutex_lock(pthread_mutex_t *mutex);
pthread_mutex_unlock Unlock mutex int pthread_mutex_unlock(pthread_mutex_t *mutex);
pthread_mutex_destroy Destroy mutex int pthread_mutex_destroy(pthread_mutex_t *mutex);

Usage: Ensures mutual exclusion, protects shared data, prevents simultaneous access.

Avoid Race condition using semaphore.

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

int x = 0;
sem_t sem; // Declare a semaphore

void* task() {
sem_wait(&sem); // Acquire lock (enter critical section)
x = x + 1;

sem_post(&sem); // Release lock (exit critical section)

return NULL;
}
 int main() {
sem_init(&sem, 0, 1); // Initialize semaphore with value 1

for (int i = 0; i < 500; i++) {

x = 0; // Reset before each run

pthread_t a, b;
pthread_create(&a, NULL, task, NULL);
pthread_create(&b, NULL, task, NULL);
pthread_join(a, NULL);
pthread_join(b, NULL);

if (x != 2) {
printf("Race condition detected! x = %d\n", x); ;
} else {
printf(" x = %d\n", x);
}
}

sem_destroy(&sem); // Cleanup

return 0;

Simulating race condition

#include<stdio.h>
#include<pthread.h>
int x=0;
void* task()
{
x=x+1;
}
int main()
{
int i;
for (i = 0; i < 1000; i++) {
x = 0; // Reset before each run

pthread_t a,b;
pthread_create(&a,NULL,task,NULL);
pthread_create(&b,NULL,task,NULL);
pthread_join(a,NULL);
pthread_join(b,NULL);
if (x != 2) {
printf("Race condition found x = %d\n", x);
} else {
printf(" x = %d\n", x);
} }
return 0;
}