text:
#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "../Game_local.h"

const idEventDef EV_Thread_Execute( "<execute>", NULL );
const idEventDef EV_Thread_SetCallback( "<script_setcallback>", NULL );

// script callable events
const idEventDef EV_Thread_TerminateThread( "terminate", "d" );
const idEventDef EV_Thread_Pause( "pause", NULL );
const idEventDef EV_Thread_Wait( "wait", "f" );
const idEventDef EV_Thread_WaitFrame( "waitFrame" );
const idEventDef EV_Thread_WaitFor( "waitFor", "e" );
const idEventDef EV_Thread_WaitForThread( "waitForThread", "d" );
const idEventDef EV_Thread_Print( "print", "s" );
const idEventDef EV_Thread_PrintLn( "println", "s" );
const idEventDef EV_Thread_Say( "say", "s" );
const idEventDef EV_Thread_Assert( "assert", "f" );
const idEventDef EV_Thread_Trigger( "trigger", "e" );
const idEventDef EV_Thread_SetCvar( "setcvar", "ss" );
const idEventDef EV_Thread_GetCvar( "getcvar", "s", 's' );
const idEventDef EV_Thread_Random( "random", "f", 'f' );
const idEventDef EV_Thread_GetTime( "getTime", NULL, 'f' );
const idEventDef EV_Thread_KillThread( "killthread", "s" );
const idEventDef EV_Thread_SetThreadName( "threadname", "s" );
const idEventDef EV_Thread_GetEntity( "getEntity", "s", 'e' );
const idEventDef EV_Thread_Spawn( "spawn", "s", 'e' );
const idEventDef EV_Thread_CopySpawnArgs( "copySpawnArgs", "e" );
const idEventDef EV_Thread_SetSpawnArg( "setSpawnArg", "ss" );
const idEventDef EV_Thread_SpawnString( "SpawnString", "ss", 's' );
const idEventDef EV_Thread_SpawnFloat( "SpawnFloat", "sf", 'f' );
const idEventDef EV_Thread_SpawnVector( "SpawnVector", "sv", 'v' );
const idEventDef EV_Thread_ClearPersistantArgs( "clearPersistantArgs" );
const idEventDef EV_Thread_SetPersistantArg( "setPersistantArg", "ss" );
const idEventDef EV_Thread_GetPersistantString( "getPersistantString", "s", 's' );
const idEventDef EV_Thread_GetPersistantFloat( "getPersistantFloat", "s", 'f' );
const idEventDef EV_Thread_GetPersistantVector( "getPersistantVector", "s", 'v' );
const idEventDef EV_Thread_AngToForward( "angToForward", "v", 'v' );
const idEventDef EV_Thread_AngToRight( "angToRight", "v", 'v' );
const idEventDef EV_Thread_AngToUp( "angToUp", "v", 'v' );
const idEventDef EV_Thread_Sine( "sin", "f", 'f' );
const idEventDef EV_Thread_Cosine( "cos", "f", 'f' );
const idEventDef EV_Thread_SquareRoot( "sqrt", "f", 'f' );
const idEventDef EV_Thread_Normalize( "vecNormalize", "v", 'v' );
const idEventDef EV_Thread_VecLength( "vecLength", "v", 'f' );
const idEventDef EV_Thread_VecDotProduct( "DotProduct", "vv", 'f' );
const idEventDef EV_Thread_VecCrossProduct( "CrossProduct", "vv", 'v' );
const idEventDef EV_Thread_VecToAngles( "VecToAngles", "v", 'v' );
const idEventDef EV_Thread_OnSignal( "onSignal", "des" );
const idEventDef EV_Thread_ClearSignal( "clearSignalThread", "de" );
const idEventDef EV_Thread_SetCamera( "setCamera", "e" );
const idEventDef EV_Thread_FirstPerson( "firstPerson", NULL );
const idEventDef EV_Thread_Trace( "trace", "vvvvde", 'f' );
const idEventDef EV_Thread_TracePoint( "tracePoint", "vvde", 'f' );
const idEventDef EV_Thread_GetTraceFraction( "getTraceFraction", NULL, 'f' );
const idEventDef EV_Thread_GetTraceEndPos( "getTraceEndPos", NULL, 'v' );
const idEventDef EV_Thread_GetTraceNormal( "getTraceNormal", NULL, 'v' );
const idEventDef EV_Thread_GetTraceEntity( "getTraceEntity", NULL, 'e' );
const idEventDef EV_Thread_GetTraceJoint( "getTraceJoint", NULL, 's' );
const idEventDef EV_Thread_GetTraceBody( "getTraceBody", NULL, 's' );
const idEventDef EV_Thread_FadeIn( "fadeIn", "vf" );
const idEventDef EV_Thread_FadeOut( "fadeOut", "vf" );
const idEventDef EV_Thread_FadeTo( "fadeTo", "vff" );
const idEventDef EV_Thread_StartMusic( "music", "s" );
const idEventDef EV_Thread_Error( "error", "s" );
const idEventDef EV_Thread_Warning( "warning", "s" );
const idEventDef EV_Thread_StrLen( "strLength", "s", 'd' );
const idEventDef EV_Thread_StrLeft( "strLeft", "sd", 's' );
const idEventDef EV_Thread_StrRight( "strRight", "sd", 's' );
const idEventDef EV_Thread_StrSkip( "strSkip", "sd", 's' );
const idEventDef EV_Thread_StrMid( "strMid", "sdd", 's' );
const idEventDef EV_Thread_StrToFloat( "strToFloat", "s", 'f' );
const idEventDef EV_Thread_RadiusDamage( "radiusDamage", "vEEEsf" );
const idEventDef EV_Thread_IsClient( "isClient", NULL, 'f' );
const idEventDef EV_Thread_IsMultiplayer( "isMultiplayer", NULL, 'f' );
const idEventDef EV_Thread_GetFrameTime( "getFrameTime", NULL, 'f' );
const idEventDef EV_Thread_GetTicsPerSecond( "getTicsPerSecond", NULL, 'f' );
const idEventDef EV_Thread_DebugLine( "debugLine", "vvvf" );
const idEventDef EV_Thread_DebugArrow( "debugArrow", "vvvdf" );
const idEventDef EV_Thread_DebugCircle( "debugCircle", "vvvfdf" );
const idEventDef EV_Thread_DebugBounds( "debugBounds", "vvvf" );
const idEventDef EV_Thread_DrawText( "drawText", "svfvdf" );
const idEventDef EV_Thread_InfluenceActive( "influenceActive", NULL, 'd' );

CLASS_DECLARATION( idClass, idThread )
	EVENT( EV_Thread_Execute,				idThread::Event_Execute )
	EVENT( EV_Thread_TerminateThread,		idThread::Event_TerminateThread )
	EVENT( EV_Thread_Pause,					idThread::Event_Pause )
	EVENT( EV_Thread_Wait,					idThread::Event_Wait )
	EVENT( EV_Thread_WaitFrame,				idThread::Event_WaitFrame )
	EVENT( EV_Thread_WaitFor,				idThread::Event_WaitFor )
	EVENT( EV_Thread_WaitForThread,			idThread::Event_WaitForThread )
	EVENT( EV_Thread_Print,					idThread::Event_Print )
	EVENT( EV_Thread_PrintLn,				idThread::Event_PrintLn )
	EVENT( EV_Thread_Say,					idThread::Event_Say )
	EVENT( EV_Thread_Assert,				idThread::Event_Assert )
	EVENT( EV_Thread_Trigger,				idThread::Event_Trigger )
	EVENT( EV_Thread_SetCvar,				idThread::Event_SetCvar )
	EVENT( EV_Thread_GetCvar,				idThread::Event_GetCvar )
	EVENT( EV_Thread_Random,				idThread::Event_Random )
	EVENT( EV_Thread_GetTime,				idThread::Event_GetTime )
	EVENT( EV_Thread_KillThread,			idThread::Event_KillThread )
	EVENT( EV_Thread_SetThreadName,			idThread::Event_SetThreadName )
	EVENT( EV_Thread_GetEntity,				idThread::Event_GetEntity )
	EVENT( EV_Thread_Spawn,					idThread::Event_Spawn )
	EVENT( EV_Thread_CopySpawnArgs,			idThread::Event_CopySpawnArgs )
	EVENT( EV_Thread_SetSpawnArg,			idThread::Event_SetSpawnArg )
	EVENT( EV_Thread_SpawnString,			idThread::Event_SpawnString )
	EVENT( EV_Thread_SpawnFloat,			idThread::Event_SpawnFloat )
	EVENT( EV_Thread_SpawnVector,			idThread::Event_SpawnVector )
	EVENT( EV_Thread_ClearPersistantArgs,	idThread::Event_ClearPersistantArgs )
	EVENT( EV_Thread_SetPersistantArg,		idThread::Event_SetPersistantArg )
	EVENT( EV_Thread_GetPersistantString,	idThread::Event_GetPersistantString )
	EVENT( EV_Thread_GetPersistantFloat,	idThread::Event_GetPersistantFloat )
	EVENT( EV_Thread_GetPersistantVector,	idThread::Event_GetPersistantVector )
	EVENT( EV_Thread_AngToForward,			idThread::Event_AngToForward )
	EVENT( EV_Thread_AngToRight,			idThread::Event_AngToRight )
	EVENT( EV_Thread_AngToUp,				idThread::Event_AngToUp )
	EVENT( EV_Thread_Sine,					idThread::Event_GetSine )
	EVENT( EV_Thread_Cosine,				idThread::Event_GetCosine )
	EVENT( EV_Thread_SquareRoot,			idThread::Event_GetSquareRoot )
	EVENT( EV_Thread_Normalize,				idThread::Event_VecNormalize )
	EVENT( EV_Thread_VecLength,				idThread::Event_VecLength )
	EVENT( EV_Thread_VecDotProduct,			idThread::Event_VecDotProduct )
	EVENT( EV_Thread_VecCrossProduct,		idThread::Event_VecCrossProduct )
	EVENT( EV_Thread_VecToAngles,			idThread::Event_VecToAngles )
	EVENT( EV_Thread_OnSignal,				idThread::Event_OnSignal )
	EVENT( EV_Thread_ClearSignal,			idThread::Event_ClearSignalThread )
	EVENT( EV_Thread_SetCamera,				idThread::Event_SetCamera )
	EVENT( EV_Thread_FirstPerson,			idThread::Event_FirstPerson )
	EVENT( EV_Thread_Trace,					idThread::Event_Trace )
	EVENT( EV_Thread_TracePoint,			idThread::Event_TracePoint )
	EVENT( EV_Thread_GetTraceFraction,		idThread::Event_GetTraceFraction )
	EVENT( EV_Thread_GetTraceEndPos,		idThread::Event_GetTraceEndPos )
	EVENT( EV_Thread_GetTraceNormal,		idThread::Event_GetTraceNormal )
	EVENT( EV_Thread_GetTraceEntity,		idThread::Event_GetTraceEntity )
	EVENT( EV_Thread_GetTraceJoint,			idThread::Event_GetTraceJoint )
	EVENT( EV_Thread_GetTraceBody,			idThread::Event_GetTraceBody )
	EVENT( EV_Thread_FadeIn,				idThread::Event_FadeIn )
	EVENT( EV_Thread_FadeOut,				idThread::Event_FadeOut )
	EVENT( EV_Thread_FadeTo,				idThread::Event_FadeTo )
	EVENT( EV_SetShaderParm,				idThread::Event_SetShaderParm )
	EVENT( EV_Thread_StartMusic,			idThread::Event_StartMusic )
	EVENT( EV_Thread_Warning,				idThread::Event_Warning )
	EVENT( EV_Thread_Error,					idThread::Event_Error )
	EVENT( EV_Thread_StrLen,				idThread::Event_StrLen )
	EVENT( EV_Thread_StrLeft,				idThread::Event_StrLeft )
	EVENT( EV_Thread_StrRight,				idThread::Event_StrRight )
	EVENT( EV_Thread_StrSkip,				idThread::Event_StrSkip )
	EVENT( EV_Thread_StrMid,				idThread::Event_StrMid )
	EVENT( EV_Thread_StrToFloat,			idThread::Event_StrToFloat )
	EVENT( EV_Thread_RadiusDamage,			idThread::Event_RadiusDamage )
	EVENT( EV_Thread_IsClient,				idThread::Event_IsClient )
	EVENT( EV_Thread_IsMultiplayer,			idThread::Event_IsMultiplayer )
	EVENT( EV_Thread_GetFrameTime,			idThread::Event_GetFrameTime )
	EVENT( EV_Thread_GetTicsPerSecond,		idThread::Event_GetTicsPerSecond )
	EVENT( EV_CacheSoundShader,				idThread::Event_CacheSoundShader )
	EVENT( EV_Thread_DebugLine,				idThread::Event_DebugLine )
	EVENT( EV_Thread_DebugArrow,			idThread::Event_DebugArrow )
	EVENT( EV_Thread_DebugCircle,			idThread::Event_DebugCircle )
	EVENT( EV_Thread_DebugBounds,			idThread::Event_DebugBounds )
	EVENT( EV_Thread_DrawText,				idThread::Event_DrawText )
	EVENT( EV_Thread_InfluenceActive,		idThread::Event_InfluenceActive )
END_CLASS

idThread			*idThread::currentThread = NULL;
int					idThread::threadIndex = 0;
idList<idThread *>	idThread::threadList;
trace_t				idThread::trace;

/*
================
idThread::CurrentThread
================
*/
idThread *idThread::CurrentThread( void ) {
	return currentThread;
}

/*
================
idThread::CurrentThreadNum
================
*/
int idThread::CurrentThreadNum( void ) {
	if ( currentThread ) {
		return currentThread->GetThreadNum();
	} else {
		return 0;
	}
}

/*
================
idThread::BeginMultiFrameEvent
================
*/
bool idThread::BeginMultiFrameEvent( idEntity *ent, const idEventDef *event ) {
	if ( !currentThread ) {
		gameLocal.Error( "idThread::BeginMultiFrameEvent called without a current thread" );
	}
	return currentThread->interpreter.BeginMultiFrameEvent( ent, event );
}

/*
================
idThread::EndMultiFrameEvent
================
*/
void idThread::EndMultiFrameEvent( idEntity *ent, const idEventDef *event ) {
	if ( !currentThread ) {
		gameLocal.Error( "idThread::EndMultiFrameEvent called without a current thread" );
	}
	currentThread->interpreter.EndMultiFrameEvent( ent, event );
}

/*
================
idThread::idThread
================
*/
idThread::idThread() {
	Init();
	SetThreadName( va( "thread_%d", threadIndex ) );
	if ( g_debugScript.GetBool() ) {
		gameLocal.Printf( "%d: create thread (%d) '%s'\n", gameLocal.time, threadNum, threadName.c_str() );
	}
}

/*
================
idThread::idThread
================
*/
idThread::idThread( idEntity *self, const function_t *func ) {
	assert( self );

	Init();
	SetThreadName( self->name );
	interpreter.EnterObjectFunction( self, func, false );
	if ( g_debugScript.GetBool() ) {
		gameLocal.Printf( "%d: create thread (%d) '%s'\n", gameLocal.time, threadNum, threadName.c_str() );
	}
}

/*
================
idThread::idThread
================
*/
idThread::idThread( const function_t *func ) {
	assert( func );

	Init();
	SetThreadName( func->Name() );
	interpreter.EnterFunction( func, false );
	if ( g_debugScript.GetBool() ) {
		gameLocal.Printf( "%d: create thread (%d) '%s'\n", gameLocal.time, threadNum, threadName.c_str() );
	}
}

/*
================
idThread::idThread
================
*/
idThread::idThread( idInterpreter *source, const function_t *func, int args ) {
	Init();
	interpreter.ThreadCall( source, func, args );
	if ( g_debugScript.GetBool() ) {
		gameLocal.Printf( "%d: create thread (%d) '%s'\n", gameLocal.time, threadNum, threadName.c_str() );
	}
}

/*
================
idThread::idThread
================
*/
idThread::idThread( idInterpreter *source, idEntity *self, const function_t *func, int args ) {
	assert( self );

	Init();
	SetThreadName( self->name );
	interpreter.ThreadCall( source, func, args );
	if ( g_debugScript.GetBool() ) {
		gameLocal.Printf( "%d: create thread (%d) '%s'\n", gameLocal.time, threadNum, threadName.c_str() );
	}
}

/*
================
idThread::~idThread
================
*/
idThread::~idThread() {
	idThread	*thread;
	int			i;
	int			n;

	if ( g_debugScript.GetBool() ) {
		gameLocal.Printf( "%d: end thread (%d) '%s'\n", gameLocal.time, threadNum, threadName.c_str() );
	}
	threadList.Remove( this );
	n = threadList.Num();
	for( i = 0; i < n; i++ ) {
		thread = threadList[ i ];
		if ( thread->WaitingOnThread() == this ) {
			thread->ThreadCallback( this );
		}
	}

	if ( currentThread == this ) {
		currentThread = NULL;
	}
}

/*
================
idThread::ManualDelete
================
*/
void idThread::ManualDelete( void ) {
	interpreter.terminateOnExit = false;
}

/*
================
idThread::Save
================
*/
void idThread::Save( idSaveGame *savefile ) const {

	// We will check on restore that threadNum is still the same,
	//  threads should have been restored in the same order.
	savefile->WriteInt( threadNum );

	savefile->WriteObject( waitingForThread );
	savefile->WriteInt( waitingFor );
	savefile->WriteInt( waitingUntil );

	interpreter.Save( savefile );

	savefile->WriteDict( &spawnArgs );
	savefile->WriteString( threadName );

	savefile->WriteInt( lastExecuteTime );
	savefile->WriteInt( creationTime );

	savefile->WriteBool( manualControl );
}

/*
================
idThread::Restore
================
*/
void idThread::Restore( idRestoreGame *savefile ) {
	savefile->ReadInt( threadNum );

	savefile->ReadObject( reinterpret_cast<idClass *&>( waitingForThread ) );
	savefile->ReadInt( waitingFor );
	savefile->ReadInt( waitingUntil );

	interpreter.Restore( savefile );

	savefile->ReadDict( &spawnArgs );
	savefile->ReadString( threadName );

	savefile->ReadInt( lastExecuteTime );
	savefile->ReadInt( creationTime );

	savefile->ReadBool( manualControl );
}

/*
================
idThread::Init
================
*/
void idThread::Init( void ) {
	// create a unique threadNum
	do {
		threadIndex++;
		if ( threadIndex == 0 ) {
			threadIndex = 1;
		}
	} while( GetThread( threadIndex ) );

	threadNum = threadIndex;
	threadList.Append( this );

	creationTime = gameLocal.time;
	lastExecuteTime = 0;
	manualControl = false;

	ClearWaitFor();

	interpreter.SetThread( this );
}

/*
================
idThread::GetThread
================
*/
idThread *idThread::GetThread( int num ) {
	int			i;
	int			n;
	idThread	*thread;

	n = threadList.Num();
	for( i = 0; i < n; i++ ) {
		thread = threadList[ i ];
		if ( thread->GetThreadNum() == num ) {
			return thread;
		}
	}

	return NULL;
}

/*
================
idThread::DisplayInfo
================
*/
void idThread::DisplayInfo( void ) {
	gameLocal.Printf(
		"%12i: '%s'\n"
		"        File: %s(%d)\n"
		"     Created: %d (%d ms ago)\n"
		"      Status: ",
		threadNum, threadName.c_str(),
		interpreter.CurrentFile(), interpreter.CurrentLine(),
		creationTime, gameLocal.time - creationTime );

	if ( interpreter.threadDying ) {
		gameLocal.Printf( "Dying\n" );
	} else if ( interpreter.doneProcessing ) {
		gameLocal.Printf(
			"Paused since %d (%d ms)\n"
			"      Reason: ",  lastExecuteTime, gameLocal.time - lastExecuteTime );
		if ( waitingForThread ) {
			gameLocal.Printf( "Waiting for thread #%3i '%s'\n", waitingForThread->GetThreadNum(), waitingForThread->GetThreadName() );
		} else if ( ( waitingFor != ENTITYNUM_NONE ) && ( gameLocal.entities[ waitingFor ] ) ) {
			gameLocal.Printf( "Waiting for entity #%3i '%s'\n", waitingFor, gameLocal.entities[ waitingFor ]->name.c_str() );
		} else if ( waitingUntil ) {
			gameLocal.Printf( "Waiting until %d (%d ms total wait time)\n", waitingUntil, waitingUntil - lastExecuteTime );
		} else {
			gameLocal.Printf( "None\n" );
		}
	} else {
		gameLocal.Printf( "Processing\n" );
	}

	interpreter.DisplayInfo();

	gameLocal.Printf( "\n" );
}

/*
================
idThread::ListThreads_f
================
*/
void idThread::ListThreads_f( const idCmdArgs &args ) {
	int	i;
	int	n;

	n = threadList.Num();
	for( i = 0; i < n; i++ ) {
		//threadList[ i ]->DisplayInfo();
		gameLocal.Printf( "%3i: %-20s : %s(%d)\n", threadList[ i ]->threadNum, threadList[ i ]->threadName.c_str(), threadList[ i ]->interpreter.CurrentFile(), threadList[ i ]->interpreter.CurrentLine() );
	}
	gameLocal.Printf( "%d active threads\n\n", n );
}

/*
================
idThread::Restart
================
*/
void idThread::Restart( void ) {
	int	i;
	int	n;

	// reset the threadIndex
	threadIndex = 0;

	currentThread = NULL;
	n = threadList.Num();
	for( i = n - 1; i >= 0; i-- ) {
		delete threadList[ i ];
	}
	threadList.Clear();

	memset( &trace, 0, sizeof( trace ) );
	trace.c.entityNum = ENTITYNUM_NONE;
}

/*
================
idThread::DelayedStart
================
*/
void idThread::DelayedStart( int delay ) {
	CancelEvents( &EV_Thread_Execute );
	if ( gameLocal.time <= 0 ) {
		delay++;
	}
	PostEventMS( &EV_Thread_Execute, delay );
}

/*
================
idThread::Start
================
*/
bool idThread::Start( void ) {
	bool result;

	CancelEvents( &EV_Thread_Execute );
	result = Execute();

	return result;
}

/*
================
idThread::SetThreadName
================
*/
void idThread::SetThreadName( const char *name ) {
	threadName = name;
}

/*
================
idThread::ObjectMoveDone
================
*/
void idThread::ObjectMoveDone( int threadnum, idEntity *obj ) {
	idThread *thread;

	if ( !threadnum ) {
		return;
	}

	thread = GetThread( threadnum );
	if ( thread ) {
		thread->ObjectMoveDone( obj );
	}
}

/*
================
idThread::End
================
*/
void idThread::End( void ) {
	// Tell thread to die.  It will exit on its own.
	Pause();
	interpreter.threadDying	= true;
}

/*
================
idThread::KillThread
================
*/
void idThread::KillThread( const char *name ) {
	int			i;
	int			num;
	int			len;
	const char	*ptr;
	idThread	*thread;

	// see if the name uses a wild card
	ptr = strchr( name, '*' );
	if ( ptr ) {
		len = ptr - name;
	} else {
		len = strlen( name );
	}

	// kill only those threads whose name matches name
	num = threadList.Num();
	for( i = 0; i < num; i++ ) {
		thread = threadList[ i ];
		if ( !idStr::Cmpn( thread->GetThreadName(), name, len ) ) {
			thread->End();
		}
	}
}

/*
================
idThread::KillThread
================
*/
void idThread::KillThread( int num ) {
	idThread *thread;

	thread = GetThread( num );
	if ( thread ) {
		// Tell thread to die.  It will delete itself on it's own.
		thread->End();
	}
}

/*
================
idThread::Execute
================
*/
bool idThread::Execute( void ) {
	idThread	*oldThread;
	bool		done;

	if ( manualControl && ( waitingUntil > gameLocal.time ) ) {
		return false;
	}

	oldThread = currentThread;
	currentThread = this;

	lastExecuteTime = gameLocal.time;
	ClearWaitFor();
	done = interpreter.Execute();
	if ( done ) {
		End();
		if ( interpreter.terminateOnExit ) {
			PostEventMS( &EV_Remove, 0 );
		}
	} else if ( !manualControl ) {
		if ( waitingUntil > lastExecuteTime ) {
			PostEventMS( &EV_Thread_Execute, waitingUntil - lastExecuteTime );
		} else if ( interpreter.MultiFrameEventInProgress() ) {
			PostEventMS( &EV_Thread_Execute, gameLocal.msec );
		}
	}

	currentThread = oldThread;

	return done;
}

/*
================
idThread::IsWaiting

Checks if thread is still waiting for some event to occur.
================
*/
bool idThread::IsWaiting( void ) {
	if ( waitingForThread || ( waitingFor != ENTITYNUM_NONE ) ) {
		return true;
	}

	if ( waitingUntil && ( waitingUntil > gameLocal.time ) ) {
		return true;
	}

	return false;
}

/*
================
idThread::CallFunction

NOTE: If this is called from within a event called by this thread, the function arguments will be invalid after calling this function.
================
*/
void idThread::CallFunction( const function_t *func, bool clearStack ) {
	ClearWaitFor();
	interpreter.EnterFunction( func, clearStack );
}

/*
================
idThread::CallFunction

NOTE: If this is called from within a event called by this thread, the function arguments will be invalid after calling this function.
================
*/
void idThread::CallFunction( idEntity *self, const function_t *func, bool clearStack ) {
	assert( self );
	ClearWaitFor();
	interpreter.EnterObjectFunction( self, func, clearStack );
}

/*
================
idThread::ClearWaitFor
================
*/
void idThread::ClearWaitFor( void ) {
	waitingFor			= ENTITYNUM_NONE;
	waitingForThread	= NULL;
	waitingUntil		= 0;
}

/*
================
idThread::IsWaitingFor
================
*/
bool idThread::IsWaitingFor( idEntity *obj ) {
	assert( obj );
	return waitingFor == obj->entityNumber;
}

/*
================
idThread::ObjectMoveDone
================
*/
void idThread::ObjectMoveDone( idEntity *obj ) {
	assert( obj );

	if ( IsWaitingFor( obj ) ) {
		ClearWaitFor();
		DelayedStart( 0 );
	}
}

/*
================
idThread::ThreadCallback
================
*/
void idThread::ThreadCallback( idThread *thread ) {
	if ( interpreter.threadDying ) {
		return;
	}

	if ( thread == waitingForThread ) {
		ClearWaitFor();
		DelayedStart( 0 );
	}
}

/*
================
idThread::Event_SetThreadName
================
*/
void idThread::Event_SetThreadName( const char *name ) {
	SetThreadName( name );
}

/*
================
idThread::Error
================
*/
void idThread::Error( const char *fmt, ... ) const {
	va_list	argptr;
	char	text[ 1024 ];

	va_start( argptr, fmt );
	vsprintf( text, fmt, argptr );
	va_end( argptr );

	interpreter.Error( text );
}

/*
================
idThread::Warning
================
*/
void idThread::Warning( const char *fmt, ... ) const {
	va_list	argptr;
	char	text[ 1024 ];

	va_start( argptr, fmt );
	vsprintf( text, fmt, argptr );
	va_end( argptr );

	interpreter.Warning( text );
}

/*
================
idThread::ReturnString
================
*/
void idThread::ReturnString( const char *text ) {
	gameLocal.program.ReturnString( text );
}

/*
================
idThread::ReturnFloat
================
*/
void idThread::ReturnFloat( float value ) {
	gameLocal.program.ReturnFloat( value );
}

/*
================
idThread::ReturnInt
================
*/
void idThread::ReturnInt( int value ) {
	// true integers aren't supported in the compiler,
	// so int values are stored as floats
	gameLocal.program.ReturnFloat( value );
}

/*
================
idThread::ReturnVector
================
*/
void idThread::ReturnVector( idVec3 const &vec ) {
	gameLocal.program.ReturnVector( vec );
}

/*
================
idThread::ReturnEntity
================
*/
void idThread::ReturnEntity( idEntity *ent ) {
	gameLocal.program.ReturnEntity( ent );
}

/*
================
idThread::Event_Execute
================
*/
void idThread::Event_Execute( void ) {
	Execute();
}

/*
================
idThread::Pause
================
*/
void idThread::Pause( void ) {
	ClearWaitFor();
	interpreter.doneProcessing = true;
}

/*
================
idThread::WaitMS
================
*/
void idThread::WaitMS( int time ) {
	Pause();
	waitingUntil = gameLocal.time + time;
}

/*
================
idThread::WaitSec
================
*/
void idThread::WaitSec( float time ) {
	WaitMS( SEC2MS( time ) );
}

/*
================
idThread::WaitFrame
================
*/
void idThread::WaitFrame( void ) {
	Pause();

	// manual control threads don't set waitingUntil so that they can be run again
	// that frame if necessary.
	if ( !manualControl ) {
		waitingUntil = gameLocal.time + gameLocal.msec;
	}
}

/***********************************************************************

  Script callable events

***********************************************************************/

/*
================
idThread::Event_TerminateThread
================
*/
void idThread::Event_TerminateThread( int num ) {
	idThread *thread;

	thread = GetThread( num );
	KillThread( num );
}

/*
================
idThread::Event_Pause
================
*/
void idThread::Event_Pause( void ) {
	Pause();
}

/*
================
idThread::Event_Wait
================
*/
void idThread::Event_Wait( float time ) {
	WaitSec( time );
}

/*
================
idThread::Event_WaitFrame
================
*/
void idThread::Event_WaitFrame( void ) {
	WaitFrame();
}

/*
================
idThread::Event_WaitFor
================
*/
void idThread::Event_WaitFor( idEntity *ent ) {
	if ( ent && ent->RespondsTo( EV_Thread_SetCallback ) ) {
		ent->ProcessEvent( &EV_Thread_SetCallback );
		if ( gameLocal.program.GetReturnedInteger() ) {
			Pause();
			waitingFor = ent->entityNumber;
		}
	}
}

/*
================
idThread::Event_WaitForThread
================
*/
void idThread::Event_WaitForThread( int num ) {
	idThread *thread;

	thread = GetThread( num );
	if ( !thread ) {
		if ( g_debugScript.GetBool() ) {
			// just print a warning and continue executing
			Warning( "Thread %d not running", num );
		}
	} else {
		Pause();
		waitingForThread = thread;
	}
}

/*
================
idThread::Event_Print
================
*/
void idThread::Event_Print( const char *text ) {
	gameLocal.Printf( "%s", text );
}

/*
================
idThread::Event_PrintLn
================
*/
void idThread::Event_PrintLn( const char *text ) {
	gameLocal.Printf( "%s\n", text );
}

/*
================
idThread::Event_Say
================
*/
void idThread::Event_Say( const char *text ) {
	cmdSystem->BufferCommandText( CMD_EXEC_NOW, va( "say \"%s\"", text ) );
}

/*
================
idThread::Event_Assert
================
*/
void idThread::Event_Assert( float value ) {
	assert( value );
}

/*
================
idThread::Event_Trigger
================
*/
void idThread::Event_Trigger( idEntity *ent ) {
	if ( ent ) {
		ent->Signal( SIG_TRIGGER );
		ent->ProcessEvent( &EV_Activate, gameLocal.GetLocalPlayer() );
		ent->TriggerGuis();
	}
}

/*
================
idThread::Event_SetCvar
================
*/
void idThread::Event_SetCvar( const char *name, const char *value ) const {
	cvarSystem->SetCVarString( name, value );
}

/*
================
idThread::Event_GetCvar
================
*/
void idThread::Event_GetCvar( const char *name ) const {
	ReturnString( cvarSystem->GetCVarString( name ) );
}

/*
================
idThread::Event_Random
================
*/
void idThread::Event_Random( float range ) const {
	float result;

	result = gameLocal.random.RandomFloat();
	ReturnFloat( range * result );
}

/*
================
idThread::Event_GetTime
================
*/
void idThread::Event_GetTime( void ) {
	ReturnFloat( MS2SEC( gameLocal.realClientTime ) );
}

/*
================
idThread::Event_KillThread
================
*/
void idThread::Event_KillThread( const char *name ) {
	KillThread( name );
}

/*
================
idThread::Event_GetEntity
================
*/
void idThread::Event_GetEntity( const char *name ) {
	int			entnum;
	idEntity	*ent;

	assert( name );

	if ( name[ 0 ] == '*' ) {
		entnum = atoi( &name[ 1 ] );
		if ( ( entnum < 0 ) || ( entnum >= MAX_GENTITIES ) ) {
			Error( "Entity number in string out of range." );
		}
		ReturnEntity( gameLocal.entities[ entnum ] );
	} else {
		ent = gameLocal.FindEntity( name );
		ReturnEntity( ent );
	}
}

/*
================
idThread::Event_Spawn
================
*/
void idThread::Event_Spawn( const char *classname ) {
	idEntity *ent;

	spawnArgs.Set( "classname", classname );
	gameLocal.SpawnEntityDef( spawnArgs, &ent );
	ReturnEntity( ent );
	spawnArgs.Clear();
}

/*
================
idThread::Event_CopySpawnArgs
================
*/
void idThread::Event_CopySpawnArgs( idEntity *ent ) {
	spawnArgs.Copy( ent->spawnArgs );
}

/*
================
idThread::Event_SetSpawnArg
================
*/
void idThread::Event_SetSpawnArg( const char *key, const char *value ) {
	spawnArgs.Set( key, value );
}

/*
================
idThread::Event_SpawnString
================
*/
void idThread::Event_SpawnString( const char *key, const char *defaultvalue ) {
	const char *result;

	spawnArgs.GetString( key, defaultvalue, &result );
	ReturnString( result );
}

/*
================
idThread::Event_SpawnFloat
================
*/
void idThread::Event_SpawnFloat( const char *key, float defaultvalue ) {
	float result;

	spawnArgs.GetFloat( key, va( "%f", defaultvalue ), result );
	ReturnFloat( result );
}

/*
================
idThread::Event_SpawnVector
================
*/
void idThread::Event_SpawnVector( const char *key, idVec3 &defaultvalue ) {
	idVec3 result;

	spawnArgs.GetVector( key, va( "%f %f %f", defaultvalue.x, defaultvalue.y, defaultvalue.z ), result );
	ReturnVector( result );
}

/*
================
idThread::Event_ClearPersistantArgs
================
*/
void idThread::Event_ClearPersistantArgs( void ) {
	gameLocal.persistentLevelInfo.Clear();
}

/*
================
idThread::Event_SetPersistantArg
================
*/
void idThread::Event_SetPersistantArg( const char *key, const char *value ) {
	gameLocal.persistentLevelInfo.Set( key, value );
}

/*
================
idThread::Event_GetPersistantString
================
*/
void idThread::Event_GetPersistantString( const char *key ) {
	const char *result;

	gameLocal.persistentLevelInfo.GetString( key, "", &result );
	ReturnString( result );
}

/*
================
idThread::Event_GetPersistantFloat
================
*/
void idThread::Event_GetPersistantFloat( const char *key ) {
	float result;

	gameLocal.persistentLevelInfo.GetFloat( key, "0", result );
	ReturnFloat( result );
}

/*
================
idThread::Event_GetPersistantVector
================
*/
void idThread::Event_GetPersistantVector( const char *key ) {
	idVec3 result;

	gameLocal.persistentLevelInfo.GetVector( key, "0 0 0", result );
	ReturnVector( result );
}

/*
================
idThread::Event_AngToForward
================
*/
void idThread::Event_AngToForward( idAngles &ang ) {
	ReturnVector( ang.ToForward() );
}

/*
================
idThread::Event_AngToRight
================
*/
void idThread::Event_AngToRight( idAngles &ang ) {
	idVec3 vec;

	ang.ToVectors( NULL, &vec );
	ReturnVector( vec );
}

/*
================
idThread::Event_AngToUp
================
*/
void idThread::Event_AngToUp( idAngles &ang ) {
	idVec3 vec;

	ang.ToVectors( NULL, NULL, &vec );
	ReturnVector( vec );
}

/*
================
idThread::Event_GetSine
================
*/
void idThread::Event_GetSine( float angle ) {
	ReturnFloat( idMath::Sin( DEG2RAD( angle ) ) );
}

/*
================
idThread::Event_GetCosine
================
*/
void idThread::Event_GetCosine( float angle ) {
	ReturnFloat( idMath::Cos( DEG2RAD( angle ) ) );
}

/*
================
idThread::Event_GetSquareRoot
================
*/
void idThread::Event_GetSquareRoot( float theSquare ) {
	ReturnFloat( idMath::Sqrt( theSquare ) );
}

/*
================
idThread::Event_VecNormalize
================
*/
void idThread::Event_VecNormalize( idVec3 &vec ) {
	idVec3 n;

	n = vec;
	n.Normalize();
	ReturnVector( n );
}

/*
================
idThread::Event_VecLength
================
*/
void idThread::Event_VecLength( idVec3 &vec ) {
	ReturnFloat( vec.Length() );
}

/*
================
idThread::Event_VecDotProduct
================
*/
void idThread::Event_VecDotProduct( idVec3 &vec1, idVec3 &vec2 ) {
	ReturnFloat( vec1 * vec2 );
}

/*
================
idThread::Event_VecCrossProduct
================
*/
void idThread::Event_VecCrossProduct( idVec3 &vec1, idVec3 &vec2 ) {
	ReturnVector( vec1.Cross( vec2 ) );
}

/*
================
idThread::Event_VecToAngles
================
*/
void idThread::Event_VecToAngles( idVec3 &vec ) {
	idAngles ang = vec.ToAngles();
	ReturnVector( idVec3( ang[0], ang[1], ang[2] ) );
}

/*
================
idThread::Event_OnSignal
================
*/
void idThread::Event_OnSignal( int signal, idEntity *ent, const char *func ) {
	const function_t *function;

	assert( func );

	if ( !ent ) {
		Error( "Entity not found" );
	}

	if ( ( signal < 0 ) || ( signal >= NUM_SIGNALS ) ) {
		Error( "Signal out of range" );
	}

	function = gameLocal.program.FindFunction( func );
	if ( !function ) {
		Error( "Function '%s' not found", func );
	}

	ent->SetSignal( ( signalNum_t )signal, this, function );
}

/*
================
idThread::Event_ClearSignalThread
================
*/
void idThread::Event_ClearSignalThread( int signal, idEntity *ent ) {
	if ( !ent ) {
		Error( "Entity not found" );
	}

	if ( ( signal < 0 ) || ( signal >= NUM_SIGNALS ) ) {
		Error( "Signal out of range" );
	}

	ent->ClearSignalThread( ( signalNum_t )signal, this );
}

/*
================
idThread::Event_SetCamera
================
*/
void idThread::Event_SetCamera( idEntity *ent ) {
	if ( !ent ) {
		Error( "Entity not found" );
		return;
	}

	if ( !ent->IsType( idCamera::Type ) ) {
		Error( "Entity is not a camera" );
		return;
	}

	gameLocal.SetCamera( ( idCamera * )ent );
}

/*
================
idThread::Event_FirstPerson
================
*/
void idThread::Event_FirstPerson( void ) {
	gameLocal.SetCamera( NULL );
}

/*
================
idThread::Event_Trace
================
*/
void idThread::Event_Trace( const idVec3 &start, const idVec3 &end, const idVec3 &mins, const idVec3 &maxs, int contents_mask, idEntity *passEntity ) {
	if ( mins == vec3_origin && maxs == vec3_origin ) {
		gameLocal.clip.TracePoint( trace, start, end, contents_mask, passEntity );
	} else {
		gameLocal.clip.TraceBounds( trace, start, end, idBounds( mins, maxs ), contents_mask, passEntity );
	}
	ReturnFloat( trace.fraction );
}

/*
================
idThread::Event_TracePoint
================
*/
void idThread::Event_TracePoint( const idVec3 &start, const idVec3 &end, int contents_mask, idEntity *passEntity ) {
	gameLocal.clip.TracePoint( trace, start, end, contents_mask, passEntity );
	ReturnFloat( trace.fraction );
}

/*
================
idThread::Event_GetTraceFraction
================
*/
void idThread::Event_GetTraceFraction( void ) {
	ReturnFloat( trace.fraction );
}

/*
================
idThread::Event_GetTraceEndPos
================
*/
void idThread::Event_GetTraceEndPos( void ) {
	ReturnVector( trace.endpos );
}

/*
================
idThread::Event_GetTraceNormal
================
*/
void idThread::Event_GetTraceNormal( void ) {
	if ( trace.fraction < 1.0f ) {
		ReturnVector( trace.c.normal );
	} else {
		ReturnVector( vec3_origin );
	}
}

/*
================
idThread::Event_GetTraceEntity
================
*/
void idThread::Event_GetTraceEntity( void ) {
	if ( trace.fraction < 1.0f ) {
		ReturnEntity( gameLocal.entities[ trace.c.entityNum ] );
	} else {
		ReturnEntity( ( idEntity * )NULL );
	}
}

/*
================
idThread::Event_GetTraceJoint
================
*/
void idThread::Event_GetTraceJoint( void ) {
	if ( trace.fraction < 1.0f && trace.c.id < 0 ) {
		idAFEntity_Base *af = static_cast<idAFEntity_Base *>( gameLocal.entities[ trace.c.entityNum ] );
		if ( af && af->IsType( idAFEntity_Base::Type ) && af->IsActiveAF() ) {
			ReturnString( af->GetAnimator()->GetJointName( CLIPMODEL_ID_TO_JOINT_HANDLE( trace.c.id ) ) );
			return;
		}
	}
	ReturnString( "" );
}

/*
================
idThread::Event_GetTraceBody
================
*/
void idThread::Event_GetTraceBody( void ) {
	if ( trace.fraction < 1.0f && trace.c.id < 0 ) {
		idAFEntity_Base *af = static_cast<idAFEntity_Base *>( gameLocal.entities[ trace.c.entityNum ] );
		if ( af && af->IsType( idAFEntity_Base::Type ) && af->IsActiveAF() ) {
			int bodyId = af->BodyForClipModelId( trace.c.id );
			idAFBody *body = af->GetAFPhysics()->GetBody( bodyId );
			if ( body ) {
				ReturnString( body->GetName() );
				return;
			}
		}
	}
	ReturnString( "" );
}

/*
================
idThread::Event_FadeIn
================
*/
void idThread::Event_FadeIn( idVec3 &color, float time ) {
	idVec4		fadeColor;
	idPlayer	*player;

	player = gameLocal.GetLocalPlayer();
	if ( player ) {
		fadeColor.Set( color[ 0 ], color[ 1 ], color[ 2 ], 0.0f );
		player->playerView.Fade(fadeColor, SEC2MS( time ) );
	}
}

/*
================
idThread::Event_FadeOut
================
*/
void idThread::Event_FadeOut( idVec3 &color, float time ) {
	idVec4		fadeColor;
	idPlayer	*player;

	player = gameLocal.GetLocalPlayer();
	if ( player ) {
		fadeColor.Set( color[ 0 ], color[ 1 ], color[ 2 ], 1.0f );
		player->playerView.Fade(fadeColor, SEC2MS( time ) );
	}
}

/*
================
idThread::Event_FadeTo
================
*/
void idThread::Event_FadeTo( idVec3 &color, float alpha, float time ) {
	idVec4		fadeColor;
	idPlayer	*player;

	player = gameLocal.GetLocalPlayer();
	if ( player ) {
		fadeColor.Set( color[ 0 ], color[ 1 ], color[ 2 ], alpha );
		player->playerView.Fade(fadeColor, SEC2MS( time ) );
	}
}

/*
================
idThread::Event_SetShaderParm
================
*/
void idThread::Event_SetShaderParm( int parmnum, float value ) {
	if ( ( parmnum < 0 ) || ( parmnum >= MAX_GLOBAL_SHADER_PARMS ) ) {
		Error( "shader parm index (%d) out of range", parmnum );
	}

	gameLocal.globalShaderParms[ parmnum ] = value;
}

/*
================
idThread::Event_StartMusic
================
*/
void idThread::Event_StartMusic( const char *text ) {
	gameSoundWorld->PlayShaderDirectly( text );
}

/*
================
idThread::Event_Warning
================
*/
void idThread::Event_Warning( const char *text ) {
	Warning( "%s", text );
}

/*
================
idThread::Event_Error
================
*/
void idThread::Event_Error( const char *text ) {
	Error( "%s", text );
}

/*
================
idThread::Event_StrLen
================
*/
void idThread::Event_StrLen( const char *string ) {
	int len;

	len = strlen( string );
	idThread::ReturnInt( len );
}

/*
================
idThread::Event_StrLeft
================
*/
void idThread::Event_StrLeft( const char *string, int num ) {
	int len;

	if ( num < 0 ) {
		idThread::ReturnString( "" );
		return;
	}

	len = strlen( string );
	if ( len < num ) {
		idThread::ReturnString( string );
		return;
	}

	idStr result( string, 0, num );
	idThread::ReturnString( result );
}

/*
================
idThread::Event_StrRight
================
*/
void idThread::Event_StrRight( const char *string, int num ) {
	int len;

	if ( num < 0 ) {
		idThread::ReturnString( "" );
		return;
	}

	len = strlen( string );
	if ( len < num ) {
		idThread::ReturnString( string );
		return;
	}

	idThread::ReturnString( string + len - num );
}

/*
================
idThread::Event_StrSkip
================
*/
void idThread::Event_StrSkip( const char *string, int num ) {
	int len;

	if ( num < 0 ) {
		idThread::ReturnString( string );
		return;
	}

	len = strlen( string );
	if ( len < num ) {
		idThread::ReturnString( "" );
		return;
	}

	idThread::ReturnString( string + num );
}

/*
================
idThread::Event_StrMid
================
*/
void idThread::Event_StrMid( const char *string, int start, int num ) {
	int len;

	if ( num < 0 ) {
		idThread::ReturnString( "" );
		return;
	}

	if ( start < 0 ) {
		start = 0;
	}
	len = strlen( string );
	if ( start > len ) {
		start = len;
	}

	if ( start + num > len ) {
		num = len - start;
	}

	idStr result( string, start, start + num );
	idThread::ReturnString( result );
}

/*
================
idThread::Event_StrToFloat( const char *string )
================
*/
void idThread::Event_StrToFloat( const char *string ) {
	float result;

	result = atof( string );
	idThread::ReturnFloat( result );
}

/*
================
idThread::Event_RadiusDamage
================
*/
void idThread::Event_RadiusDamage( const idVec3 &origin, idEntity *inflictor, idEntity *attacker, idEntity *ignore, const char *damageDefName, float dmgPower ) {
	gameLocal.RadiusDamage( origin, inflictor, attacker, ignore, ignore, damageDefName, dmgPower );
}

/*
================
idThread::Event_IsClient
================
*/
void idThread::Event_IsClient( void ) {
	idThread::ReturnFloat( gameLocal.isClient );
}

/*
================
idThread::Event_IsMultiplayer
================
*/
void idThread::Event_IsMultiplayer( void ) {
	idThread::ReturnFloat( gameLocal.isMultiplayer );
}

/*
================
idThread::Event_GetFrameTime
================
*/
void idThread::Event_GetFrameTime( void ) {
	idThread::ReturnFloat( MS2SEC( gameLocal.msec ) );
}

/*
================
idThread::Event_GetTicsPerSecond
================
*/
void idThread::Event_GetTicsPerSecond( void ) {
	idThread::ReturnFloat( USERCMD_HZ );
}

/*
================
idThread::Event_CacheSoundShader
================
*/
void idThread::Event_CacheSoundShader( const char *soundName ) {
	declManager->FindSound( soundName );
}

/*
================
idThread::Event_DebugLine
================
*/
void idThread::Event_DebugLine( const idVec3 &color, const idVec3 &start, const idVec3 &end, const float lifetime ) {
	gameRenderWorld->DebugLine( idVec4( color.x, color.y, color.z, 0.0f ), start, end, SEC2MS( lifetime ) );
}

/*
================
idThread::Event_DebugArrow
================
*/
void idThread::Event_DebugArrow( const idVec3 &color, const idVec3 &start, const idVec3 &end, const int size, const float lifetime ) {
	gameRenderWorld->DebugArrow( idVec4( color.x, color.y, color.z, 0.0f ), start, end, size, SEC2MS( lifetime ) );
}

/*
================
idThread::Event_DebugCircle
================
*/
void idThread::Event_DebugCircle( const idVec3 &color, const idVec3 &origin, const idVec3 &dir, const float radius, const int numSteps, const float lifetime ) {
	gameRenderWorld->DebugCircle( idVec4( color.x, color.y, color.z, 0.0f ), origin, dir, radius, numSteps, SEC2MS( lifetime ) );
}

/*
================
idThread::Event_DebugBounds
================
*/
void idThread::Event_DebugBounds( const idVec3 &color, const idVec3 &mins, const idVec3 &maxs, const float lifetime ) {
	gameRenderWorld->DebugBounds( idVec4( color.x, color.y, color.z, 0.0f ), idBounds( mins, maxs ), vec3_origin, SEC2MS( lifetime ) );
}

/*
================
idThread::Event_DrawText
================
*/
void idThread::Event_DrawText( const char *text, const idVec3 &origin, float scale, const idVec3 &color, const int align, const float lifetime ) {
	gameRenderWorld->DrawText( text, origin, scale, idVec4( color.x, color.y, color.z, 0.0f ), gameLocal.GetLocalPlayer()->viewAngles.ToMat3(), align, SEC2MS( lifetime ) );
}

/*
================
idThread::Event_InfluenceActive
================
*/
void idThread::Event_InfluenceActive( void ) {
	idPlayer *player;

	player = gameLocal.GetLocalPlayer();
	if ( player && player->GetInfluenceLevel() ) {
		idThread::ReturnInt( true );
	} else {
		idThread::ReturnInt( false );
	}
}


For the homeowners looking forward to the purchase of a new home, it will be a sure perfect alternative to go for the services of a custom home builder as nothing seems to be better than this alternative to this. Dealing with the custom home builders will get out of your way the hassle that often comes with the need such as shuffling through different homes so as to have the one that will be the perfect option for you to go with. As a matter of fact, these service providers will indeed construct you a home as per your very specifications.
As a result the custom home builders will be a sure alternative for those who have families and as such are interested in having a home that is of a permanent ownership and occupancy that precisely goes in line with their specifications. The following are some of the sure benefits that come with the hiring of the services of the custom home builders and some bit of news that will be received with so much pleasure by the prospective home buyers.
One of the top benefits of hiring the services of a custom home builder is in the sense that they will enable you to come up with your very kind of designs. These service providers always have their own designers who will do a great job at designing the whole lay out for the house or home. With the custom builder, you will have a team that will be surely in a position to come up with a home that will indeed meet your very specifications as a home buyer.
The other benefit of the services of the custom home builders is in the fact of there being no compromises of any kind in the kind of house you want to buy as a home buyer. In most cases, it is the experience of many that when you have to buy a house from an already built house seller, you will always have to make so many compromises to the purchase as there may be some changes that you may be interested in that may not be brought in or removed, however the case may be. But with the services and acquisition of a home through the services of a custom home builder, a home buyer will be entirely with the freedom and ability to bring in and leave out all that they may regard as of no use. This is as such the reason why you will indeed find it a lot of a preferred choice for a majority of the home buyers for the acquisition of new homes.
The next benefit that makes the services of the custom home builders a sure choice for you as a home buyer is the fact of the affordability of the service.


text:
What If …? Marvel Studios dazzles with its new official trailer in Spanish
What If…? from Marvel Studios shares its new official trailer in Spanish. The animated series of the American giant will arrive at Disney + next August 11th. From that day on, you will receive a new episode every Wednesday, until completing the 10 expected in the first season. You can see the full video in the Headboard of this news.
What If…? Marvel Studios: Everything We Know
"You will enter a multiverse of infinite possibilities", narrates the producer in its official description. Marvel Studios' first animated series aims to give a different perspective on its array of heroes. Through the eyes of The vigilant, played by actor Jeffrey Wright, we will travel through the multiverses to see the faces of always play a different role.
Among those roles we can find Peggy Carter as Captain Britain, Doctor Strange in his darkest version, or T'Challa as Star Lord, the charismatic leader of the Guardians of the Galaxy. All the animated characters will have the voices of their actors in real life. Including Chadwick Boseman, which was their last collaboration before passing away.
Therefore, we can expect the following names: Peggy Carter as Captain Britain (Hayley Atwell), Thor (Chris Hemsworth), Gamora (Zoe Saldana), T'Challa como Star-Lord (Chadwick Boseman), Doctor Strange with a dark look (Benedict Cumberbatch), Killmonger (Michael B. Jordan) y Black widow (Scarlett Johansson).
We know that 20 episodes have been made; the remaining 10 will carry over to the second season. It has not yet transpired what level of relevance the series will have in the current situation of the MCU, so it only remains to wait for its premiere on August 11. To see it you must be registered in the Disney + subscription, the platform where the company usually releases the content of Marvel licenses.
Read Also Guardians of the Night (Kimetsu No Yaiba): The Infinite Train already has a date on Amazon Prime Video
Fountain: Marvel Spain on YouTube
# Communication# Disney+# IP television# Marvel (video games)# Series Marvel# Superhero series# Television series
Fire Force Season 3: Release Date & Everything We Know
Yinyleon: Sneak Peek Into The Life Of Pornhub's Most Viewed Model
21 Celebrity Camel Toe Moments Captured in Public

redpajama_set_name: RedPajamaCommonCrawl


There are plenty of enterprise-level solutions aimed at Fortune 1000 companies, and now also a growing number of affordable Web-based services aimed at small to midsized companies. We tested three to see how they compare.
Is your business spread across multiple offices? Does it work closely with outside clients? Do you spend your day trying to collaborate with faraway people via phone and e-mail? If you answered yes to any of these questions, it's high time you adopted an Internet collaboration tool—a set of graphical applications that lets you easily interact with colleagues via your own private network.
There are plenty of enterprise-level solutions aimed at Fortune 1000 companies, and now also a growing number of affordable Web-based services aimed at small to midsized companies. We tested three to see how they compare. 37Signals, a Chicago-based Web-design firm, recently debuted a simple, inexpensive collaboration tool known as Basecamp, and after a few facelifts, two of the more advanced tools, Intranets.com and Groove, are more impressive than ever.


Christopher Tucker, known famously as Chris Tucker, is a standup comedian and movie actor who gained widespread popularity from his role as Detective James Carter in the Rush Hour series, alongside, Jackie Chan. He has worked with several famous stars such as Bruce Willis and Ice Cube in other projects.
Chris Tucker was born on August 31, 1971, in Atlanta, Georgia, United States. His father Norris Tucker had a janitor agency, and his mother Mary Louise was a homemaker who also did small jobs to support the family. Tucker has five siblings and is the youngest child of his parents.
While in high school, Chris Tucker worked as a janitor at a local Burger King.
Chris Tucker left for Los Angeles with dreams of making it big. He later said in an interview that he left home early so that if he failed, he could always go back. As a child, he had developed a style of comedy, and hoped to reach success and fame, riding on the same.
After a few small stints, Chris Tucker landed a spot at the Def Comedy Jam. He was quite successful there and became a regular comedian with them.
Tucker's first movie role came in 1994 when he made his debut in House Party 3. The movie was moderately successful, but Tucker's performance was praised. He then did a few small roles, before appearing in the 1995 film, Friday, alongside Ice Cube. Chris Tucker career got a major boost when he was cast in a role in the Bruce Willis film, The fifth element. But the most notable movies of Tucker's career belong to the Rush Hour series. These films established him as an accomplished actor in the Hollywood film industry. The first two Rush hour movies made more than $600 million.
The success of the franchise allowed the producers to sign Tucker for a third film Rush Hour 3, for a huge amount of $25 million. The film, however, landed flat on the box office due to a weak script. Chris Tucker also appeared in the movie Jackie Brown, by Quentin Tarantino.
Chris Tucker was in a debt of over 12 million dollars at some point after the failure of Rush Hour 3. Disillusioned, he left Hollywood and vanished from the scene for close to four years.
In 2011, Chris Tucker made a comeback to comedy and began performing standup comedy. Motivated by the positive feedback, he took on a role in the 2012 movie, Silver Linings Playbook. The film was successful, and his performance was praised again.
Chris Tucker received the MTV award for Best Onscreen Duo along with Jackie Chan for the Rush Hour series. He also won the 2012 Broadcast Film Critics Award for Best Cast along with other members of the Silver Linings Playbook cast.
Chris Tucker has a son named Destin, who was born in 1998. He has traced his ancestry to African, European and Native American people.


text:
\section{Introduction}

Gravitational wave detections of coalescing binary black holes
	(\cite{TheLIGOScientific:2016pea, Abbott:2016blz, Abbott:2016nmj, Abbott:2017vtc})
	with the Advanced LIGO detectors
	(\cite{Abramovici:1992ah, Harry:2010zz, Aasi:2013wya, TheLIGOScientific:2014jea, TheLIGOScientific:2016agk})
	have opened up a new tool to test modified theories of gravity.
A number of such tests have already been performed looking for generic deviations from Einstein's general relativity (GR),
	and so far the data has been found consistent with GR
	(\cite{TheLIGOScientific:2016pea, Abbott:2016blz, TheLIGOScientific:2016src, Abbott:2017vtc, Abbott:2016bqf}).
Merging black hole observations are particularly suited to testing theories that deviate from Einstein's GR in the near black hole horizon regime.
In a certain sense, colliding black holes are the ideal testing ground for such models,
	but because of a lack of definite predictions, little is known about how these tests impact specific modified theories.

One such theory that proposes to modify the near-horizon physics is pseudo-complex general relativity (pc-GR) (\cite{Hess:2008wd}).
This theory proposes a pseudo-complex generalisation of GR and leads to a number of novel predictions.
Ray-tracing of light rays in this geometry has been previously calculated in \cite{Schonenbach:2013nya}
	with an eye to comparing predictions to observations from the Event Horizon Telescope.
Simulations of accretion disks have been studied to compare to X-ray observations of accreting systems (\cite{Hess:2015hpc}),
associated with an innermost stable circular orbit (ISCO).
Further studies have looked at the effect on gravitational redshift and frame-dragging (\cite{Schonenbach:2012mw}).
Most of these studies relate to comparisons with future precision observational data.

One of the features believed to be associated with pc-GR is a strong modification of near-horizon physics.
In fact it is has been claimed that pc-GR predicts there are no black holes
	because of a modification of the near-horizon gravitational field (\cite{Hess:2010pba}).
This makes gravitational wave observations of merging black holes ideal observations to test such a theory.
Here we will directly compare the theory with the gravitational wave observation of GW150914
	(\cite{Abbott:2016blz, Abbott:2016bqf})
	and with bounds on modifications from GR established by Advanced LIGO's first detections
	(\cite{TheLIGOScientific:2016pea, Abbott:2016blz, TheLIGOScientific:2016src, Abbott:2016nmj, Abbott:2017vtc}).
This has previously been investigated in \cite{Hess:2016gmh}, where it was claimed that
	pc-GR implies that the coalescence which produced GW150914
	may have had a chirp mass much larger than claimed by the LIGO team,
	and occurring at a much greater luminosity distance.
Here we will re-examine this interpretation and show how existing gravitational wave observations
	are able to constrain the free parameters of pc-GR
	and even rule out certain parameter ranges that allow horizonless objects.

\section{Model and spacetime metric}

In any metric theory of gravity, including pc-GR, the spacetime of an isolated, spinning, stationary object is likely to be axisymmetric.
By the requirements of theorem 7.1.1 of (\cite{wald2010general}) such a stationary, axisymmetric metric can be put in the form
\beq \label{generalKerr}
\dd s^2 = g_{tt}\dt^2 + 2g_{\phi t} \dt \dphi + g_{\phi\phi}\dphi^2 + g_{\rho\rho}\drho^{2} + g_{zz}\dz^{2} ~,
\eeq
where only four of the metric functions are independent since $\rho^{2} = g^2_{t\phi} - g_{tt}g_{\phi\phi}$,
	and all metric functions are only functions of the coordinates $\rho$ and $z$.
The coordinates $t$ and $\phi$ are adapted to the stationary and axisymmetric symmetries and the coordinate $z$ can be replaced with a zenith-angle coordinate $\theta$.
If we furthermore assume that the spacetime has a reflection symmetry about an equatorial plane, $\theta=\frac{\pi}{2}$,
	then all metric functions are guaranteed to satisfy $\partial_{\theta}g_{ab}=0$ on this equatorial plane.
This general form of the metric will hold in any metric theory of gravity with these symmetries
	and is a purely geometrical result, before any theory-specific equations of motion have been solved.
In particular,
	it contains the Kerr-Newman class of electrovacuum solutions in GR as well as a host of other known solutions.

To obtain the functional form of the metric functions in a specific theory we should solve the equations of motion.
This has already been done within pc-GR (\cite{Caspar:2012ux}) and we adopt without modification the solution here:
\ba
g_{tt} &=& - \left( 1 - \frac{\psi}{\Sg} \right)		~~~,	~~
g_{rr} = \frac{\Sg}{\Delta}		~~~,	~~~
g_{\theta\theta} = \Sg		~,	\nonumber \\
g_{\phi\phi} &=& \left( \left( r^2 + a^2 \right) + \frac{a^2\psi}{\Sg} \sin^2\theta \right) \sin^2\theta			~,	\nonumber \\
g_{t\phi} &=& g_{\phi t} = - a \frac{\psi}{\Sg} \sin^2\theta		~,
\label{metric}
\ea
with $\Sg = r^2 + a^2 \cos^2 \theta$ and $\Delta = r^2 + a^2 - \psi(r)$.
If the function $\psi(r)$ is chosen to satisfy $\psi =2Mr$
	then this solution is just the Kerr solution of vacuum GR with mass $M$ and specific angular momentum $a = \chi M$.
However, pc-GR allows for $\psi(r)$ to be a more general function,
	with the form adopted in \cite{Caspar:2012ux} $\psi  = 2 m(r) r$ where
\ba
m(r) = M - \frac{B}{2r^{n}} = M \, g(r)	~,	~~
g(r) = \left[ 1 - b \left(\frac{M}{r}\right)^{n} \, \right] .
\label{modified mass}
\ea
Here $b$ is a new dimensionless parameter for the pc-GR modification. Its value in GR is zero.
The ultimate provenance of this free parameter in pc-GR is a term in the action variation for the theory,
that following a proposal of \cite{Schuller:2002ma} is taken to lie exclusively in one half of the kinematical pseudo-complex algebra.
The freedom to choose $\psi(r)$ is a restricted form of the four metric-function freedom in the more general metric (\ref{generalKerr}).
In fact, in the non-rotating case with $g_{t\phi}=0$,
these solutions are examples of a restricted class of dirty black holes studied previously in Einstein's GR (\cite{Visser:1992qh});
	of particular relevance to the current work is their quasi-normal mode behaviour (\cite{Medved:2003rga}).
We will not discuss further here the theoretical motivation for including such a general function,
but merely adopt this as a model to be constrained by data.

The parameter $b$ can be chosen large enough such that the solutions do not admit Killing horizons,
although values less than this critical value are not in principle ruled out by the theory.
The Killing horizons of the Killing vector field
$k^{a} = \delta^{a}_{t} - \Omega\delta^{a}_{\phi}$
occur at the solutions of $r^{2}+a^{2}-2m(r)r =0$ where $\Omega = g_{t\phi}/g_{\phi\phi}$.
No horizons exist when this equation does not have real positive solutions, which occurs when $b$ is greater than
\beq b_{\mathrm{maxH}} = \rmin^{n}\left( 1 - \frac{\chi^{2}}{2\rmin} - \frac{\rmin}{2}\right)  ~, \label{bmaxH} \eeq
where $\rmin = (n+\sqrt{n^2-(n^2-1)\chi^2})/(n+1)$.
Thus for sufficiently large $b$, black holes can be said not to exist (\cite{Hess:2010pba}).
This limiting value is largest when $\chi =0$, and in the $n=2$ case takes the value $16/27$.

As written, the spacetime metric is still in general singular,
and for $a=0$ contains a curvature singularity at $r=0$,
as evidenced by the value of the Kretschmann scalar
\ba
\frac{r^{6}}{4}R_{abcd}R^{abcd} = \hspace{5cm} & & \nonumber \\
	m'' r^{2} (4m-4m'r +r^{2}m'') + 8m'r(m'r-2m)+12m^{2} ~. & &
\ea
It is clearly the intention of the original authors of the model
that such singularities should be regularised by some effect (\cite{HessPrivate})
	and we take the spacetime of equation (\ref{metric}) as a working model only away from such singularities.

Equatorial circular orbits in the general spacetime (\ref{generalKerr}) have four-velocities, $u^{a}$, given by
\beq
u^{a} = \frac{\dt}{\dlam}\delta^{a}_{t} + \frac{\dphi}{\dlam}\delta^{a}_{\phi}	~,
\eeq
where $\lam$ parameterises the orbital path and can be chosen to be the proper time in the case of timelike orbits.
For these orbits to be geodesic, bound only by gravity,
we should in addition solve the geodesic equation $u^{a}\nabla_{a}u^{b} = 0$.
In the spacetime (\ref{generalKerr}), the only non-trivial equation of the four geodesic equations is the $r$-component.
This condition suffices to determine the functions $\frac{\dt}{\dlam}$ and $\frac{\dphi}{\dlam}$
	up to an overall normalisation as a function of the $r$ coordinate.
Since the orbital frequency observed asymptotically is given by $\w = \dphi / \dt$, the geodesic equation gives
\beq \label{omega_geodesic}
\w_{\pm} =
\frac{-g_{t\phi}' \pm \sqrt{g_{t\phi}'^{2}-g_{\phi\phi}' g_{tt}'}}{g_{\phi\phi}'}	~,
\eeq
where $'$ denotes an $r$-derivative.
Therefore, using the metric components of (\ref{metric}) the geodesic equation can be written as
\beq \label{mgeodesic} (\w \, a - 1)^2(m - m' r) - \w^2 \, r^3 = 0 ~, \eeq
In the limit of $m'=0$ this gives the expected behaviour for the Kerr spacetime (\cite{Bardeen:1972fi}),
	and in the further Schwarzschild limit of $a=0$ it reduces to the familiar Kepler-like relation between $r$ and $\w$ (\cite{Abbott:2016bqf}).

\section{Post-merger: ringdown}

The single body metric (\ref{metric}) lends itself immediately to calculations of test mass orbital properties,
	needed for studies of ray tracing, accretion disks or ringdown frequencies.
Objects compact enough to support circular photon orbits are expected
	to have ringdown frequencies approximated by the gravitational wave frequency
	of a massless test particle at this ```light ring" (LR) (\cite{Cardoso:2016rao}).
For the orbits discussed above to be null, we require additionally that $u^{a}u_{a}=0$.
This is equivalent to requiring
\beq \label{omega_null}
\w_{\pm} =  \frac{-g_{t\phi} \pm \sqrt{g_{t\phi}^{2}-g_{\phi\phi} g_{tt}}}{g_{\phi\phi}}	~.
\eeq
Using the metric components of (\ref{metric}) the null condition can be rewritten as
\beq \label{mnull} 2m - r - 4\w ma + \w^2 (r^3 + ra^2 + 2ma^2) = 0 ~. \eeq
For a circular orbit to be both geodesic and null requires both eqns (\ref{mgeodesic}) and (\ref{mnull}) to be satisfied.
Eliminating $\w$ from these equations gives the location of the light ring.
This will be the root of a polynomial in $r$, in the present case given by
\beq \sqrt{\Delta}(r^3-a^2 F) + a(2r^2m + (r^2+a^2)F) - r\sqrt{rF}g_{\phi\phi} = 0 ~,\eeq
where $\Delta$ and $g_{\phi\phi}$ are functions given in eqn (\ref{metric}) and we have defined $F = m - m' r$ as in \cite{Hess:2016gmh}.
This equation will have a positive real root (and hence a light ring will exist) if its value at a local minimum is negative for positive $r$.
For the static, spherically symmetric case with $-g_{tt}=g_{rr}^{-1} = 1-2m(r)/r$ and $g_{t\phi} = 0$ the equation becomes
\beq r-3m(r) + m' r = 0 ~, \eeq
For the Schwarzschild solution with $m'=0$ this gives the familiar photon sphere at $r=3M$.
For the mass function (\ref{modified mass}), the existence of a light ring requires $b$ to be less than
\beq b_{\mathrm{maxLR}} = \frac{1}{n(3+n)}\left( \rLR\right)^{n+1} ~, \label{bmaxLR} \eeq
where $\rLR=3n/(n+1)$.
Thus for the non-rotating case, when $n>0$, if there is a horizon then there is also a photon sphere.

With the location of the light ring,
	the frequency of an orbiting null test mode can be calculated using either eqn (\ref{omega_geodesic}) or eqn (\ref{omega_null}).
Fig (\ref{fig:ringdown}) shows the mass and spin values that the spacetime described by equation (\ref{metric}) needs to have
	in order to have a light-ring frequency of 250 Hz.
This frequency is broadly consistent with the ringdown frequency of GW150914 (\cite{TheLIGOScientific:2016src}).
It can be seen from the figure that for values of $b$ greater than zero,
	either a higher mass or a lower frequency is needed obtain the same frequency as the required values in general relativity.

\begin{figure}
	\includegraphics[width=\columnwidth]{ringdown_plot}
    \caption{The final mass and spin values needed for the ringdown frequency, based on the light ring orbital frequency to take the value 250 Hz.
    Values of $b$ greater than zero require either a higher mass or a lower spin than the $b=0$ values predicted by GR.}
    \label{fig:ringdown}
\end{figure}

For values of $b$ greater than $b_{\mathrm{maxLR}}$ there is no light ring.
In this case the ringdown of the object will be dominated by its intrinsic quasi-normal modes and will look radically different from the damped-sinusoid ringdown associated with the light ring.
The exact calculation of this behaviour will likely require a numerical solution of the field equations of pc-GR and is beyond the scope of this paper.

\section{Pre-merger: inspiral}

In order to solve the two-body problem for the orbital motion of two nearly equal mass objects,
	more is needed than just the one-body metric (\ref{metric}).
In Newtonian gravity the two-body problem of bound gravitational orbits is solved by the Keplerian orbits.
These Keplerian orbits, along with the Einstein quadrupole formula for gravitational wave emission,
can be used to infer basic properties of the binary source of GW150914 (\cite{Abbott:2016bqf}).
Beyond this Newtonian order,
post-Newtonian (PN) corrections to the orbits can be calculated,
which impact the gravitational wave signal.
These are usually regulated (\cite{Cutler:1994ys, Blanchet:1995ez, Blanchet:2013haa})
	by the PN parameter $x \sim \left( v/c \right)^2$,
	the dimensionless spins,
	and the mass ratio $q = M_1/M_2$,
	with $M = M_1+M_2$ the total mass
	and $\mu = M_1 M_2 / M = M q / (1+q)^2$ the reduced mass.
To these we now add the parameter $b$ which regulates the relative strength of the modification to the function $\psi$.
In the Newtonian and post-Newtonian regimes, $x \sim M / r \sim (M\w)^{2/3}$.
We thus see from the factor $g(r)$ in (\ref{modified mass}) that every appearance of $b$ involves a suppression by at least $n$th pN order.
We shall approximate how the leading order correction to the Newtonian frequency and phase evolutions depends on the modification,
and find the $b$ dependent post-Newtonian term to leading order in $b$.

In the wave zone we expect the same relation between the metric perturbation and the source quadrupole as in GR,
	and so expect the same wave polarizations and multipole decomposition.
We therefore treat the generation of gravitational waves
	as governed by a quadrupole formula
	(\cite{Einstein:1918btx,Blanchet:1995ez,Blanchet:2013haa,Abbott:2016bqf}),
\beq
  \label{quadrupole}
  \dot{E}_{\rm GW}
  = - \frac{32}{5} \frac{G}{c^5} \mu^2 \, r^4 \, \w^6 \, g^\varrho(r)~,
\eeq
where we allow for a possible deviation from the GR quadrupole formula
	with a subleading term $g^\varrho(r)$.
Examining the energy carried by the waves far away suggests adopting $\varrho=0$,
	while we note that \cite{Hess:2016gmh} uses $\varrho=1$ for regulating this emission.

The output of gravitational waves drains the orbital energy of the system,
    which is assumed to descend through quasi-circular orbits.
To leading order in $b$ this orbital energy is
\ba
\label{Eorbital}
E_{\rm orb} &=& -\frac{G m_1(r) m_2(r) } {2r}				\nonumber \\
	&=& -\frac{G M \mu } {2r} \left[ 1
										- b \left( \! \frac{M}{r} \! \right)^{\!n} \!\! Q
										+ b^2 \left( \! \frac{M}{r} \! \right)^{\!2n} \!\! Q_2
								\right],~~~~~~
\ea
where $Q = \frac{1 \!+\! q^n} {\left( 1 \!+\!q \right)^n}$,
and $Q_2 = \frac{q^n} {\left( 1 \!+\!q \right)^{2n}} \mathfrak{f}(n,\eps_1, \eps_2)$
depend on the mass ratios and distributions\footnote{
The form-factor
\ba
\mathfrak{f}(n, \eps_1, \eps_2) = n 	\sum_{k=1}^{n\!+\!2} (-1)^k
		\frac{\Gm(n\!+\!k\!-\!2)\,\Gm(n\!+\!2\!-\!k)}{\Gm(n\!+\!2)\,\Gm(n\!-\!1)}	\cdot		~~~~~~~~	\nonumber\\
\cdot
		\left. \left[ x^{-(n\!+\!2\!-\!k)}
					\sum_{m=0}^1
							(-1)^{m(n-1)} (x\!+\!(-1)^m)^{-(n\!+\!k\!-\!2)}
		\right] \right|^{1-\eps_2}_{\eps1}
\!\!\!\!\!
\ea
also generally depends on the how the singularities near $r=0$ are regularized.
In the simplest model, $\mathfrak{f}(n, \eps_1, \eps_2) = 1$.
}.
We note that $Q=1,\,Q_2=0$ corresponds to the model of \cite{Hess:2016gmh}.
We also introduce for the deviation from GR the shorthand
\beq
\gt = 1 - g(R) = b \left( \! \frac{M}{r} \! \right)^{\!n} ~~,~~
\frac{\dd \gt}{dr} = -\frac{n}{r}\gt ~,
\eeq
such that to leading order in the deviation,
\beq
\label{Kepler}
 \frac{\dd E_{\rm orb}}{\dr}
 = \frac{G M \mu }{2r^2}
	\left[	1 - (n\!+\!1) \, Q \, \gt	\, \right] \, ,
\eeq
which can be used in the equation for the energy balance equation
	$\dot{E}_{\rm GW} = \dot{E}_{\rm orb} = {E}_{\rm orb}'\dot{r}$
	to find
\beq
\label{energy balance short}
 - \frac{32}{5} \frac{G}{c^5} \mu^2 \, r^4 \, \w^6 \, g^\varrho(r) = \frac{G M \mu }{2r^2}
	\left[	1 - (n\!+\!1) \, Q \, \gt	\, \right] \dot{r}	~,
\eeq
We note that for large $b$, the gravitational well might have a minimum
	at finite $r = M ^{\,n} \!\!\!\! \sqrt{(n\!+\!1)\,b\,Q}$,
	by which the energy balance approximations fail.
Before reaching there,
	the orbital angular velocity $\w$ can be eliminated
	from the expression (\ref{energy balance short}) by noting that,
    for quasi-circular orbits,
    there is a relation between $\w$ and $r$ given similarly to Kepler's third law by
\beq
\label{Kepler2}
\w^2 = \frac{G M }{r^3} \left[	1 - (n\!+\!1) \, Q \, \gt \,		\right] \, ,
\eeq
Thus we find from equation (\ref{energy balance short}) that
\beq
 \label{energy balance full r}
 \dot{r} = - \frac{64}{5} \frac{G^3 M^2 \mu}{r^3 c^5} \,
	\left[	1 - (n\!+\!1) \, Q \, \gt \,	\right]^2 \, g^\varrho(r) ~,
\eeq
an equation which can be solved numerically for the orbit.

\subsection{Amplitude evolution}
The evolution of the amplitude of the gravitational wave from a binary inspiral can be found
	by substituting $r(t)$ from eqn (\ref{energy balance full r}) and $\w(t)$ from eqn (\ref{Kepler2})
	into the Newtonian order amplitude equation (compare \cite{Hess:2016gmh}'s  Eq. (14), with $\varrho=1$)
\beq
A = \frac{4G\mu \w^2 r^2}{d_{L}c^4}g^\varrho(r)	~.
\label{amplitude}
\eeq
Since this relies on several approximations it is not expected to exactly match the amplitude evolution for a real signal.
However, it is known that the 0PN Newtonian amplitude is a good approximation to the full signal in general relativity
	up until very close to the merger (\cite{Cutler:1992tc}).
A plot of the amplitude evolutions in pcGR and the 0PN Newtonian approximation are shown in Fig. (\ref{fig:amplitude})
	against a full inspiral-merger-ringdown waveform model in vacuum general relativity, SEOBNRv2 (\cite{Taracchini:2013rva}).

\begin{figure}
	\includegraphics[width=\columnwidth]{amp_evolution}
    \caption{The amplitude evolution of the inspiral with $b=0$ to leading order 0PN approximation (red)
	and with $b=16/27$ (black) to leading order in the modification, for the $n=2$ case.
	These are compared to the general relativity model SEOBNRv2 full gravitational waveform (blue)
    for a binary coalescence of near equal mass objects each with zero spin.
    The waveform is shown from an initial frequency of 30Hz,
    similar to the low frequency cutoff of the Advanced LIGO detectors during their first observation run
    and the amplitudes are matched there.
    The $b=0$ 0PN approximation with $b=0$ is seen to match better than the $b=16/27$ approximation,
    especially for the later inspiral cycles, just before the peak.}
    \label{fig:amplitude}
\end{figure}

It can be seen in the figure that the approximation based on $b=16/27$ begins to deviate noticeably from the GR model waveform several orbits before the peak amplitude.
A comparison of the measured gravitational wave amplitude against the predicted amplitude can constrain the luminosity distance to the source via equation (\ref{amplitude}).
However, the model should match the amplitude evolution for all values of the inspiral expansion parameter $M/r$ as the orbit evolves and the bodies approach one another.
It is not possible to compare amplitudes only at a single value of the expansion parameter as was suggested in \cite{Hess:2016gmh}.
Because pc-GR agrees with GR for sufficiently low values of $M/r$ where several cycles of the waveform are seen, the luminosity distance is required to be broadly consistent with the luminosity distance found by the LIGO team (\cite{Abbott:2016blz}),
	and the high redshift values found in \cite{Hess:2016gmh} for GW150914 are not consistent with the data,
	even within pseudo-complex general relativity.

\subsection{Phase evolution}

To obtain the phase evolution of the orbital motion and of the gravitational wave,
	it is useful to work in the frequency domain in the PN framework (to leading and next-to-leading orders).
Differentiating the Keplerian relation (\ref{Kepler2}) with respect to time, yields after some algebra
\beq
\label{w-r}
\left[ 3 - n (n\!+\!1) \, Q \, \gt \, \right] \frac{\dot{r}}{r} = -2 \frac{\dot{\w}}{\w} \, .
\eeq
and we can change from $r$ to $\w$ using eqns (\ref{Kepler2},\ref{w-r}),
\ba
r &=& \left[\frac{G M }{\w^2} \right]^{1/3}
		\left[	1 - \frac{(n\!+\!1)}{3} \, Q \, \gtw	\,	\right] \, ,																\\
\dot{r} &=& -\frac{2}{3}\frac{\dot{\w}}{\w} \, r \, \left[ 1 + \frac{n (n\!+\!1)}{3} \, Q \, \gtw	\, \right] \, ,
\ea
with
\beq
\gtw = \tilde{g} \left( r(\w) \right) = b \left( M \w\right)^{2n/3\,}	 ,	~~
g^\varrho(r) = 1- \varrho\,\gtw ~ .
\eeq
Hence instead of (\ref{energy balance full r}) we have
\ba
 \label{energy balance full w}
 \dot{\w} = \frac{96}{5} \frac{\left(G\Mc\right)^{5/3}}{c^5} \, \w^{11/3}
				\left[	1  - \IBw		\right]	 ,	\\
 \label{energy balance full f}
 \dot{f} = \frac{96}{5} \frac{ \pi^{8/3} \left(G\Mc\right)^{5/3}}{c^5} \, f^{11/3}
				\left[	1  - \IBw			\right]	 ,
\ea
as the new chirp equations, with the standard chirp mass $\Mc = \left( M^2 \mu^3 \right)^{1/5}$
and with $\gtw$ and numerical prefactors collected into the modification at $n$-PN $\IBw$,
\beq
\IBw = \left( \frac{(n\!+\!2) (n\!+\!1)}{3} Q + \varrho\right) b \,  (M\w)^{2n/3}~.
\eeq
We note also (\ref{energy balance full f}) in terms of the gravitational wave frequency
$f = \w/\pi$ (twice the orbital frequency),
with $\IBf = \IB (\w=\pi f)$.

We would like to relate this $\IBf$ modification to known bounds on PN coefficients.
We first plug equation (\ref{energy balance full f}) into the integrals for the time and for the phase (compare \cite{Cutler:1994ys})\footnote{
These forms must be trivially modified to apply to $n=2.5,4$
	where the integrals for $\phi$ and $t$ respectively give logarithms of $\pi M f$ rather than its powers.
},
\ba
t 	&=& \!\! t_c + \int \frac{\df}{\dot{f}}																					\nonumber\\
	&=& \!\! t_c - \frac{5 \, c^5 \, \left(\pi f \right)^{-8/3}} {256 \left(G\Mc \right)^{5/3}}
			\left[ 1 - \frac{4}{n-4} \IBf \right]
 \, ,~~~~~~																												\\
\phi &=& \!\! 2\pi \int \! f \, dt = 2\pi \int \!\! \frac{f}{\dot{f}}  \df													\nonumber\\
	&=& \!\! - \frac{c^5}{16 \left(\pi G\Mc f\right)^{5/3}} \left[ 1 - \frac{5}{2n -5} \IBf \right]
 \, ,~~~~~~
\ea
and then use these with the stationary phase approximation (\cite{Cutler:1994ys}) to find
\ba
\Psi
&=& \!\!\! 2\pi f t_c - \phi_c - \pi/4		\\
	&&\!\!\!+ \frac{3 }  {128 \left(\pi G \Mc f \right)^{5/3} }
		\left[ 1 + \frac{20}{\left(n -4\right)\left(2n -5\right)} \IBf \right]	\, .	\nonumber
\ea

This form can be compared directly to the expected PN coefficients in GR of \cite{Buonanno:2009zt}
	(following \cite{Iyer:1993xi, Will:1996zj, Blanchet:2000nv}),
	and to the limits set on deviations from them
	by the observed gravitational waves in the inspiral regime in \cite{TheLIGOScientific:2016pea, TheLIGOScientific:2016src}
	(based on \cite{Talmadge:1988qz, Mishra:2010tp, PhysRevD.85.082003}).
This comparison is summarized in Table \ref{PN table},
	for the leading pc-GR PN terms for $n=1,2,3$ and the corresponding GR PN phase coefficients of orders $1,2,3$.
All coefficients are calculated for the fiducial equal mass non-spinning case ($q=1$, $a=0$);
	the pc-GR coefficients are calculated for the critical $b_{\mathrm{maxH}}$ value of equation (\ref{bmaxH}), where the horizon vanishes,
	and for $\varrho=0$.
The table also compares to the 90\% bounds set on the relative deviations $(p_n^{\rm mod-GR} - p_n^{GR})/p_n^{GR}$
	established in LIGO's first observation run O1.
This comparison provides independent evidence to show that non-existence of horizons for $n=1$ pc-GR
	is inconsistent with observed gravitational wave events in O1,
	and the first evidence to rule out their possibility in $n=2$ pc-GR as well.

\begin{table}
  \centering \caption{pc-GR PN coefficients}
\begin{center}
\begin{tabular}{cccccccc}
  \hline

  $n$	& $\rmin$	& $b_{\rm crit}$	& $p_n^{\rm pc-GR}$	& $p_n^{\rm GR}$	& $\delta_\phi$	& $range(\delta_\phi)$ \\  \hline
  1		& 1			& 0.5				& 20/9						& 6.44					& $34\%$			& $(-20\%, 5\%)$	\\
  2		& $4/3$		& 16/27			& 320/27					& 46.2					& $26\%$			& $(-130\%, 15\%)$ \\
  3		& 1.5			& 27/32 			& -225/8					& -652					& $4.3\%$		& $(-100\%, 600\%)$	\\
\hline
\label{PN table}
\end{tabular}
\end{center}
\end{table}

Conversely, the limits on the deviations of PN coefficients can be translated to limits on $b$,
	which for $n=1,2,3$ are $|b|\leq 0.85, 2.96, 118$ respectively.
This suggests that $b \left(\pi M f \right)^{2n/3}$ is indeed a small parameter throughout the system's evolution,
	and that hence the introduction of the pc-GR modifications should not produce large deviations from the
	standard GR post-Newtonian inspiral, and in particular should not largely affect the chirp mass $\Mc$.
For the GW150914 data, estimating the chirp mass from directly from $f$ and $\dot{f}$ at different inspiral times
	using the Newtonian approximation (0PN, $b=0$)
	shows it remains approximately constant up to a frequency of $\sim150Hz$ (\cite{Abbott:2016bqf}),
	and is equal to roughly 30 solar masses.
This corresponds to $\left(\pi M f \right)^{2/3} \sim 0.17$,
	consistent with treating $\IBf$ only at leading order,
	and inconsistent with the much larger modified chirp mass (and correspondingly higher redshift)
	estimated in \cite{Hess:2016gmh} from the late part of the orbit.

\subsection{Testing a previous model}
As mentioned through the text, the model of \cite{Hess:2016gmh} can be considered under our formalism
	as the case $n=2$, $Q=1$, $Q_2=0$, $\varrho=1$.
For the critical value of $b=16/27$,
	this changes the leading coefficient $p_2^{\rm GR}$ from $320/27$ to $800/27$,
	which changes $\delta_\phi$ from $26\%$ to $65\%$ of the GR value.
As Table \ref{PN table} indicates,
	this value is well beyond the range observed and reported by LIGO's O1,
	and so this model pc-GR also cannot sustain horizonless objects as the sources of LIGO's detections.

\section{Conclusions}

We have shown how the model of pseudo-complex general relativity can be constrained
	using gravitational wave observations.
These observations are very much independent of and complementary to observations
	with other techniques that have previously been proposed,
	such as accretion disk studies and imaging of super-massive black holes.
For two merging compact objects,
	gravitational wave observations provide strong constraints on the near horizon behaviour
	from both the inspiral phase and the final ringdown after merger.
In particular we have seen that the ringdown phase,
	modeled in terms of the light ring structure within pc-GR,
	typically requires the final object after merger to be slightly heavier and spinning slightly slower
	than is found using Einstein's GR.
However, the Newtonian limit of pc-GR requires the chirp mass
	to be broadly consistent with the values found using Einstein's GR,
	and this bounds both the total mass and luminosity distance
	to be broadly consistent with those found using Einstein general relativity.

We have discussed the model in terms of a dimensionless parameter $b$ and power index $n$ in equation (\ref{modified mass}).
For sufficiently large values of $b$ objects can be horizonless.
We find that horizonless objects in the $n=1$ case are already ruled out,
	independently of other Solar System constraints (\cite{Will2006}).

For the critical case with $n=2$ and $b=16/27$ discussed in \cite{Hess:2016gmh}
	we find that the final object can only fit the ringdown with a frequency in the range observed in \cite{TheLIGOScientific:2016src} if the spin value is close to zero.
Larger spin values require lower values of $b$ and hence, if $b$ is universal,
	allow non-spinning black holes with horizons.
In the inspiral regime, the case of $n=2$ and $b=16/27$ is also in tension with the data.
The model suggests a noticeable fall-off in the amplitude which is not seen in the data \cite{Abbott:2016bqf},
	and the inspiral phasing is in conflict with detailed fits of the post-Newtonian parameters (\cite{TheLIGOScientific:2016pea}).

For values of $n$ larger than 2 the situation is not so clear.
As the value of $n$ is increased in the model, the corrections of the model are constrained to smaller and smaller distances.
For $n=3$ the leading order correction from pseudo-complex general relativity is a 3PN term and this term is less tightly constrained by current LIGO observations.
Higher terms at 4PN and beyond are not yet fully calculated in general relativity so a direct comparison with these terms is not yet possible.

Our conclusions are only valid to the extent of the approximations that have been made in deriving the model of \cite{Caspar:2012ux}.
The parameters $b$ and $n$ are assumed constant and apply equally to the pre-merger inspiral phase as to the post-merger ringdown.
Little is known about how pseudo-complex general relativity behaves in the highly dynamical merger phase and our results cannot address this part of the LIGO observations.
This is ultimately likely to require, as in the case of vacuum Einstein relativity, numerical solutions to the field equations.
Further work is also required to understand exactly how the features of pseudo-complex coordinates should be implemented in a gravitational theory, but this is beyond the scope of this work.

We have deliberately interpreted the pseudo-complex relativity model slightly differently from \cite{Hess:2016gmh}.
We have explicitly mapped the vacuum solution of pseudo-complex general relativity to an equivalent problem of what would be a non-vacuum spacetime in Einstein relativity.
This enables us to relate the techniques more generally.
Aside from pseudo-complex general relativity,
	this analysis can also be applied to dirty black holes,
	and a similar analysis of PN effects has been pursued for dark matter minispikes (\cite{Eda:2014kra}).
Thus it is hoped that the techniques here described may find application beyond the specific scope of testing pseudo-complex general relativity.

\section*{Acknowledgements}

We thank P. O. Hess and the LIGO TestingGR working group for useful conversations and correspondance.

\bibliographystyle{mnras}

redpajama_set_name: RedPajamaArXiv


I want to begin by acknowledging to everyone what a great job the National Weather Service did with Hurricane Florence.
And, the forecasts and messaging for Florence from the entire meteorological community represented a huge step forward.
Florence also demonstrated the minority of people who believe we can take human meteorologists out of the process are wrong, very wrong. Some of the computer models were way off early in the process yet human forecasters knew how to correct for those issues. We are going to need human forecasters, especially in storm or unusual circumstances, as far into the future as I can see.
Regardless of that huge step forward, there were a vocal few people who were upset -- some very upset -- about the television, WEA, and Twitter warnings for Hurricane Florence.
Those are a couple of the civil tweets. Some were downright mean.
While I know we cannot please everyone, I'm not sure these people people want. The forecasts, including that it would take days for all of the rivers to crest, were excellent. See here and here.
The issue I have is that first responders have to go in, risking their lives, to rescue these skeptics.
A fine of $500/household if rescued by boat.
Fine of $1,000 if rescued by a helicopter.
The death toll of 33, while tragic, is tiny when compared with the Florence's potential. Combine that number with the 900+ rescues so far plus the fact that most people evacuated and you can easily imagine a death toll of 1,000+ had the forecasts been off.
Weather science likely saved 1,000+ deaths in Florence. Regardless of location, go buy your favorite meteorologist a beer or send them a congratulatory note. It will be greatly appreciated.
Note that I am not congratulating the climate community. The behavior of some during Florence was disgraceful: trying to politically tie Florence to President Trump or global warming. Dr. Judith Curry -- an expert in the field -- published a piece on her blog yesterday agreeing that there is little evidence to tie Florence to global warming. Her conclusion is below. Her entire piece is here.
I've scratched the surface of the complex issues surrounding the weather and climate dynamics of Florence, but the take home point is that convincingly attributing any of this to human caused global warming is very challenging, and the strategies used by the mainstream climate community to do this ... are woefully inadequate and misleading to scientists, the public and policy makers.
Dr. Curry is not the only one. Here is an excerpt of a Letter to the Editor of Nature which was part of the "global warming caused/made worse Hurricane Florence" crowd. This will get a tiny fraction of the publicity than the original, unscientific claims.
Global warming has contaminated the field of atmosphere science, to which I have given my career, and it saddens me greatly.


The PUII reduces up to 99% of chlorine, ammonia, lead, giardia cyst, cryptosporidium, unpleasant taste & odour. Also available in 0.01 micron.
Aluminium, chlorine, copper, iron, lead, mercury, bacteria, cholera, cyct, cryptosporidium, E. coli bacteria, salmonella, taste & odour.
To order our Twin Undersink System or if you have questions for our staff, please contact us.


text:
Home/THEATRE/The 60's are Alive and Well and in Psychedelic Color at Signature Theatre
The 60's are Alive and Well and in Psychedelic Color at Signature Theatre
Zebra Send an email March 10, 2017
By Sara Dudley Brown
Debra Monk warming up her "chords" for a recording session as Mrs. Miller in Signature Theatre's "Mrs. Miller Does Her Thing." (Photo by Margot Shulman)
One of my favorite actresses, Debra Monk, stars as Mrs. Elva Miller in a world premiere production of "Mrs. Miller Does Her Thing," at Signature Theatre in Shirlington, Va. If you enjoyed Debra Monk in some of her Emmy and Tony award winning performances such as "Grey's Anatomy," "Mozart in the Jungle," and her many Broadway and off-Broadway productions, you will absolutely love her in this truly extraordinary role. This affectionate account of a few pivotal years in Mrs. Miller's life is beautifully written and touchingly directed by James Lapine ("Sunday in the Park with George" and "Into the Woods").
Boyd Gaines (left) and Debra Monk (right) as Mr. and Mrs. Miller making light of an uncomfortable living situation in the hilarious and touching "Mrs. Miller Does Her Thing," Signature Theatre's current offering. (Photo by Margot Shulman)
"Mrs. Miller Does Her Thing" is also an evocative, startlingly accurate and somewhat disturbing portrayal of the era and times (the mid-1960's) of one Elva Miller, who actually lived, was said to be a somewhat classically trained singer and who, up to this point in her life, went about singing her church songs, taking care of her seriously ailing husband, and existing in a sort of a dreamy 50's haze. Maybe you remember her? I do, but just barely.
"These Boots are Made for Walkin'," with Debra Monk as Mrs. Elva Miller and dancers from left, Kimberly Marable as Denise Banfield, Jacob ben Widmar as Bobby Sherin, and Kaitlyn Davidson as Carol Sue Singleton. (Photo by Margot Shulman)
This production is based on the story of a woman who is plucked from total obscurity and thrown into a world she simply didn't understand by people who only wanted to profit from her "funny" overwrought sound. They found if they teamed her with cutting edge (of the day) singers and musicians, and kept her in the dark about what they were actually doing and why audiences were howling, they could laugh all the way to the bank. It was over in just three years.
During that time Mrs. Miller recorded covers of hits by some of the leading singers of the day, including the Beatles, Petula Clark, and Nancy Sinatra. Mrs. Miller's cover of Nancy Sinatra's song, "These Boots are Made for Walkin'," as performed by Debra Monk with every word over-articulated while wearing an iconic 60's fringed green striped dress and white go-go boots, brought down the house.
Additionally, we are treated to some wonderful backup singing and dancing by Jacob ben Widmar, Kaitlyn Davidson, and Kimberly Marable, as well as terrific performances by Boyd Gaines, whom I will never forget in "Gypsy" on Broadway, and the marvelous Will LeBow, playing seven, count'em seven, singular roles! Rebekah Brockman as Joelle, Mrs. Miller's niece, is totally believable, maddening, and touching, as is Corey Mach as Simon Bock, Mrs. Miller's young producer, who gets sucked into drugs and the promise of easy money.
If you are interested in visiting a little history of the mid-sixties (1966-68) and that turbulent time of great anger, pushback, and change, this is the shop for it! However, if you weren't there, you may miss some of the more pointed references to things like Patchouli Oil (it was thought to be an antidepressant and an aphrodisiac) the SDS, and other Viet Nam era in-jokes.
Green brownies and tea. Yum! Wait, green brownies? From left: Debra Monk and Will LeBow. (Photo by Margot Shulman)
Speaking of the 60's, the sets by Heidi Ettinger are right on, evoking the stark reality of the no frills recording studios of the day, as well as the sad nursing home situation of Mrs. Miller's husband. The sensational costumes by Jennifer Caprio, the inventive spot-on choreography by Josh Prince, and the four piece band, ably led by Matt Hinkley, are simply marvelous. With co-conceiver Mark Oliver Everett; orchestrations by Michael Starobin; lighting by Jeff Croiter; sound by Ryan Hickey; wigs and makeup by J. Jared Janas; production stage manager Kerry Epstein; and assistant stage manager Allie Roy.
About an hour and 45 minutes. Tickets: $40-99. Through March 26 at Signature Theatre, 4200 Campbell Ave., Arlington, VA. Visit sigtheatre.org or call 703-820-9771.
Allie Roy Boyd Gaines Carol Sue Singleton Corey Mach Debra Monk Denise Banfield Heidi Ettinger J. Jared Janas Jacob ben Widmar James Lapine Jeff Croiter Jennifer Caprio Josh Prince Kaitlyn Davidson Kerry Epstein Kimberly Marable Margot Shulman Mark Oliver Everett Matt Hinkley Michael Starobin Mrs. Miller Does Her Thing Rebekah Brockman Ryan Hickey Sara Dudley Brown Signature Theatre Will LeBow
Freshman at SSSAS Makes All-State Band
Cadet Pessaud at Fork Union Military Academy Qualifies for National Debate Meet
Tickets Available: Unique Dance and Music Collaboration in Alexandria, November 12
A Stunning World Premiere at the New Capital One Hall in Tysons
Audience Wowed by Singer Danielle Talamantes, Composer Henry Dehlinger, and The National Philharmonic World Premiere at New Capital One Hall in Tysons
"Fences" at Little Theatre of Alexandria is Strong and Absorbing


Items where Author is "Nur Syuhada Farhana , A Zahari"
Nur Syuhada Farhana , A Zahari (2017) Interlingual subtitling of nonsensical words, phrases and utterances in the movie Alice in Wonderland / Nur Syuhada Farhana A Zahari. Masters thesis, University of Malaya.
This list was generated on Mon Apr 22 23:01:53 2019 MYT.


The City of Amarillo and the Amarillo Economic Development Corporation (Amarillo EDC) believe that a comprehensive economic development strategy, supported and shared by both entities, can organize community goals into actionable steps, delineate responsibilities among stakeholders and provide a clear timeline for the execution of efforts.
For this reason, in November of 2016, the City of Amarillo and the Amarillo EDC agreed to co-fund a contract awarded to Avalanche Consulting, in cooperation with CDS, to develop an Economic Development Strategic Plan for the community. The seven month process to complete the strategy is estimated to be completed in June 2017.
During this in depth process there will be multiple trips to the Amarillo region, various stakeholder engagement events such as interviews, focus groups and public forums where we will ask the citizens of Amarillo to participate in discussions about Amarillo's economic future. Join us in this discussion to help shape the future of Amarillo and the High Plains.


text:
More championship pages Home 2019 Results Past Winners
R&A Girls Home Internationals
The R&A Girls Home Internationals was first played in 1935.
The championship is an annual event played over three days featuring teams from England, Ireland, Scotland and Wales.
2018 R&A Girls Home Internationals Champions
England won the R&A Girls Home Internationals after a final day victory at Ballybunion, Ireland.
Downfield Golf Club
7-9 August 2019
The R&A Girls Home Internationals will be played at Downfield from 7-9 August 2019. Having hosted the event in 2000, the beautiful parkland venue in the city of Dundee will again welcome leading girl amateurs from across GB&I. In 2016, Downfield was also chosen as a qualifying course for the Senior Open which was played at Carnoustie.
In 2016, Downfield was also chosen as a qualifying course for the Senior Open which was played at Carnoustie. In the past, it has also played host to other prestigious events such as the Scottish PGA Open, the SPGA Masters and the Scottish Amateur Championship. It was also the venue for the 1999 and 2007 Open Qualifying stage.
Turnberry Avenue
Teams from England, Ireland, Scotland and Wales compete against each other in individual matches.
A match consists of three foursomes and six singles, each over the same 18 holes, with the foursomes being played first.
The scores are calculated by team results with each team scoring one point for a team win and half a point for a halved match.
If two or more countries score an equal number of team points and have each won the same number of individual games, the tie will be resolved by aggregating the number of holes played in the individual games won and the team with the fewest number of holes played is declared the winner.
The first R&A Girls Home International Match was played in 1935.
The teams from England, Scotland, Ireland and Wales compete for the Stroyan Cup.
Since 2008, England have won every staging of the R&A Girls Home Internationals - other than Ireland's victory in 2016.


The University of Perpetual Help System DALTA was founded on 5 February 1975 with its former name- The Perpetual Help College Rizal (PHCR) by Dr. /BGen. Antonio Laperal Tamayo and Dr Daisy Moran Tamayo.
Initially, it catered to 185 students with the Nursing and secondary course. The school expanded its 2 branches in 1995 and 1996- the Molino & Calamba campuses. Now the University has acquired the 45 years of proven quality of medical education.
Today, UPHSD is putting efforts to achieve its objective of maintaining and sustaining excellence in education. It has an integrated extensive network of national and international collaborations in higher education and business.
The University of Perpetual Help System DALTA is now emerging as a leading University of Philippines as it is the perfect venue for the pursuit of excellence in academics, technology and research through local and international association. It has received many awards from the Philippine Association of Colleges and Universities Commission on Accreditation (PACUCOA) in recognition of its quality education at an affordable cost.
UPHSD relies on a mission of producing the Perpetualites as "Helpers of God" by delivering medical education to all the medical aspirants coming from different corners of the world.
The University has established and maintained the local and international linkages with prestigious institutions and Hospitals.
University has a name in imparting quality education for MD (Doctor of Medicine) in the Philippines through Jonelta Foundation School of Medicine (estd. in 1996). The University also provides the opportunity of Internship at the University of Perpetual Help Dalta Medical Center (UPHDM). University has a 100% passing rate of graduates for USMLE.
Faculty members of the University are graduates of reputed International Universities like Harvard University, University of London, UCLA, etc., with masteral & doctoral degrees in education, epidemiology and social sciences.
University provides assistance in providing accommodation facilities to all its students. It makes sure that hostels are equipped with all the basic amenities required for comfortable living and guarded with safety & security measures.
University has a Supreme Student Council for empowering students and gearing them towards self-reliance. Students participate and enjoy in civic & social affairs, harnessing pure Filipino culture.
University of Perpetual help foresees the students enjoying a quality of life in abundance, living in peace and building a nation that the coming generation will nourish, cherish and value.
University has a collaborative venture of University's Library and Media centre that ensures that teachers, school and administrators work together to provide opportunities for social, cultural and educational growth of students.
Las Pinas, officially known as the City of Las Pinas; is a first-class urbanized city of Philippines, situated in Metro Manila region.
Las Pinas gained the city title in 1997, as before it was one of the first settlements on the outskirts of Manila.
Las Pinas has a tropical climate. In winters, there is much less rainfall than in summer.
Economy of the city lies within Salt-Making Industry and Agriculture.
Every year, a food festival is organized in Las Pinas city and the famous food chains of the city are Juncel Food corner, Fresh and Famous Foods, Mang Raul's BBQ, etc.


The Storie House serves to create an environment where love can restore. Our vision for the home is that it will provide every woman the opportunity to achieve the fresh start she desires.
The Storie House is a private residence that can support and nurture five women from our program and up to four children, as well as provide a safe, sober place to live and integrate new life skills. This new addition will be overseen by Judy Clark, our Director of Women's Services.
The home's namesake comes from our Board Member Nancy Storie and is inspired by her generosity and dedication to the women in our program.


Welcome to the latest edition of the NAB Charitable Giving Index.
Donations growth has improved since our last report. Giving to charity grew 1.4% over the year to August 2017, after falling -1.0% over the year to February 2017. In a longer term context, charitable giving has grown by around 37% since NAB first started compiling this report in 2010.
The latest results suggest that the downturn in charitable giving growth that began in early 2016 may have finally bottomed, with growth turning up since March 2017.
Looking forward, donors face headwinds from high household debt levels, slow wages growth and high utility prices, all of which may impact their desire to spend. But as wages growth slowly inches up and unemployment improves, we hope to see further growth in charitable donations.
In this latest edition, you will find detailed state data, including market share, average donation size, growth by charity sector and the most generous postcodes.
We hope this report helps charities to make better informed decisions and raise more money.