I have an array of structures, where each structure contains a first name and a last name, along with other information. I'm trying to print the array in tabular form, something like this
+---------------------------+--------+--------+
| Student Name | Test 1 | Test 2 |
+---------------------------+--------+--------+
| Pousseur, Henri | 95 | 92 |
| Boyer, Charles | 90 | 97 |
+---------------------------+--------+--------+
However, my output looks like this
+---------------------------+--------+--------+
| Student Name | Test 1 | Test 2 |
+---------------------------+--------+--------+
| Pousseur, Henri | 95 | 92 |
| Boyer, Charles | 90 | 97 |
+---------------------------+--------+--------+
My question is, how do I concatenate the last name to the first name (with a comma in between), and then print the whole thing as a fixed width string? So that my table lines up correctly.
Here's my code:
#include <stdio.h>
#define NAME_LEN 25
typedef struct
{
char fname[NAME_LEN+1];
char lname[NAME_LEN+1];
int score1;
int score2;
} STUREC;
void printRecords(STUREC records[], int count)
{
printf("+---------------------------+--------+--------+\n");
printf("| Student Name | Test 1 | Test 2 |\n");
printf("+---------------------------+--------+--------+\n");
for (int i = 0; i < count; i++)
printf ("| %-s, %-26s| %4d | %4d |\n", records[i].lname, records[i].fname, records[i].score1, records[i].score2 );
printf("+---------------------------+--------+--------+\n");
}
int main(void)
{
STUREC records[] = {
{ "Henri" , "Pousseur", 95, 92 },
{ "Charles", "Boyer" , 90, 97 }
};
printRecords(records, 2);
}
Note that printf returns the number of characters printed. So if you want to print the name within a fixed width, you can print the name, and then output spaces as needed to fill the width.
#define WIDTH 26
int count = printf( "%s, %s", records[i].lname, records[i].fname );
if ( count < WIDTH )
printf( "%*s", WIDTH-count, "" );
In the format string "%*s", the * tells printf that the width of the string will be passed as an argument. The WIDTH-count argument is the number of spaces that need to be printed, and "" is just an empty string. So for example, if count is 16, then WIDTH-count is 10, so the printf is equivalent to
printf( "%10s", "" );
which will print 10 spaces.
This is just an adpatation of #user3386109 answer.
Add
#define WIDTH 27 // You get a max width of 26
somewhere in the beginning of your program and a string
char fullname[WIDTH];
somewhere in the beginning of the main.
Then make changes like below :
printf("\n+---------------------------+--------+--------+--------+--------+--------+--------+---------+-------+\n");
printf("| Student Name | ID | Test 1 | Test 2 | Proj 1 | Proj 2 | Proj 3 | Average | Grade |\n");
printf("+---------------------------+--------+--------+--------+--------+--------+--------+---------+-------+\n");
for (i = 0; i < count; i++)
{
int lname_len=strlen(records[i].lname);
int fname_len=strlen(records[i].fname);
snprintf(fullname,WIDTH,"%s,%s%*s", records[i].lname,records[i].fname,(WIDTH>(lname_len+fname_len)?(WIDTH-(lname_len+fname_len)):0),"");
/* The above step concatenates - since you're very interested in it -
* the sirname and the first name into a string fullname making sure
* that the string is padded to 26 characters utmost.
*/
printf ("| %s | %-7.6d| %4d | %4d | %4d | %4d | %4d | %6.2f | %-2s |\n", fullname, records[i].id, records[i].score1,
records[i].score2, records[i].score3, records[i].score4, records[i].score5,
records[i].ave, records[i].grade);
}
printf("+---------------------------+--------+--------+--------+--------+--------+--------+---------+-------+\n");
printf("\nHave A Terrible Day!\n\n");
Note the ternary expression :
(WIDTH>(lname_len+fname_len)?(WIDTH-(lname_len+fname_len)):0)
in snprintf. This will be evaluated to unused width, if any which we pad with emptry strings "" or null characters.
If you didn't understand it please have a look here
Related
I made a program to print an ASCII table up to a certain range (like ASCII from 0 to 104).
#include <stdio.h>
int main(void)
{
int n;
printf("\n\nthis program will print list of ASCII values for your computer enter the upper limit for the range - ");
scanf("%d", &n);
printf("\nDECIMAL\tCHARACTER");
for (int i = 0; i <= n; i++)
{
printf("\n %d | %c", i, i);
// printf("\n-------------");
printf("_"); //when i include this "undescore" it causes problems, the code stops at 27th ASCII character and gets stuck.
}
return 0;
}
The 27 decimal corresponds to ASCII SYSTEM CODE - [ESCAPE].
None of the following works, and the code stops at the 27th ASCII character:
printf("__"); //double or multiple underscore does not work.
printf("\n_"); //this doesnt work either.
printf("//_"); //somehow this works.
If I remove that printf("_"); part then the code does not stop at 27 and runs smoothly, the code only stops when I use the underscore (_) character.
If I use a different character (-, *, etc), it runs smoothly.
What can the problem be? Could it be something related to macros?
Edit-
when I replaced 'printf("_");' with 'printf("n");' thinking it would perform the same as '\n' some weird language popped up and the language of the terminal changed.
when '_' is replaced by 'n'
Your terminal support ANSI escape sequences which means it does something with ESC _: Application Program Command. In general, if your printing it, you probably want to make sure it shows up so I am using an alternative format here for non-printable characters:
#include <ctype.h>
#include <stdio.h>
int main(void) {
printf("\n\nthis program will print list of ASCII values for your computer enter the upper limit for the range - ");
int n;
scanf("%d", &n);
printf("\nDECIMAL\tCHARACTER");
for (int i = 0; i <= n; i++) {
if(isprint(i))
printf("\n %d | %c", i, i);
else
printf("\n %d | 0x%x", i, i);
printf("_");
}
}
Here is a sample output:
this program will print list of ASCII values for your computer enter the upper limit for the range - 38
DECIMAL CHARACTER
0 | 0x0_
1 | 0x1_
2 | 0x2_
3 | 0x3_
4 | 0x4_
5 | 0x5_
6 | 0x6_
7 | 0x7_
8 | 0x8_
9 | 0x9_
10 | 0xa_
11 | 0xb_
12 | 0xc_
13 | 0xd_
14 | 0xe_
15 | 0xf_
16 | 0x10_
17 | 0x11_
18 | 0x12_
19 | 0x13_
20 | 0x14_
21 | 0x15_
22 | 0x16_
23 | 0x17_
24 | 0x18_
25 | 0x19_
26 | 0x1a_
27 | 0x1b_
28 | 0x1c_
29 | 0x1d_
30 | 0x1e_
31 | 0x1f_
32 | _
33 | !_
34 | "_
35 | #_
36 | $_
37 | %_
The code ran differently than I predicted, I think *(score+i*n+j) is problematic, it could also be a problem elsewhere, I'm not quite sure, but I don't know how to modify it.
#include <stdio.h>
#define STUD 30 // Maximum number of students possible
#define COURSE 5 // The maximum number of possible exam subjects
void Total(int *score, int sum[], float aver[], int m, int n);
void Print(int *score, int sum[], float aver[], int m, int n);
int main(void)
{
int i, j, m, n, score[STUD][COURSE], sum[STUD];
float aver[STUD];
printf("Enter the total number of students and courses:\n");
scanf("%d %d",&m,&n);
printf("Enter score:\n");
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
scanf("%d", &score[i][j]);
}
}
Total(*score, sum, aver, m, n);
Print(*score, sum, aver, m, n);
return 0;
}
void Total(int *score, int sum[], float aver[], int m, int n)
{
int i, j;
for (i = 0; i < m; i++)
{
sum[i] = 0;
for (j = 0; j < n; j++)
{
sum[i] = sum[i] + *(score + i * n + j);
}
aver[i] = (float) sum[i] / n;
}
}
void Print(int *score, int sum[], float aver[], int m, int n)
{
int i, j;
printf("Result:\n");
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
printf("%4d\t", *(score + i * n + j));
}
printf("%5d\t%6.1f\n", sum[i], aver[i]);
}
}
Example of a program running:
Enter the total number of students and courses:
2 3↙
Enter score:
90↙
95↙
97↙
82↙
73↙
69↙
Result:
90 95 97 282 94.0
82 73 69 224 74.7
Compiling your program yields no warnings or errors. Running it with the sample input you've provided yields:
Enter the total number of students and courses:
2 3
Enter score:
90
95
97
82
73
69
Result:
90 95 97 282 94.0
404780 0 82 404862 134954.0
This is correct for the first set of scores, but not the second. As you intuited, this means your math for accessing the array via pointer math is probably wrong.
Consider what your array actually looks like in memory. You've allocated on the stack an array that looks like:
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
Your example input has filled it like this:
+---+---+---+---+---+
| 90| 95| 97| | |
+---+---+---+---+---+
| 82| 73| 69| | |
+---+---+---+---+---+
...
If you want to access the first element of the second row, you need your offset to be i * 5 rather than i * 3 which is what happens when you use i * n. This 5 we can get from your constant COURSE.
*(score + i * COURSE + j)
When you use a different offset you get data which has not been initialized, which is why you see garbage values. If you initialize all of the values in your array to 0, but leave your code otherwise unchanged, you can see this in action.
int i, j, m, n, score[STUD][COURSE] = {0}, sum[STUD];
Enter the total number of students and courses:
2 3
Enter score:
90
95
97
82
73
69
Result:
90 95 97 282 94.0
0 0 82 82 27.3
As you note, the problem is your array accesses -- you use score[i][j] in main to fill the array and then *(score + i * n + j) in your Total and Print functions to try to access it, and these are different and incompatible. The easiest fix is probably just to fix the declarations of Total and Print to match the score you are using:
void Total(int score[][COURSE], int sum[], float aver[], int m, int n);
void Print(int score[][COURSE], int sum[], float aver[], int m, int n);
Then you can just use score[i][j] in them and everything should work. You would also pass score as just score instead of *score.
Alternately, change the declaration of score to score[STUD*COURSE] and use *(score + i * n + j) (or score[i*n + j]) in main to access it like you do in Total and Print.
OP is unclear why the code uses #defines to define values for rows and columns of the array score, then goes on to use scanf() to enter new values that may or may not conflict with the #defines, or even overflow the array memory. Either method works, but using both together confuse things. Pick one or the other.
Aside: If a dynamic sized array is necessary, then it can be created as a pointer, or pointers to allocated memory, or by use of a VLA
eg: A short example of using user input with dynamic memory allocation to create the array sized to the need of the moment:
Note: following method allows you to use plain array notation to assign values:
score[i][j] = someValue://easy to use and readable
//as opposed to
*(score + i*n + j) = someValue;// cumbersome to use and read
Example:
int student, course;//using descriptive variables
printf("Enter the total number of students and courses:\n");
scanf("%d %d",&student,&course);
int (*score)[course] = create_arr_2d (student, course);
if(score)
{ //use score
...
free(score);
}
Where create_arr_2d(...) is defined:
void * create_arr_2d (size_t x, size_t y)
{
int (*ptr_2)[x] = malloc( sizeof (int *[y]) ); //allocate a true 2D array
if(ptr_2)
{
memset(ptr_2, 0, sizeof **ptr_2);
}
return ptr_2;
}
(credit for method)
Addressing your code as is. First, the following creates variables, but does not initialize any of them:
int i, j, m, n, score[STUD][COURSE], sum[STUD];
float aver[STUD];
To eliminate some of the issues you may be seeing, initialize:
int i=0, j=0, m=0, n=0, score[STUD][COURSE]={{0}}, sum[STUD]={0};
float aver[STUD]={0};
In the function prototype in your given code:
Total(int *score, int sum[], float aver[], int m, int n)
int *score
suggests a pointer to a single dimensional array is being passed, but if it is being used to represent score[STUD][COURSE], then it should be passed as `score[m][n], with the prototype changed as:
Total(int m, int n, int score[m][n], int sum[m], float aver[m]);
Then called as:
Total(STUD, COURSE, score[STUD][COURSE], sum[STUD], aver[STUD]){...}
Note, this arrangement makes use of VLA type function arguemnts
Note also, an array such as: (shortened from your values for easier viewing)
int m = 5;
int n = 4
int array[m][n] = {{0}}
creates a single contiguous block of memory, conceivably looking like this in memory:
`|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|...`
0 5 10 15 20
Where all of the elements can be accessed in a for loop like this:
for(int i=0; i<m; i++
for(int j=0;j<n;j++)
*(array + i*n + j);
...
...
I'm working through the K&R C programming book, and I just completed exercise 1-13 where you print a histogram of the lengths of words that are input. My horizontal histogram is fine, but my vertical histogram has a '%' sign appearing at the end of it, and I can't figure out why that keeps happening. Here is the loop that I think is causing the issue:
for (i = 0; i < array_length; i++) {
printf("%-4d", i + 1);
}
If the array_length is 7, I will have a '%' sign after the 7th position like this:
|
| |
| |
| |
| |
| |
| | | | |
| | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
1 2 3 4 5 6 7 %
If I remove this loop, the vertical bars print fine, I just don't get the numbering below each of them.
What is going on here? As far as I can guess, the printf is running one extra time with garbage data in 'i', but I can't figure out why or how this is happening.
I'm compiling with gcc on Ubuntu, if that makes any difference.
Here is the complete code for your reference:
#include <stdio.h>
#define IN 1
#define OUT 0
#define ARRAY_SIZE 1000
int main() {
int c, current_word_length, state, i, j, current_word, largest, array_length, top;
int word_lengths[ARRAY_SIZE];
current_word_length = current_word = largest = 0;
state = OUT;
for (i = 0; i < ARRAY_SIZE; i++) {
word_lengths[i] = 0;
}
printf("Enter up to 1000 words and this program will calculate their length.\n");
printf("Please enter a newline, tab, or space before the last word entered, then EOF to print summary.\n\n");
while ((c = getchar()) != EOF) {
if (c == ' ' || c == '\t' || c == '\n') {
if (state == IN) {
word_lengths[current_word++] = current_word_length;
if (current_word_length > largest) {
largest = current_word_length;
}
current_word_length = 0;
state = OUT;
}
} else {
state = IN;
current_word_length++;
}
}
array_length = current_word;
printf("\nWord Lengths Histogram Horizontal:\n\n");
for (i = 0; i < array_length; i++) {
printf("%-4d: ", i + 1);
for (j = 0; j < word_lengths[i]; j++) {
printf("=");
}
printf("\n");
}
printf("\nWord Lengths Histogram Vertical:\n\n");
top = largest;
while (top > 0) {
for (i = 0; i < array_length; i++) {
if (word_lengths[i] >= top) {
printf("%-4c", '|');
} else {
printf("%-4c", ' ');
}
}
printf("\n");
top--;
}
for (i = 0; i < array_length; i++) {
printf("%-4d", i + 1);
}
return 0;
}
And here is what I expect to occur using this input string "Bacon ipsum dolor amet frankfurter landjaeger ham":
Enter up to 1000 words and this program will calculate their length.
Please enter a newline, tab, or space before the last word entered, then EOF to print summary.
Bacon ipsum dolor amet frankfurter landjaeger ham
Word Lengths Histogram Horizontal:
1 : =====
2 : =====
3 : =====
4 : ====
5 : ===========
6 : ==========
7 : ===
Word Lengths Histogram Vertical:
|
| |
| |
| |
| |
| |
| | | | |
| | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
1 2 3 4 5 6 7
OK, as pointed out by nos and chqrlie in the comments, I need to add a newline at the end of my program so that the shell prompt will appear on a newline AFTER the program has finished running.
Adding the putchar() call at the end of main() fixed my issue:
for (i = 0; i < array_length; i++) {
printf("%-4d", i + 1);
}
putchar('\n');
return 0;
} // end main()
I am trying to write a program which finds all anagrams (words that are remade by rearranging their letters) in the dictionary (/usr/share/dict/words file in Linux). The dictionary file contains a lot of words that ends with " 's " which I want to exclude from checking. Here is what I wrote to do that, but unfortunately the result file contains lines with just one letter "s" I have no idea where it comes from.
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define TRUE 1
#define FALSE 0
int wordContainsNonAlpha(char *word);
int main(int argc, const char *argv[]){
FILE *fp_read = fopen("/usr/share/dict/words", "r");
char *word = malloc(sizeof(word));
FILE *fp_write = fopen("words.txt","w");
while (fgets(word,sizeof(word), fp_read) != NULL){
if (wordContainsNonAlpha(word)){
fprintf(fp_write,"%s","\n");
}
else{
// fputs(word, stdout);
fprintf(fp_write,"%s",word);
}
}
fclose(fp_read);
fclose(fp_write);
return 0;
}
int wordContainsNonAlpha(char *word){
int currentLetter = 0;
int wordLenght = strlen(word);
int result = FALSE;
char ch;
while ( (currentLetter < wordLenght) && (result == FALSE) ){
ch = word[currentLetter];
if (ch == '\''){
// if (!isalpha(ch)){
result = TRUE;
break;
}
currentLetter++;
}
return result;
}
The result is:
$ sdiff words.txt /usr/share/dict/words | more
A A
| A's
| AA's
| AB's
| ABM's
| AC's
| ACTH's
| AI's
| AIDS's
| AM's
AOL AOL
| AOL's
| ASCII's
| ASL's
| ATM's
| ATP's
| AWOL's
| AZ's
| AZT's
<
Aachen Aachen
Aaliyah Aaliyah
Aaliyah | Aaliyah's
Aaron Aaron
Abbas Abbas
Abbasid Abbasid
Abbott Abbott
| Abbott's
s <
Abby Abby
| Abby's
Abdul Abdul
| Abdul's
<
Abe Abe
| Abe's
Abel Abel
........
If I try to use function isalpha the result is even worse, as it seems it is looking for a words with specific lenght and does not work correct at all:
sdiff words.txt /usr/share/dict/words | more
| A
| A's
| AA's
| AB's
| ABM's
| AC's
| ACTH's
| AI's
| AIDS's
| AM's
| AOL
| AOL's
| ASCII's
| ASL's
| ATM's
| ATP's
| AWOL's
| AZ's
| AZT's
| Aachen
<
Aaliyah Aaliyah
Aaliyah | Aaliyah's
| Aaron
| Abbas
Abbasid Abbasid
| Abbott
| Abbott's
| Abby
| Abby's
| Abdul
| Abdul's
| Abe
| Abe's
| Abel
| Abel's
<
<
Abelard Abelard
Abelson Abelson
Abelson | Abelson's
Aberdee | Aberdeen
Aberdee | Aberdeen's
Abernat | Abernathy
Abernat | Abernathy's
Abidjan <
Abidjan Abidjan
Could you please help!
Your issue comes from your calls to malloc():
char *word = malloc(sizeof(word));
// Here, you allocate sizeof(char*) bytes which is only the size of a pointer and not the size of a dictionary word
while (fgets(word,sizeof(word), fp_read) != NULL){
// In this case, fgets does not stop when you expect it
To solve this issue, you can simply use, for your allocations, a constant which is the length of the longest word in the dictionary or an arbitrary value (I tested quickly with 64)
Concerning your issue with isalpha(), it's because fgets() stores the '\n' in your word.
From man fgets:
If a newline is read, it is stored into the buffer
So, you can use:
if (ch != '\n' && !isalpha(ch)){
I am writing a program that allows a user to play the game connect four against the computer. I am having trouble printing out the correct dimensions for the board. I tried using nested for loops, but the output is a little off.
Here is a part of my code:
#include <stdio.h>
#define BOARD_SIZE_VERT 6
#define BOARD_SIZE_HORIZ 7
void display_board(int board[] [BOARD_SIZE_VERT]);
int main ()
{
int board[BOARD_SIZE_HORIZ][BOARD_SIZE_VERT] = {{0}};
display_board(board);
return 0;
}
void display_board(int board[] [BOARD_SIZE_VERT])
{
int i,j;
for (i=0; i<BOARD_SIZE_HORIZ; i++) {
printf ("+---+---+---+---+---+---+---+");
printf ("\n");
for (j=0; j<BOARD_SIZE_VERT; j++)
printf ("| ");
printf("\n");
}
}
This is my output:
+---+---+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+---+---+
| | | | | |
And this is what I want it to look like:
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
| | | | | | | |
+---+---+---+---+---+---+---+
void display_board(int board[] [BOARD_SIZE_VERT]){
int i,j;
for (i=0; i<BOARD_SIZE_VERT; i++) {
printf ("+");
for (j=0; j<BOARD_SIZE_HORIZ; j++)
printf("---+");
printf ("\n");
printf ("|");
for (j=0; j<BOARD_SIZE_HORIZ; j++)
printf(" |");
printf ("\n");
}
printf ("+");
for (j=0; j<BOARD_SIZE_HORIZ; j++)
printf("---+");
printf ("\n");
}
Two main problems: your loops are inverted, and you need some extra characters printed to to get the extra lines on the bottom and right. Try this:
void display_board(int board[] [BOARD_SIZE_HORIZ])
{
int row,col;
for (row=0; row<BOARD_SIZE_VERT; row++) {
printf ("+---+---+---+---+---+---+---+");
printf ("\n");
for (col=0; col<BOARD_SIZE_HORIZ; col++) {
printf ("| ");
}
printf("|\n");
}
printf ("+---+---+---+---+---+---+---+");
}
Here are the relevant changes:
I swapped the usage of the VERT/HORIZ constants in the loops. The outer loop controls the height of the board since you are printing one line at a time. The inner loop controls the number of columns in the board
Renamed i and j to the row and col so the code is more self-documenting
Added a pipe to the printf("\n"), because you need one more vertical separator line than the actual number of slots for each line
Added an extra printf("+---.... at the end, because you need one more horizontal separator than the actual number of rows
Also, I changed the array definition in the function prototype so that the first index is the row and the second is the column. If you choose to follow that, you would need to change other usages of the array in your code. For example:
int board[BOARD_SIZE_VERT][BOARD_SIZE_HORIZ] = {{0}};
Your code work very well. But you have eight "| " to display and You loops only BOARD_SIZE_VERT which worth 6. So you should increase it to 8 or add to it. Try this:
void display_board(int board[] [BOARD_SIZE_VERT]){
int i,j;
for (i=0; i<BOARD_SIZE_HORIZ - 1; i++) {
printf ("+---+---+---+---+---+---+---+");
printf ("\n");
for (j=0; j<BOARD_SIZE_VERT + 2; j++)
printf ("| ");
printf("\n");
}
printf ("+---+---+---+---+---+---+---+\n");
}