Embed Size (px)
Citation preview
WRITE A SHELL PROGRAM TO CHECK THE GIVEN STRING IS PALINDROME OR NOT.
l=0
Cnt=l
Tag=0
Echo “ Enter a string ?”
Read str
1= ‘echo $ str/wc-c
l= ‘expr $ ½’
while [ $ cnt- le $ lh ]
do
c1 = ‘echo $ str/cut-c $ cnt’
c2 = ‘echo $ str/cut-c $ 1’
if [ $ cl ! = $ c2]
then
cut = $lh
tag = l
fi
cnt = ‘ expr scnt +1’
= ‘ expr $ 1-1”
Done
If [ $ tag - ego]
Then
Echo “ string is palindrome”
Else
Echo “ string is not palindrome”
fi
OUTPUT:
WRITE A SHELL PROGRAM TO FIND FACTORIAL.
echo "Enter a number"
read num
fact=1
n=$num
while [ $num -ge 1 ]
do
fact=`echo $fact \* $num|bc`
let num--
done
echo "factorial of $n is $fact"
OUTPUT:
WRITE A SHELL PROGRAM TO FIND BIGGEST AMONG THREE NUMBERS.
Echo “Enter A value:”
Read a
Echo “Enter B value:”
Read b
Echo “Enter C value:”
Read c
If [$a-gt $b] && [$a-gt $c]
Then
Echo “ A value is greater”
Elif [$b-gt $a] && [$b-gt $c]
Then
Echo “ B value is greater”
Else
Echo “ C value is greater”
fi
OUTPUT:
IMPLEMENTATION OF LINK AND UNLINK IN C.
#include <sys/types.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#define LOCKFILE "/etc/ptmp"
#define PASSWDFILE "/etc/passwd"
#define SAVEFILE "/etc/opasswd"
...
/* If no change was made, assume error and leave passwd unchanged. */
if (!valid_change) {
fprintf(stderr, "Could not change password for user %s\n", user);
unlink(LOCKFILE);
exit(1);
}
/* Change permissions on new password file. */
chmod(LOCKFILE, S_IRUSR | S_IRGRP | S_IROTH);
/* Remove saved password file. */
unlink(SAVEFILE);
/* Save current password file. */
link(PASSWDFILE, SAVEFILE);
/* Remove current password file. */
unlink(PASSWDFILE);
/* Save new password file as current password file. */
link(LOCKFILE,PASSWDFILE);
/* Remove lock file. */
unlink(LOCKFILE);
exit(0);
STUDY ABOUT THE GENERAL PURPOSE UTILITIES :-(A) BANNER(B) CAL(C) DATE(D) TTY(E) BC(F) SPELL AND FSPELL
(A) BANNER :-
The Unix banner program outputs a large ASCII art version of the text that is supplied to it as its program arguments. One use of the command is to create highly visible separator pages for print jobs.
Implementation
The way that the program is implemented internally is error-prone and antiquated. The character fonts used are hardwired into the program code itself, as statically initialized data structures. Two data structures are used. The first is a data table comprising a sequence of printing instructions that encode the bitmap for each character (in an encoding specific to the banner program). The second is an index
into that table that indicates, for each character code, where the printing instructions for that character begin and end.
Both data structures were hand-written. Spinellis observes that it is "difficult to come up with a more error-prone and unmaintainable data format". He observes a stark contrast between the source code of the banner program and automatically generated source code for encoding computer fonts into program data (using the 6-by-10 font data in the source code of the mac68k port of NetBSD for comparison). The automatically generated data are commented, documenting with ASCII art how the bit patterns were derived. The automatically generated data were generated from a bitmap file, itself generated using a bitmap creation/editing program with a graphical user interface. And the automatically generated data are organized in a straightforward and obvious manner — a fixed-length sequence of unencoded bytes for each glyph.
Spinellis further observes that in modern computer systems it is seldom sensible to embed such data into the program executable image itself, the performance gains of doing so being negligible. Doing so makes it difficult to adapt the program to different locales, or to maintain the program. The more preferred approach in modern systems is to store such data in a separate data file, distinct from the program executable image file, or in a resource fork of the program, that the program reads at run-time.
Operation
Each argument is truncated at 10 characters and printed on a "line" of its own. To print multiple words on a single line, they must therefore be passed as a single argument, which is done from the shell by escaping or quoting the words as appropriate.
A related, and more flexible, program is figlet, which can display text in different fonts and orientations.
SYNTAX:
$banner
(B) CAL :-
cal is a standard program on Unix and Unix-like operating systems that prints an ASCII calendar of the given month or year. If the user does not specify any command-line options, cal will print a calendar of the current month.
SYNTAX:
$cal
Examples
$ cal
April 2010
Su Mo Tu We Th Fr Sa
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
The Gregorian reformation was adopted by the Kingdom of Great Britain, including its possessions in North America (later to become eastern USA), in September 1752. As a result the September 1752 cal shows the adjusted days missing. This month was the official (British) adoption of the Gregorian calendar from the previously used Julian calendar. This has been documented in the man pages for Sun Solaris as follows. "An unusual calendar is printed for September
1752. That is the month 11 days were skipped to make up for lack of leap year adjustments." The Plan 9 from Bell Labs manual states: "Try cal sep 1752."
(C) DATE :-
Date" is utility to set the time and create a timestamp is user-defined format in Unix, Linux or BSD system. It does not have the ability to convert one timestamp representation into another but BSD variant has the ability to convert date representation in seconds to any format you wish. there are also numerous "Unix timestamp calculators" on the WEB. for example
Standard Time To UNIX Timestamp Calculator
*
4WebHelp - Online Tools Unix Timestamp Converter
It was first seen in Version 1 of AT&T Unix, circa 1969, and has both grown and improved over the years to provide you with a wide variety of configurable options for your system.
The most important for scripting functionality of date is the the ability to create timestamp is wide variety of formats.
date +"%Y/%m/%d %H:%M"
The output should look something like this:
2010/01/04 06:28
If you are ok with two year year representation you can use %y instead of %Y. There is also a macro %D that provides date in mm/dd/yy format, so we can rewrite the previous example as
date +"%D %H:%M"
Here are most important build-in macros for date:
* %% a literal %
* %a locale's abbreviated weekday name (Sun..Sat)
* %A locale's full weekday name, variable length (Sunday..Saturday)
* %b locale's abbreviated month name (Jan..Dec)
* %B locale's full month name, variable length (January..December)
* %c locale's date and time (Sat Nov 04 12:02:33 EST 1989)
* %d day of month (01..31)
* %D date (mm/dd/yy)
* %e day of month, blank padded ( 1..31)
* %H hour (00..23)
* %j day of year (001..366)
* %m month (01..12)
* %M minute (00..59)
* %n a newline
* %p locale's AM or PM
* %r time, 12-hour (hh:mm:ss [AP]M)
* %S second (00..60)
* %t a horizontal tab
* %T time, 24-hour (hh:mm:ss)
* %U week number of year with Sunday as first day of week (00..53)
* %V week number of year with Monday as first day of week (01..52)
* %w day of week (0..6); 0 represents Sunday
* %W week number of year with Monday as first day of week (00..53)
* %x locale's date representation (mm/dd/yy)
* %X locale's time representation (%H:%M:%S)
* %y last two digits of year (00..99)
* %Y -- ccyy year
Date also can work not with the current time but with time of modification of the referenced file
date -r /etc/passwd +"%y%m%d"
It also can serve as data calculator.
Various options for past days (GNU date only):
date +"%Y%m%d" -d sunday # GNU date
20060709
date +"%Y%m%d" -d last-sunday # GNU date
20060702
date +"%Y%m%d" -d last-week # GNU date
date -v -1m +"%Y%m%d" # BSD date
20060627
date +"%Y%m%d" -d last-month # GNU date
date -v -1w +"%Y%m%d" # BSD date
20060604
date +"%Y%m%d" -d last-year # GNU date
date -v -1y +"%Y%m%d" # BSD date
20050704
date +"%Y%m%d" -d next-week # GNU date
date -v 1w +"%Y%m%d" # BSD date
20060711
date +"%Y%m%d" -d next-month # GNU date
date -v 1m +"%Y%m%d" # BSD date
20060804
date +"%Y%m%d" -d next-year # GNU date
date -v 1y +"%Y%m%d" # BSD date
20070704
To show the time in seconds since 1970-01-01 (Unix epoch):
date +"%s" -d "Fri Apr 24 13:14:39 CDT 2009"
1240596879
To convert Unix epoch time (seconds since 1970-01-01) to a human readable format:
date -d "UTC 1970-01-01 1240596879 secs"
Fri Apr 24 13:14:39 CDT 2009
Or:
date -ud @1000000000
Sun Sep 9 01:46:40 UTC 2001
Examples
date "+%-m/%-d/%y"
7/4/06
date "+%Y%m%d"
20060704
$ date +"%b %d, %Y"
Mar 14, 2010
date -d yesterday +"%Y/%m/%d"
2010/03/13
Yesterday assigned to variable
DATE=$(date -d yesterday +"%Y%m%d")
echo $DATE
20060704
To assign the time to a variable
START=`date '+%r'`
echo $START
03:06:02 PM
sleep 5
echo $START
03:06:02 PM
N.B. the variable has the time when it was assigned.
Yesterday assigned to variable
DATE=$(date -d yesterday +"%Y%m%d")
echo $DATE
20060704
To show the time in a different timezone, the TZ environmentvariable is read, Timezone types is found in /usr/share/zoneinfo
OLDTZ=$TZ
export TZ=GMT; echo "GMT: `date +\"%F %R (%Z)\"`"
GMT: 2008-10-31 12:30 (GMT)
export TZ=Europe/Stockholm; echo "Stockholm: `date +\"%F %R (%Z)\"`"
Stockholm: 2008-10-31 13:30 (CET)
export TZ=Asia/Kuala_Lumpur; echo "Kuala Lumpur: `date +\"%F %R (%Z)\"`"
Kuala Lumpur: 2008-10-31 20:30 (MYT)
export TZ=US/Central; echo "Dallas: `date +\"%F %R (%Z)\"`"
Dallas: 2008-10-31 07:30 (CDT)
export TZ=$OLDTZ
Using date for offset calculation:
date +"%Y%m%d" -d sunday
20060709
date +"%Y%m%d" -d last-sunday
20060702
date +"%Y%m%d" -d last-week
20060627
date +"%Y%m%d" -d last-month
20060604
date +"%Y%m%d" -d last-year
20050704
date +"%Y%m%d" -d next-week
20060711
date +"%Y%m%d" -d next-month
20060804
date +"%Y%m%d" -d next-year
20070704
(D) TTY :-
tty is a Unix command that prints to standard output the name of the file connected to standard input. The name of the program comes from teletypewriter, abbreviated "TTY".
SYNTAX:
$tty
When the program runs, it will output something like this:
$ tty
/dev/pts/4
The pts indicates that it is a pseudo terminal, with the number following it. If the program was run on a true tty, it would output something like this:
$ tty
/dev/tty2
(E)BC :-
bc is "an arbitrary precision calculator language" with syntax similar to the C programming language. It is generally used by typing the command bc on a Unix command prompt and entering a mathematical expression, such as (1 + 3) * 2, whereupon 8 will be output.
There are currently two main dialects: the rigorously defined POSIX bc, and its direct descendant, the much expanded GNU bc (also, GNU bc is available for a wider range of platforms, such as Microsoft Windows). A more recent dialect, Plan 9 bc, is a superset of the former and subset of the latter.All three forms of bc can be executed as either a mathematical scripting language or as an interactive mathematical shell.SYNTAX:$bcOperations^d1 base _input base0 base _output base are used for base conversions.BASE:Decimal: 1Binary: 2Octal: 8Hexadecimal: 16POSIX bcThe POSIX standardized bc language is traditionally written as a program in the dc programming language to provide a higher level of access to the features of the dc language without the complexities of dc's terse syntax.In this form, the bc language contains single letter variable, array and function names and most standard arithmetic operators as well as the familiar control flow constructs, (if(cond)..., while(cond)... and for(init;cond;inc)...) from C. Unlike C, an if clause may not be followed by an else.Functions are defined using a define keyword and values are returned from them using a return followed by the return value in parentheses. The auto keyword (optional in C) is used to declare a variable as local to a function.All numbers and variable contents are arbitrary precision numbers whose precision (in decimal places) is determined by the global scale variable.The numeric base of input (in interactive mode), output and program constants may be specified by setting the reserved ibase (input base) and obase (output base) variables.Output is generated by deliberately not assigning the result of a calculation to a variable.
Comments may be added to bc code by use of the C /* and */ (start and end comment) symbols.Mathematical operators Exactly as CThe following POSIX bc operators behave exactly like their C counterparts:+ - * /+= -= *= /=++ -- < >== != <= >=( ) [ ] { }Similar to CThe modulus operators: % %=... behave exactly like their C counterparts only when the global scale variable is set to 0, i.e. all calculations are integer-only. When scale is greater than 0 the modulus is calculated relative to the smallest positive value greater than zero.Only resembling C
The operators:
^ ^=
... resemble the C bitwise exclusive-or operators, but are in fact the bc integer exponentiation operators. 'Missing' operators relative to C
The bitwise, boolean and conditional operators:
& | ^ && || ^^
&= |= ^= &&= ||= ^^=
<< >>
<<= >>=
?:
... are not available in POSIX bc.Built-in functions
The sqrt() function for calculating square roots is POSIX bc's only built-in mathematical function. Other functions are available in an external standard library.Standard library functions
bc's standard math library (defined with the -l option) contains functions for calculating sine, cosine, arctangent, natural logarithm, the exponential function and the two parameter Bessel function J. Most standard mathematical functions (including the other inverse trigonometric functions) can be constructed using these. See external links for implementations of many other functions.
Please, note that the scale changes with the -l option to 20 (source). So things such as modulo may work unexpectedly. For example, write "bc -l" and then the command "print 3%2" outputs 0, instead of 1. But if you do it like "bc -l", "scale=0" and then the command "print 3%2" has 1 as output.Plan 9 bc
Plan 9 bc is just like POSIX bc but for an additional print statement.GNU bc
GNU bc derives from the POSIX standard and includes many enhancements. It is entirely separate from dc-based implementations of the POSIX standard and is instead written in C. Nevertheless, it is fully backwards compatible as all POSIX bc programs will run unmodified as GNU bc programs.
GNU bc variables, arrays and function names may contain more than one character, some more operators have been included from C, and notably, an if clause may be followed by an else.
Output is achieved either by deliberately not assigning a result of a calculation to a variable (the POSIX way) or by using the added print statement.
Furthermore, a read statement allows the interactive input of a number into a running calculation.
In addition to C-style comments, a # character will cause everything after it until the next new-line to be ignored.
The value of the last calculation is always stored within the additional built-in last variable.Extra operators
The following logical operators are additional to those in POSIX bc:
&& || !
... and are available for use in conditional statements (such as within an if statement). Note, however, that there are still no equivalent bitwise or assignment operations.Functions
All functions available in GNU bc are inherited from POSIX. No further functions are provided as standard with the GNU distribution.
(F)SPELL AND FSPELL :-
One of the characteristics of the English written language is that its orthography (i.e., spelling) is complex and can be difficult to remember. This is in contrast to many languages (e.g., Spanish and German) for which the spelling of words is closely related to their pronunciation. Fortunately, technology has come to the rescue, and there are multiple ways to check and correct spelling on Linux and other Unix-like operating systems.
One of the simplest, and sometimes most convenient, of these spelling checkers is the spell command. Despite its lack of sophisticated features, it is still worth being aware of spell for several reasons, including (1) it is very easy to use, (2) it can be found on many Unix-like systems and (3) it is well suited for use with other commands linked by pipes (which are used to combine commands).
spell compares words typed in at the keyboard or the contents of a text file to those in a built-in dictionary file and then writes all of the words not in the dictionary (and, therefore, presumably misspelled) to standard output (which is the display screen by default).
On some systems spell is a stand-alone program, either the original version or the GNU clone. On others, such as Red Hat Linux 9, it is a shell script (i.e., a simple program) that launches a simplified version of another spelling checking program, aspell, which emulates the core function of spell.
spell displays each presumably misspelled word on a new line. In the case of the Red Hat version, the words are displayed in alphabetic order and each erroneous spelling is displayed only once, regardless of the number of times that it appears in the text. If multiple files are specified for checking, a single, alphabetized list of words is still generated.
spell's syntax is
spell [options] [file_name(s)]
The items in the square brackets are optional. When no file names are supplied as arguments (i.e., inputs), spell will read from standard input, which by default is text typed in at the command line.
For example, it can easily be determined whether the word desireable is spelled correctly by first entering at the command line the spell command, pressing the RETURN key, typing the word desireable, pressing RETURN again and then simultaneously press the CONTROL key and the d key. The output will look like the following:
$ spell desireable desireable $
The word desireable is echoed (i.e., repeated by the system) because it is not in the system dictionary and is thus quite likely a spelling error. If the same procedure is repeated using desirable (i.e., omitting the second e), then it is not echoed, because it is in the system dictionary and is therefore the correct spelling. Thus, the screen would look like:
$ spell desirable $
spell can also be used with lists of words and sentences. For example, typing spell, pressing the RETURN key, typing the sentence This is the storry abuot an operating system that went from baad to wurse, pressing RETURN again, and finally simultaneously pressing the CONTROL key and the d key would produce the following output:
$ spell This is the storry abuot an operating system that went from baad to wurse abuot baad
storry wurse $
To find any spelling errors in a file, all that is necessary to supply the name of the file as an argument after the command and any options. For example, the following will search for errors in a file named file1:
spell file1
spell can be used to check any number of files simultaneously by listing them all as arguments, for example:
spell file1 file2 file3
It is then a simple matter to correct the misspellings using a text editor (e.g., vi or gedit).
As is the case with other filters, the output of spell can be redirected from standard output using the standard output redirection operator, which is designated by a rightward facing angular bracket. For example, the following tells spell to check the spelling of all words in the first three files and write its output to file4 instead of to the display screen:
spell file1 file2 file3 > file4
The output of spell can also be further processed by using pipes to send it to other filters. For example, in the following example the output of spell is piped to grep (which is used to search for files and the contents of files) in order to display only those misspelled words in file5 that contain the sequence of letters com
spell file5 | grep com
The output could likewise be redirected to a file instead of to the display screen, such as to a new or existing file named file6:
spell file5 | grep com > file6
Although spell is very useful for checking text against the several tens of thousands of commonly used words in the English language that are included in the dictionary file, it does not do a good job of checking technical terminology, proper nouns (e.g., names of people, places and products) and slang.
Also, spell is not interactive. That is, it does not highlight misspelled words in a file and assist the user in correcting them one by one in the context of the text. However, this can be an advantage in some cases, particularly if the user merely wants to see a list of the potentially misspelled words in a file without having to go through and attempt to correct all of them.
Moreover, some of the useful features that come with the original version of spell are not found on the aspell emulation version. For example, the original Unix version has several options, including -b, which accepts UK spellings (e.g. labour, colour, centre), and -x, which displays every possible stem for each word. The original version also allows users to create their own supplementary dictionary files, which can be very useful for adding technical terms and proper nouns.
When more features are desired for a command line spelling checker than are available on the the aspell emulation version, the user should consider installing the original version of spell or its GNU clone or using a more sophisticated program such as aspell or ispell, both of which are interactive and allow the use of user-created dictionaries. aspell is better at making suggestions when a word is seriously misspelled, whereas ispell has the advantage that it can be used with numerous foreign languages.
This article was written using the gedit text editor on a Red Hat 9 Linux machine. spell was used to check the spelling after the final proofreading by the author, and it found several errors. Interestingly, the only word that was misspelled multiple times was the word misspell itself, which was spelled mispell.
IMPLEMENTATION OF GREP COMMAND IN C.
#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <unistd.h>
/* calculate filesize */int calc_bufsize(char *filename){struct stat st;
stat(filename, &st);return ((int)st.st_size);}
int main(int argc, char *argv[]){if(argc < 3)
{printf("Usage:\n\t%s <word> <files> ...\n", argv[0]);return -1;}
FILE *fp;char *filename;int x = 2;
/* process each file */for(x; x != argc; x++){filename = argv[x];
if( (fp = fopen(filename, "r")) == NULL){printf("Failed to open file: %s\n", argv[2]);return -2;}
int BUFSIZE = calc_bufsize(filename);
/* read ENTIRE file into buf[] */char buf[BUFSIZE];fread(&buf, sizeof(char), BUFSIZE, fp);
/* search buf for word (case sensitive) */char *ans = strstr(buf, argv[1]);
/* word found, print filename */if(ans != NULL)printf("%s\n", filename);
/* word not found, do nothing */
fclose(fp);}return 0;}
IMPLEMENTATION OF WE COMMAND IN C.
/*count.c : Count characters in a file*/
#include <stdio.h>
#include<process.h>
void main()
/* Prompt user for file and count number of characters
and lines in it*/
{
FILE *fopen(), *fp;
int c , nc, nlines;
char filename[40] ;
nlines = 0 ;
nc = 0;
printf("Enter file name: ");
gets( filename );
fp = fopen( filename, "r" );
if ( fp == NULL )
{
printf("Cannot open %s for reading \n", filename );
exit(1); /* terminate program */
}
c = getc( fp ) ;
while ( c != EOF )
{
if ( c == '\n' )
nlines++ ;
nc++ ;
c = getc ( fp );
}
fclose( fp );
if ( nc != 0 )
{
printf("There are %d characters in %s \n", nc, filename );
printf("There are %d lines \n", nlines );
}
else
printf("File: %s is empty \n", filename );
}
IMPLEMENTATION OF MORE COMMAND IN C.
#include<stdio.h>
#include<conio.h>
#include<process.h>
void main()
{
clrscr();
FILE *fopen(),*fp;
int c,count=1,count2=1;
char file_name[50];
printf("Enter The file name :");
gets(file_name);
fp=fopen(file_name,"r");
if ( fp == NULL )
{
printf("Cannot open %s for reading \n", file_name );
exit(1); /* terminate program */
}
c=getc(fp);
while(c!=EOF)
{
if(c=='\n')
count++;
c=getc(fp);
}
fclose(fp);
fp=fopen(file_name,"r");
c=getc(fp);
while(c!=EOF)
{
if(c=='\n')
count2++;
if(count2%49==0)
{
per=(count2/count)*100;
printf("--MORE--%d%",per);
}
c=getc(fp);
}
fclose(fp);
}
IMPLEMENTATION OF LS COMMAND IN C.
#include<iostream.h>#include<sys/types.h>#include<direct.h>#include<stdlib.h>
int main(int argc, char *argv[]){int i;DIR*dp;struct direct*dirp;
if (argc==2)
{dp = opendir(argv[1]);while ((dirp = readdir(dp)) != NULL)printf("%s\n", dirp->d-name);}else{if (argc == 1){dp = opendir(".");while ( (dirp = readdir(dp)) != NULL)printf("%s\n", dirp->d-name);}else{printf("ls - Error - too many parameters\n");exit(0);}
};closedir(dp);return 0;}
Output
INDEX
S.No Practical Questions Date Remarks1. Installation of unix & linux
2. Study about general purpose utilities:
(1)Banner(2)Cal
(3)Date(4)Tty(5)Bc(6)Spell and fspell
3. Implementation of WE command in C
4. Implementation of Grep command in C
5. Implementation of More command in C
6. Implementation of Link and Unlink command in C
7. Implementation of LS command in C
8. Study about unix system variables
9. Write the shell program to find biggest among three numbers.
10. Write a shell program to find factorial.
11. Write a shell program to check the given string is palindrome or not.
IMPLEMENTATION OF GREP COMMAND IN C
#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <unistd.h>
/* calculate filesize */int calc_bufsize(char *filename){struct stat st;
stat(filename, &st);return ((int)st.st_size);}
int main(int argc, char *argv[]){if(argc < 3){printf("Usage:\n\t%s <word> <files> ...\n", argv[0]);return -1;}
FILE *fp;char *filename;int x = 2;
/* process each file */for(x; x != argc; x++){filename = argv[x];
if( (fp = fopen(filename, "r")) == NULL){printf("Failed to open file: %s\n", argv[2]);return -2;}
int BUFSIZE = calc_bufsize(filename);
/* read ENTIRE file into buf[] */char buf[BUFSIZE];fread(&buf, sizeof(char), BUFSIZE, fp);
/* search buf for word (case sensitive) */
char *ans = strstr(buf, argv[1]);
/* word found, print filename */if(ans != NULL)printf("%s\n", filename);
/* word not found, do nothing */
fclose(fp);}return 0;}
