void YukonSolver::undo_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#endif
int from, to;
card_t card;
from = m->from;
to = m->to;
/* Add to 'from' pile. */
if ( m->turn_index > 0 )
{
card_t card2 = *Wp[from];
if ( !DOWN( card2 ) )
card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 ) + ( 1 << 7 );
*Wp[from] = card2;
}
if (m->totype == O_Type) {
card = O[to] + Osuit[to];
O[to]--;
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
} else {
for ( int l = m->card_index; l >= 0; l-- )
{
card = W[to][Wlen[to]-l-1];
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
*Wp[to]--;
}
Wlen[to] -= m->card_index + 1;
hashpile(to);
}
if ( m->turn_index == 0 )
{
card_t card = *Wp[from];
if ( DOWN( card ) )
card = ( SUIT( card ) << 4 ) + RANK( card );
else
card += ( 1 << 7 );
*Wp[from] = card;
}
hashpile(from);
#if PRINT
print_layout();
#endif
}
void YukonSolver::make_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nmake move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#else
//print_layout();
#endif
int from, to;
card_t card = NONE;
from = m->from;
to = m->to;
for ( int l = m->card_index; l >= 0; l-- )
{
card = W[from][Wlen[from]-l-1];
Wp[from]--;
if ( m->totype != O_Type )
{
Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
}
}
Wlen[from] -= m->card_index + 1;
if ( m->turn_index == 0 )
{
if ( DOWN( card ) )
card = ( SUIT( card ) << 4 ) + RANK( card );
else
card += ( 1 << 7 );
W[to][Wlen[to]-m->card_index-1] = card;
} else if ( m->turn_index != -1 )
{
card_t card2 = *Wp[from];
if ( DOWN( card2 ) )
card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 );
*Wp[from] = card2;
}
hashpile(from);
/* Add to pile. */
if (m->totype == O_Type) {
O[to]++;
Q_ASSERT( m->card_index == 0 );
} else {
hashpile(to);
}
#if PRINT
print_layout();
#endif
}
void SimonSolver::undo_move(MOVE *m)
{
#if PRINT
//qDebug() << "\n\nundo_move\n";
if ( m->totype == O_Type )
fprintf( stderr, "move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#endif
int from, to;
card_t card;
from = m->from;
to = m->to;
if (m->totype == O_Type) {
for ( int j = PS_KING; j >= PS_ACE; --j )
{
Wp[from]++;
*Wp[from] = O[to] + j;
Wlen[from]++;
}
O[to] = -1;
hashpile( from );
#if PRINT
print_layout();
#endif
return;
}
/* Add to 'from' pile. */
if ( m->turn_index > 0 )
{
card_t card2 = *Wp[from];
if ( !DOWN( card2 ) )
card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 ) + ( 1 << 7 );
*Wp[from] = card2;
}
for ( int l = m->card_index; l >= 0; --l )
{
card = W[to][Wlen[to]-l-1];
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
Wp[to]--;
}
Wlen[to] -= m->card_index + 1;
hashpile(to);
hashpile(from);
#if PRINT
print_layout();
#endif
}
void SimonSolver::make_move(MOVE *m)
{
#if PRINT
//qDebug() << "\n\nmake_move\n";
if ( m->totype == O_Type )
fprintf( stderr, "move %d from %d out (at %d) Prio: %d\n\n", m->card_index, m->from, m->turn_index, m->pri );
else
fprintf( stderr, "move %d from %d to %d (%d) Prio: %d\n\n", m->card_index, m->from, m->to, m->turn_index, m->pri );
print_layout();
#else
//print_layout();
#endif
int from, to;
card_t card = NONE;
from = m->from;
to = m->to;
if (m->totype == O_Type) {
O[to] = SUIT( *Wp[from] );
Wlen[from] -= 13;
Wp[from] -= 13;
hashpile( from );
if ( Wlen[from] && DOWN( *Wp[from] ) )
{
*Wp[from] = ( SUIT( *Wp[from] ) << 4 ) + RANK( *Wp[from] );
}
#if PRINT
print_layout();
#endif
return;
}
for ( int l = m->card_index; l >= 0; --l )
{
card = W[from][Wlen[from]-l-1];
Wp[from]--;
if ( m->totype != O_Type )
{
Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
}
}
Wlen[from] -= m->card_index + 1;
hashpile(from);
hashpile(to);
#if PRINT
print_layout();
#endif
}
void IdiotSolver::make_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nmake move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#else
//print_layout();
#endif
int from, to;
card_t card = NONE;
from = m->from;
to = m->to;
if ( from == 4 )
{
Q_ASSERT( Wlen[from] >= 4 );
for ( int i = 0; i < 4; ++i )
{
Wp[i]++;
card = *Wp[from];
*Wp[i] = ( SUIT( card ) << 4 ) + RANK( card );
Wp[from]--;
Wlen[from]--;
Wlen[i]++;
hashpile( i );
}
hashpile( from );
} else {
card = *Wp[from];
Wp[from]--;
Wlen[from]--;
*Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
hashpile( to );
hashpile(from);
}
#if PRINT
print_layout();
#endif
}
void GolfSolver::make_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nmake move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#else
//print_layout();
#endif
int from = m->from;
int to = m->to;
Q_ASSERT( to == 7 );
Q_ASSERT( from != 7 );
// move to pile
if ( from == 8 && to == 7 )
{
card_t card = *Wp[8];
Wp[8]--;
Wlen[8]--;
card = ( SUIT( card ) << 4 ) + RANK( card );
Wp[7]++;
*Wp[7] = card;
Wlen[7]++;
hashpile( 7 );
hashpile( 8 );
#if PRINT
print_layout();
#endif
return;
}
card_t card = *Wp[from];
Wp[from]--;
Wlen[from]--;
Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
hashpile(from);
hashpile(to);
#if PRINT
print_layout();
#endif
}
void IdiotSolver::undo_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#endif
int from, to;
card_t card;
from = m->from;
to = m->to;
if ( from == 4 )
{
for ( int i = 3; i >= 0; --i )
{
card = *Wp[i];
Wp[i]--;
Wlen[i]--;
Wp[from]++;
*Wp[from] = ( SUIT( card ) << 4 ) + RANK( card ) + ( 1 << 7 );
Wlen[from]++;
hashpile( i );
}
hashpile( from );
} else {
card = *Wp[to];
Wp[to]--;
Wlen[to]--;
*Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
hashpile( to );
hashpile(from);
}
#if PRINT
print_layout();
#endif
}
void print_layouts(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(req_formats); ++i) {
print_layout(req_formats[i]);
printf("\n");
}
}
void ClockSolver::undo_move(MOVE *m)
{
#if PRINT2
if ( m->totype == O_Type )
fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#endif
int from, to;
card_t card;
from = m->from;
to = m->to;
if (m->totype == O_Type) {
card = W[8][to];
if ( RANK( card ) == PS_ACE )
W[8][to] = W[8][to] - PS_ACE + PS_KING;
else
W[8][to]--;
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
hashpile( 8 );
hashpile( from );
} else {
card = *Wp[to];
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
Wp[to]--;
Wlen[to]--;
hashpile(to);
hashpile( from );
}
#if PRINT2
print_layout();
#endif
}
void ClockSolver::make_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nmake move %d from %d out %d (at %d)\n\n", m->card_index, m->from, m->to, m->turn_index );
else
fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#else
//print_layout();
#endif
int from, to;
from = m->from;
to = m->to;
card_t card = *Wp[from];
Wlen[from]--;
Wp[from]--;
hashpile(from);
/* Add to pile. */
if (m->totype == O_Type) {
if ( RANK( W[8][to] ) == PS_KING )
W[8][to] = W[8][to] - PS_KING + PS_ACE;
else
W[8][to]++;
Q_ASSERT( m->card_index == 0 );
hashpile( 8 );
} else {
Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
hashpile( to );
}
#if PRINT
print_layout();
#endif
}
void GypsySolver::undo_move(MOVE *m)
{
#if PRINT
kDebug() << "\n\nundo_move\n";
if ( m->totype == O_Type )
fprintf( stderr, "move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#endif
int from, to;
//card_t card;
from = m->from;
to = m->to;
if ( m->from == deck )
{
for ( int i = 7; i >= 0; --i )
{
card_t card = *Wp[i];
Q_ASSERT( !DOWN( card ) );
card = ( SUIT( card ) << 4 ) + RANK( card ) + ( 1 << 7 );
++Wp[from];
--Wp[i];
*Wp[from] = card;
Wlen[from]++;
Wlen[i]--;
hashpile( i );
}
hashpile( from );
#if PRINT
print_layout();
#endif
return;
}
/* Add to 'from' pile. */
if ( m->turn_index > 0 )
{
card_t card2 = *Wp[from];
if ( !DOWN( card2 ) )
card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 ) + ( 1 << 7 );
*Wp[from] = card2;
}
card_t card = NONE;
if (m->totype == O_Type) {
card = *Wp[to];
if ( RANK( card ) == PS_ACE )
{
Wlen[to] = 0;
} else {
*Wp[to] = card - 1; // SUIT( card ) << 4 + RANK( card ) - 1;
}
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
hashpile( to );
} else {
for ( int l = m->card_index; l >= 0; --l )
{
card = W[to][Wlen[to]-l-1];
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
Wp[to]--;
}
Wlen[to] -= m->card_index + 1;
hashpile(to);
}
if ( m->turn_index == 0 )
{
card_t card = *Wp[from];
if ( DOWN( card ) )
card = ( SUIT( card ) << 4 ) + RANK( card );
else
card += ( 1 << 7 );
*Wp[from] = card;
}
hashpile(from);
#if PRINT
print_layout();
#endif
}
void KlondikeSolver::make_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nmake move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#else
//print_layout();
#endif
int from, to;
card_t card = NONE;
from = m->from;
to = m->to;
/* Remove from pile. */
if ( from == 7 && to == 8 )
{
while ( Wlen[7] )
{
card = W[7][Wlen[7]-1] + ( 1 << 7 );
Wlen[8]++;
W[8][Wlen[8]-1] = card;
Wlen[7]--;
}
Wp[7] = &W[7][0];
Wp[8] = &W[8][Wlen[8]-1];
hashpile( 7 );
hashpile( 8 );
#if PRINT
print_layout();
#endif
return;
}
// move to pile
if ( from == 8 && to == 7 )
{
for ( int i = 0; i < m->card_index; ++i )
{
if ( !Wlen[8] )
continue;
card = *Wp[8];
Wp[8]--;
Wlen[8]--;
card = ( SUIT( card ) << 4 ) + RANK( card );
Wp[7]++;
*Wp[7] = card;
Wlen[7]++;
}
hashpile( 7 );
hashpile( 8 );
#if PRINT
print_layout();
#endif
return;
}
for ( int l = m->card_index; l >= 0; --l )
{
card = W[from][Wlen[from]-l-1];
Wp[from]--;
if ( m->totype != O_Type )
{
Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
}
}
Wlen[from] -= m->card_index + 1;
if ( m->turn_index == 0 )
{
if ( DOWN( card ) )
card = ( SUIT( card ) << 4 ) + RANK( card );
else
card += ( 1 << 7 );
W[to][Wlen[to]-m->card_index-1] = card;
} else if ( m->turn_index != -1 )
{
card_t card2 = *Wp[from];
if ( DOWN( card2 ) )
card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 );
*Wp[from] = card2;
}
hashpile(from);
/* Add to pile. */
if (m->totype == O_Type) {
O[to]++;
Q_ASSERT( m->card_index == 0 );
} else {
hashpile(to);
}
#if PRINT
print_layout();
#endif
}
void KlondikeSolver::undo_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#endif
int from, to;
card_t card;
from = m->from;
to = m->to;
/* Remove from 'to' pile. */
if ( from == 7 && to == 8 )
{
while ( Wlen[8] )
{
card = W[8][Wlen[8]-1];
card = ( SUIT( card ) << 4 ) + RANK( card );
Wlen[7]++;
W[7][Wlen[7]-1] = card;
Wlen[8]--;
}
Wp[8] = &W[8][0];
Wp[7] = &W[7][Wlen[7]-1];
hashpile( 7 );
hashpile( 8 );
#if PRINT
print_layout();
#endif
return;
}
// move back to deck
if ( from == 8 && to == 7 )
{
for ( int i = 0; i < m->card_index; ++i )
{
card = *Wp[7];
Wp[7]--;
Wlen[7]--;
card = ( SUIT( card ) << 4 ) + RANK( card ) + ( 1 << 7 );
Wp[8]++;
*Wp[8] = card;
Wlen[8]++;
}
hashpile( 7 );
hashpile( 8 );
#if PRINT
print_layout();
#endif
return;
}
/* Add to 'from' pile. */
if ( m->turn_index > 0 )
{
card_t card2 = *Wp[from];
if ( !DOWN( card2 ) )
card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 ) + ( 1 << 7 );
*Wp[from] = card2;
}
if (m->totype == O_Type) {
card = O[to] + Osuit[to];
O[to]--;
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
} else {
for ( int l = m->card_index; l >= 0; --l )
{
card = W[to][Wlen[to]-l-1];
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
Wp[to]--;
}
Wlen[to] -= m->card_index + 1;
hashpile(to);
}
if ( m->turn_index == 0 )
{
card_t card = *Wp[from];
if ( DOWN( card ) )
card = ( SUIT( card ) << 4 ) + RANK( card );
else
card += ( 1 << 7 );
*Wp[from] = card;
}
hashpile(from);
#if PRINT
print_layout();
#endif
}
void GypsySolver::make_move(MOVE *m)
{
#if PRINT
kDebug() << "\n\nmake_move\n";
if ( m->totype == O_Type )
fprintf( stderr, "move %d from %d out (at %d) Prio: %d\n\n", m->card_index, m->from, m->turn_index, m->pri );
else
fprintf( stderr, "move %d from %d to %d (%d) Prio: %d\n\n", m->card_index, m->from, m->to, m->turn_index, m->pri );
print_layout();
#else
//print_layout();
#endif
int from, to;
//card_t card = NONE;
from = m->from;
to = m->to;
if ( m->from == deck )
{
for ( int i = 0; i < 8; ++i )
{
card_t card = *Wp[from];
card = ( SUIT( card ) << 4 ) + RANK( card );
++Wp[i];
*Wp[i] = card;
--Wp[from];
Wlen[i]++;
hashpile( i );
Wlen[from]--;
}
hashpile( from );
#if PRINT
print_layout();
#endif
return;
}
card_t card = NONE;
for ( int l = m->card_index; l >= 0; --l )
{
card = W[from][Wlen[from]-l-1];
Wp[from]--;
if ( m->totype != O_Type )
{
Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
}
}
Wlen[from] -= m->card_index + 1;
if ( m->turn_index == 0 )
{
if ( DOWN( card ) )
card = ( SUIT( card ) << 4 ) + RANK( card );
else
card += ( 1 << 7 );
W[to][Wlen[to]-m->card_index-1] = card;
} else if ( m->turn_index != -1 )
{
card_t card2 = *Wp[from];
if ( DOWN( card2 ) )
card2 = ( SUIT( card2 ) << 4 ) + RANK( card2 );
*Wp[from] = card2;
}
hashpile(from);
/* Add to pile. */
if (m->totype == O_Type) {
if ( Wlen[to] )
*Wp[to] = card;
else {
Wp[to]++;
Wlen[to]++;
*Wp[to] = card;
}
Q_ASSERT( m->card_index == 0 );
}
hashpile(to);
#if PRINT
print_layout();
#endif
}
// ------------------------------------------------------------------
// ciFieldLayout::print
void ciFieldLayout::print() {
tty->print("<ciLayout layout=");
print_layout();
tty->print(" address=0x%x>", (address)this);
}
void Mod3Solver::make_move(MOVE *m)
{
#if PRINT
if ( m->totype == O_Type )
fprintf( stderr, "\nmake move %d from %d out %d (at %d)\n\n", m->card_index, m->from, m->to, m->turn_index );
else
fprintf( stderr, "\nmake move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#else
//print_layout();
#endif
int from, to;
from = m->from;
to = m->to;
if ( from == deck )
{
int len = m->card_index;
if ( len > 8 )
len = 8;
for ( int i = 0; i < len; i++ )
{
card_t card = *Wp[deck];
Wlen[deck]--;
Wp[deck]--;
card = ( card & PS_SUIT ) + RANK( card );
Wp[24 + i]++;
Wlen[24 + i]++;
*Wp[24 + i] = card;
hashpile( 24 + i );
}
hashpile( deck );
#if PRINT
print_layout();
#endif
return;
}
card_t card = *Wp[from];
Wlen[from]--;
Wp[from]--;
hashpile( from );
/* Add to pile. */
Wp[to]++;
*Wp[to] = card;
Wlen[to]++;
hashpile( to );
if ( m->turn_index == 1 )
{
card_t card2 = *Wp[deck];
Wlen[deck]--;
Wp[deck]--;
hashpile(deck);
/* Add to pile. */
Wp[from]++;
*Wp[from] = RANK( card2 ) + ( SUIT( card2 ) << 4 );
Wlen[from]++;
}
hashpile(from);
#if PRINT
print_layout();
#endif
}
void Mod3Solver::undo_move(MOVE *m)
{
#if PRINT2
if ( m->totype == O_Type )
fprintf( stderr, "\nundo move %d from %d out (at %d)\n\n", m->card_index, m->from, m->turn_index );
else
fprintf( stderr, "\nundo move %d from %d to %d (%d)\n\n", m->card_index, m->from, m->to, m->turn_index );
print_layout();
#endif
int from, to;
card_t card;
from = m->from;
to = m->to;
if ( from == deck )
{
int len = m->card_index;
if ( len > 8 )
len = 8;
for ( int i = len; i >= 0; i-- )
{
card_t card = *Wp[24+i];
Wlen[deck]++;
Wp[deck]++;
*Wp[deck] = ( 1 << 7 ) + card;
Wp[24 + i]--;
Wlen[24 + i]--;
hashpile( 24 + i );
}
hashpile( deck );
#if PRINT2
print_layout();
#endif
return;
}
if ( m->turn_index == 1)
{
card_t card = *Wp[from];
Wp[deck]++;
Wlen[deck]++;
*Wp[deck] = ( 1 << 7 ) + card;
Wlen[from]--;
Wp[from]--;
hashpile(deck);
}
card = *Wp[to];
Wp[from]++;
*Wp[from] = card;
Wlen[from]++;
Wp[to]--;
Wlen[to]--;
hashpile(to);
hashpile( from );
#if PRINT2
print_layout();
#endif
}
int main(){
char a;int check=0;
while(1){
print_layout(0);
a=getche();
switch((int)a-48){
case 1:
print_layout(1);
break;
case 2:
if(print_layout(2)){
system("cls");
gotoxy(0,1);
printf("================================================================================");
printf("\t\t\t Student Enrollment System");
printf("\n________________________________________________________________________________");
gotoxy(30,8);
printf("1. Add Student");
gotoxy(30,10);
printf("2. Remove Student");
gotoxy(30,12);
printf("3. Add Admin");
gotoxy(30,14);
printf("4. Remove Admin");
gotoxy(30,16);
printf("5. View Pending Approval");
gotoxy(30,18);
printf("6. View Checked Approval");
gotoxy(30,20);
printf("7. View List Of Student");
gotoxy(30,22);
printf("8. View Log");
a=getche();
switch((int)a-48){
case 1:ak
system("cls");
gotoxy(0,1);
printf("================================================================================");
printf("\t\t\t Student Enrollment System");
printf("\n________________________________________________________________________________");
gotoxy(30,8);
printf("Enter Year");
gotoxy(30,10);
scanf("%d",&st.year);
system("cls");
print_layout(4);
gotoxy(30,8);
printf("Select Course");
gotoxy(30,10);
printf("1. Computer");
gotoxy(30,12);
printf("2. Electrical");
gotoxy(30,14);
printf("3. Mechnical");
gotoxy(30,16);
printf("4. Electronics");
gotoxy(30,18);
printf("5. Petrochemical");
gotoxy(30,20);
printf("6. Chemical");
a=getche();
st.course=course_code[a-49];
system("cls");
print_layout(4);
gotoxy(30,8);
printf("Enter Name Of Student");
gotoxy(30,10);
scanf("%s",st.name);
FP=fopen("year_index.DAT","wb+");
if(FP==NULL)
printf("f**k");
//rewind(fp);
while(fread(&yr,sizeof(yr),1,FP)){
printf("found");
if(st.year==2012){
yr.count++;
check=1;
printf("found");
}
}
if(check==0){
yr.count=1;
yr.year=st.year;
fwrite(&yr,sizeof(yr),1,fp);
printf("check");
}
fclose(fp);
}
}
}
break;
}
return 0;
}
