// ==================================================
// Automatic C-Source output for program:
//   IF >0 ( READ_IOF )( OR ( IF >0 ( IF >0 ( READ_IUF )( READ_IOF )( IF >0 ( 21 )( WHILE >0 ( TurnRight )( * ( WHILE >0 ( -18 )( OR ( -10 )( OR ( AND ( READ_IUB )( + ( TurnRight )( TurnRight )))( READ_IOF ))))( READ_IOB )))( READ_IUB )))( READ_IUF )( / ( IF >0 ( * ( TurnLeft )( READ_IOF ))( -7 )( - ( 14 )( * ( 1 )( - ( * ( 0 )( -8 ))( * ( 2 )( AND ( TurnLeft )( OR ( -21 )( IF >0 ( - ( / ( -8 )( TurnRight ))( WHILE >0 ( -17 )( 4 )))( -2 )( READ_IUB )))))))))( OR ( OR ( / ( -15 )( / ( 13 )( TurnLeft )))( - (..
//
// 124 nodes/instructions in program
// ==================================================
gpFunc()
{

	if (READ_IOF > 0)
	{
		if (READ_IUF > 0)
		{
			cond2 = READ_IOF ;
		}
		else
		{
			if (21 > 0)
			{
				While (TurnRight > 0)
				{
					While (-18 > 0)
					{
						res4 = TurnRight + TurnRight ;
						res5 = READ_IUB AND res4 ;
						res6 = res5 OR READ_IOF ;
						res7 = -10 OR res6 ;
						// re-eval argument branch ( -18 )
						// leaf - no re-evaluation necessary
					}
					res8 = res7  * READ_IOB ;
					// re-eval argument branch ( TurnRight )
					// leaf - no re-evaluation necessary
				}
				cond3 = res8  ;
			}
			else
			{
				cond3 = READ_IUB ;
			}
			cond2 = cond3 ;
		}
		if (cond2 > 0)
		{
			cond9 = READ_IUF ;
		}
		else
		{
			res10 = TurnLeft * READ_IOF ;
			if (res10 > 0)
			{
				cond11 = -7 ;
			}
			else
			{
				res12 = 0 * -8 ;
				res13 = -8 / TurnRight ;
				While (-17 > 0)
				{
					4 
					// re-eval argument branch ( -17 )
					// leaf - no re-evaluation necessary
				}
				res14 = res13 - 4  ;
				if (res14 > 0)
				{
					cond15 = -2 ;
				}
				else
				{
					cond15 = READ_IUB ;
				}
				res16 = -21 OR cond15 ;
				res17 = TurnLeft AND res16 ;
				res18 = 2 * res17 ;
				res19 = res12 - res18 ;
				res20 = 1 * res19 ;
				res21 = 14 - res20 ;
				cond11 = res21 ;
			}
			res22 = 13 / TurnLeft ;
			res23 = -15 / res22 ;
			res24 = READ_IUB - 14 ;
			While (READ_IOF > 0)
			{
				res25 = TurnRight AND READ_IUB ;
				res26 = res25 OR READ_IUF ;
				// re-eval argument branch ( READ_IOF )
				// leaf - no re-evaluation necessary
			}
			res27 = res24 + res26  ;
			res28 = READ_IUF + -14 ;
			res29 = res27 + res28 ;
			res30 = res29 / TurnRight ;
			res31 = res30 AND -12 ;
			res32 = -19 - READ_IOB ;
			res33 = READ_IUF * res32 ;
			if (res33 > 0)
			{
				cond34 = -17 ;
			}
			else
			{
				cond34 = READ_IOB ;
			}
			res35 = -21 + READ_IUF ;
			res36 = res35 * 17 ;
			res37 = cond34 - res36 ;
			res38 = res37 - 15 ;
			res39 = res31 * res38 ;
			res40 = READ_IUF * res39 ;
			res41 = 0 OR 1 ;
			res42 = res40 - res41 ;
			res43 = res23 OR res42 ;
			res44 = res43 OR TurnRight ;
			res45 = cond11 / res44 ;
			cond9 = res45 ;
		}
		res46 = cond9 OR READ_IUB ;
		cond1 = res46 ;
	}
	else
	{
		res47 = TurnLeft - 16 ;
		res48 = res47 - READ_IUF ;
		res49 = res48 * READ_IUB ;
		While (TurnLeft > 0)
		{
			READ_IOF 
			// re-eval argument branch ( TurnLeft )
			// leaf - no re-evaluation necessary
		}
		if (READ_IOF  > 0)
		{
			cond50 = READ_IOF ;
		}
		else
		{
			cond50 = -17 ;
		}
		if (cond50 > 0)
		{
			cond51 = -1 ;
		}
		else
		{
			cond51 = TurnLeft ;
		}
		res52 = res49 OR cond51 ;
		cond1 = res52 ;
	}

	return cond1 ;

}