#include <iostream>
#include <cmath>
#include <vector> 
#include <algorithm>
#include <chrono>
#include <random>
#include <atomic>
#include <stdio.h>

#define NUM_STREAMS 2

using namespace std;

mt19937 rng;
random_device rd;
__managed__ int n, l, r, s;


class Particle
{ 
	public: 
		operator string() const { 
			char buffer [200];
			snprintf(buffer, 200, "%d %.8lf %.8lf %.8lf %.8lf", i, x, y, vX, vY); 
			return buffer;
		}

		int i;
		double x;
		double y;
		double vX;
		double vY; 
		int pColl;
		int wColl;

		Particle() {};

		Particle(int i, double x, double y, double vX, double vY, int l) 
		{
			this -> i = i;
			this -> x = x;
			this -> y = y;
			this -> vX = vX;
			this -> vY = vY;
			this -> pColl = 0;
			this -> wColl = 0;
		}
		__device__ __host__ int getIndex()
		{
			return this->i;
		}
		
		string getFullRepresentation()
		{
			
			char buffer[200];
			snprintf(buffer, 200, "%d %.8lf %.8lf %.8lf %.8lf %d %d", i, x, y, vX, vY, pColl, wColl); 
			string res(buffer);
			return res;
		}
}; 


class CollisionEvent 
{
	public:
		const static int WALL = 0;
		const static int PARTICLE = 1;
		const static int NONE = 2;

		Particle* first;
		Particle* second;
		double time;
		int type;

		__host__ __device__ bool operator == (CollisionEvent other)
		{
			int firstIndex = (*this->first).getIndex();
			int otherFirstIndex = (*other.first).getIndex();
            if (this->second != nullptr)
			{
				int secondIndex = (*this->second).getIndex();
				int otherSecondIndex = (*other.second).getIndex();
		        return (firstIndex == otherSecondIndex && secondIndex == otherFirstIndex) ||
					(firstIndex == otherFirstIndex && secondIndex == otherSecondIndex);
			}
			return (firstIndex == otherFirstIndex);
		}


		__host__ __device__ bool operator < (CollisionEvent other)
		{
			if (this->time == other.getTime()) return this->getSmallestIndex() > other.getSmallestIndex(); 
			return this->time > other.getTime();
		}

		__host__ __device__ CollisionEvent() {}

		__host__ __device__ virtual ~CollisionEvent() {}

		// wall collision event
		__host__ __device__ CollisionEvent(Particle* first, double time)
		{
			this->first = first;
			this->second = nullptr;
			this->time = time;
			this->type = this->WALL;
		}

		// particle collision event
		__host__ __device__ CollisionEvent(Particle* first, Particle* second, double time)
		{
			this->first = first;
			this->second = second;
			this->time = time;
			this->type = this->PARTICLE;
		}

		// no collision event
		__host__ __device__ CollisionEvent(Particle* first)
		{
			this->first = first;
			this->second = nullptr;
			this->time = 1.0;
			this->type = this->NONE;
		}

		__host__ __device__ double getTime()
		{
			return this->time;
		}

		__host__ __device__ int getType()
		{
			return this->type;
		}

		__host__ __device__ double getSmallestIndex()
		{
			if (this->second != nullptr)
			{
				return (*first).getIndex() < (*second).getIndex() ? (*first).getIndex() : (*second).getIndex();
			}
			return (*first).getIndex();
		}
};


// cuda streams
cudaStream_t streams[NUM_STREAMS];

// particle objects
__managed__ Particle* particles;

// collision times
__managed__ double** particleCollisionTimes;
__managed__ double* wallCollisionTimes;

// collision events
__managed__ CollisionEvent* temp;
__managed__ int* found;

__managed__ CollisionEvent** particleCollisions;
__managed__ int particleCollisionsCount;

__managed__ CollisionEvent** wallCollisions;
__managed__ int wallCollisionsCount;

__managed__ CollisionEvent** noCollisions;
__managed__ int noCollisionsCount;

// function headers
__host__ void moveParticles(Particle* particles);
__global__ void findEarliestCollision();
__global__ void timeParticleCollision();
__global__ void timeWallCollision();
__global__ void executeParticleCollision();
__global__ void executeWallCollision();
__global__ void executeNoCollision();

__host__ int main (void)
{
	string command;
	cin >> n >> l >> r >> s >> command;

	rng.seed(rd());
	uniform_real_distribution<double> pos(r, l-r);
	uniform_real_distribution<double> velocity((double)l/(8*r), (double)l/4);
	cudaError_t cudaStatus = cudaMallocManaged(&particles, sizeof(Particle) * n);
	int scanned;
	for (scanned = 0; scanned < n; ++scanned)
	{
		int index; 
		double x;
		double y;
		double vX;
		double vY; 
		int count;
		count = scanf("%d %lf %lf %lf %lf", &index, &x, &y, &vX, &vY);
		if (count == EOF || count <= 0) break;

		particles[scanned] = Particle(index, x, y, vX, vY, l);
	}
	for (int j = scanned; j < n; j++)
	{
		double x = pos(rng);
		double y = pos(rng);
		double vX = velocity(rng);
		double vY = velocity(rng);
		particles[scanned] = Particle(j, x, y, vX, vY, l);
	}


	for (int i = 0; i < NUM_STREAMS; ++i) 
	{
		cudaStreamCreate(&streams[i]);
	}
	cudaMallocManaged(&particleCollisionTimes, sizeof(double*) * n);
	for (int i = 0; i < n; ++i)
	{
		cudaMallocManaged(&particleCollisionTimes[i], sizeof(double) * n);
	}
	cudaMallocManaged(&wallCollisionTimes, sizeof(double) * n);
	cudaMallocManaged(&found, sizeof(int) * n);
	cudaMallocManaged(&particleCollisions, sizeof(CollisionEvent*) * n);
	cudaMallocManaged((void**) &particleCollisionsCount, sizeof(int));
	cudaMallocManaged(&wallCollisions, sizeof(CollisionEvent*) * n);
	cudaMallocManaged((void**) &wallCollisionsCount, sizeof(int));
	cudaMallocManaged(&noCollisions, sizeof(CollisionEvent*) * n);
	cudaMallocManaged((void**) &noCollisionsCount, sizeof(int));
	cudaMallocManaged(&temp, sizeof(CollisionEvent) * n);

	auto start = chrono::high_resolution_clock::now();
	for (int i = 0; i < s; ++i)
	{
		if (!command.compare("print"))
		{
			for (int j = 0; j < n; ++j)
			{
				cout << i << " " << (string) particles[j] << endl;
			}
		}
		moveParticles(particles);
	}

	auto finish = std::chrono::high_resolution_clock::now();
	for (int j = 0; j < n; ++j)
	{
		cout << s << " " << particles[j].getFullRepresentation() << endl;
	}
	double timeTaken = (double)chrono::duration_cast<chrono::nanoseconds>(finish-start).count()/1000000000;
	// printf("Time taken: %.5f s\n", timeTaken);
	return 0;
}


__host__ void moveParticles(Particle* particles) 
{
	for (int i = 0; i < n; ++i) found[i] = -1;
	particleCollisionsCount = 0;	
	wallCollisionsCount = 0;
	noCollisionsCount = 0;
	
	// calculate collision times
	timeWallCollision<<<(n-1)/64+1, 64, 0, streams[0]>>>();
	
	dim3 threadsPerBlock(16, 16, 1);
	dim3 blocksPerGrid((n-1)/16 + 1, (n-1)/16 + 1);
	timeParticleCollision<<<blocksPerGrid, threadsPerBlock, 0, streams[1]>>>();

	cudaDeviceSynchronize();
	
	// find valid collisions
	int foundCount = 0;
	while (foundCount != n)
	{  
		findEarliestCollision<<<(n-1)/64+1,64>>>();
		cudaDeviceSynchronize();
		for (int i = 0; i < n; ++i)
		{
			if (found[i] != -1) continue;
			CollisionEvent* e = &temp[i];
			// particle-particle collision
			if ((*e).getType() == CollisionEvent::PARTICLE)
			{
				int otherIndex = (*(*e).second).getIndex();
				if (temp[otherIndex].getType() == CollisionEvent::PARTICLE)
				{
					if ((*e) == temp[otherIndex] && i < otherIndex) 
					{
						found[i] = 0;
						found[otherIndex] = 0;
						foundCount += 2;
						particleCollisions[particleCollisionsCount++] = e;
					}
				}
			}
			// particle-wall collision
			else if ((*e).getType() == CollisionEvent::WALL)
			{
				found[i] = 0;
				++foundCount;
				wallCollisions[wallCollisionsCount++] = e;
			}
			// no collision
			else
			{
				found[i] = 0;
				++foundCount;
				noCollisions[noCollisionsCount++] = e;
			}
		}
	}

	// apply valid collisions
	executeParticleCollision<<<(particleCollisionsCount-1)/64+1, 64, 0, streams[0]>>>();
	executeWallCollision<<<(wallCollisionsCount-1)/64+1, 64, 0, streams[1]>>>();
	executeNoCollision<<<(n-1)/64+1, 64, 0, streams[1]>>>(); 
	cudaDeviceSynchronize();
}

__global__ void findEarliestCollision()
{
	int index = blockIdx.x * blockDim.x + threadIdx.x;

	if (index >= n || found[index] != -1) return;
	// first assume no collision
	temp[index] = CollisionEvent(&particles[index]);

	// check for particle-wall collision
	if (wallCollisionTimes[index] < temp[index].getTime() && wallCollisionTimes[index] < 1)
	{
		temp[index] = CollisionEvent(&particles[index], wallCollisionTimes[index]);
	}

	// check for particle-particle collision
	for (int j = 0; j < n; ++j)
	{
		if (index == j || found[j] != -1) continue;
        double time = particleCollisionTimes[index][j];

		if (time > -1 && time < temp[index].getTime() && time < 1) {
			temp[index] = CollisionEvent(&particles[index], &particles[j], time);
		}
	}

}


// "input": 2 Particles
// "output": Returns time taken before collision occurs if they collide, negative value otherwise.
__global__ void timeParticleCollision()
{
	int firstIndex = blockIdx.x * blockDim.x + threadIdx.x;
	int secondIndex = blockIdx.y * blockDim.y + threadIdx.y;
	if (firstIndex >= n || secondIndex >= n || firstIndex >= secondIndex) return;
	else
	{
		Particle first = particles[firstIndex];
		Particle second = particles[secondIndex];
		//a, b and c are as in the quadratic formula representation.
		//t, the time taken for the 2 circles to touch, is the unknown variable we are solving for
		//by taking difference in circle centres, setting an unknown t for collision time, and then taking distance moved in time t,
		//we can solve for t such that the circle centers are <= 2r and therefore collide. 4r^2 is to solve for radius distance.
		double c = pow((first.x-second.x), 2) + pow((first.y - second.y), 2) - 4*r*r;
		double b = 2*((first.x - second.x)*(first.vX - second.vX) + (first.y - second.y)*(first.vY-second.vY));
		double a = pow((first.vX-second.vX), 2) + pow((first.vY - second.vY), 2);
		//check for solution
		double solfirst;
		if (b*b-4*a*c < 0)
		{
			solfirst = 100000.0;
		} 
		else
		{
			//else if there is a solution, the one with smaller value should be the main collision. Second value is after the 2 circles phase through each other
			solfirst = (-sqrt(b*b-4*a*c)-b)/(2*a);
			if (solfirst < 0)
			{
				solfirst = (sqrt(b*b-4*a*c)-b)/(2*a);
				if (solfirst > 0) solfirst = 0;
				else solfirst = 100000.0;
			}
		}
		particleCollisionTimes[first.i][second.i] = solfirst;
		particleCollisionTimes[second.i][first.i] = solfirst;
	}
}

// "input": 1 Particle
// "output": Returns time taken before collision occurs if it collides with wall, negative value otherwise.
__global__ void timeWallCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex >=n) {
		return;
	}
	else
	{
		Particle particle = particles[particleIndex];
		//check for x wall, y wall collisions
		double xCollide = particle.vX < 0 ? (particle.x-r)/(0-particle.vX) : ((double)l-particle.x-r)/particle.vX;
		double yCollide = particle.vY < 0 ? (particle.y-r)/(0-particle.vY) : ((double)l-particle.y-r)/particle.vY;
		wallCollisionTimes[particle.i] = fmin(xCollide, yCollide);
	}
}

__global__ void executeParticleCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex < particleCollisionsCount)
	{
		CollisionEvent *e = particleCollisions[particleIndex];
		Particle *first = e->first;
		Particle *second = e->second;
		double time = e->time;
		if (first->getIndex() >= second->getIndex())
			return;
		//move them to proper position first
		first->x += time * first->vX;
		first->y += time * first->vY;
		second->x += time * second->vX;
		second->y += time * second->vY;

		//perform collision here
		//find normal vector
		double normalX = first->x - second->x;
		double normalY = first->y - second->y;
		double normalMag = sqrt(pow(normalX, 2) + pow(normalY, 2));
		normalX = normalX/normalMag; normalY = normalY/normalMag;
		double tangentX = -normalY;
		double tangentY = normalX;
		//compute velocity vectors wrt to normal and tangent
		double vFirstNormal = normalX * first->vX + normalY * first->vY;
		double vFirstTangent = tangentX * first->vX + tangentY * first->vY;
		double vSecondNormal = normalX * second->vX + normalY * second->vY;
		double vSecondTangent = tangentX * second->vX + tangentY * second->vY;
		//collision simply swaps velocities
		double temp = vFirstNormal;
		vFirstNormal = vSecondNormal;
		vSecondNormal = temp;
		first->vX = vFirstNormal * normalX + vFirstTangent * tangentX;
		first->vY = vFirstNormal * normalY + vFirstTangent * tangentY;
		second->vX = vSecondNormal * normalX + vSecondTangent * tangentX;
		second->vY = vSecondNormal * normalY + vSecondTangent * tangentY;
		//eliminate negative 0s
		if (first->vX == -0.0) first->vX = 0.0;
		if (first->vY == -0.0) first->vY = 0.0;
		if (second->vX == -0.0) second->vX = 0.0;
		if (second->vY == -0.0) second->vY = 0.0;
		//Continue to move them here
		//Check for wall collisions and stop the particle at wall if so
		double timeToMove;
		double xCollide = first->vX < 0 ? (first->x-r)/(0-first->vX) : ((double)l-r-first->x)/first->vX;
		double yCollide = first->vY < 0 ? (first->y-r)/(0-first->vY) : ((double)l-r-first->y)/first->vY;
		if (xCollide >= 1-time && yCollide >= 1-time) 
		{
			timeToMove = 1-time;
		}
		else
		{
			timeToMove = fmin(xCollide, yCollide);
		}
		first->x += timeToMove * first->vX;
		first->y += timeToMove * first->vY;
		
		xCollide = second->vX < 0 ? (second->x-r)/(0-second->vX) : ((double)l-r-second->x)/second->vX;
		yCollide = second->vY < 0 ? (second->y-r)/(0-second->vY) : ((double)l-r-second->y)/second->vY;
		if (xCollide >= 1-time && yCollide >= 1-time) 
		{
			timeToMove = 1-time;
		}
		else
		{
			timeToMove = fmin(xCollide, yCollide);
		}
		second->x += timeToMove * second->vX;
		second->y += timeToMove * second->vY;
		first->pColl++;
		second->pColl++;
	}
}

__global__ void executeWallCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex < wallCollisionsCount)
	{
		CollisionEvent *e = wallCollisions[particleIndex];
		Particle *first = e->first;
		//check for x wall collisions
		//check for y wall collisions
		double xCollide = first->vX < 0 ? (first->x-r)/(0-first->vX) : ((double)l-first->x-r)/first->vX;
		double yCollide = first->vY < 0 ? (first->y-r)/(0-first->vY) : ((double)l-first->y-r)/first->vY;
		double earlierTime = fmin(xCollide, yCollide);
		double laterTime = fmax(xCollide, yCollide);
		first->x += earlierTime * first->vX;
		first->y += earlierTime * first->vY;
		//Reverse direction depending on which collision happens first
		if (xCollide <= yCollide) {
			first->vX = -first->vX;
		}	
		if (yCollide <= xCollide) {
			first->vY = -first->vY;
		}
		//artificially set timing to allow particle to continue after hitting corner
		if (xCollide == yCollide) {
			laterTime = 1;
		}
		first->x += (fmin(1.0, laterTime)-earlierTime) * first->vX;	
		first->y += (fmin(1.0, laterTime)-earlierTime) * first->vY;
		first->wColl++;
	}
}

__global__ void executeNoCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex < noCollisionsCount)
	{
		CollisionEvent *e = noCollisions[particleIndex];
		Particle *first = e->first;
		first->x += first->vX;
		first->y += first->vY;
	}
}

	.file	"tmpxft_00358a50_00000000-6_cuda-simulator.cudafe1.cpp"
	.text
#APP
	.globl _ZSt21ios_base_library_initv

#NO_APP
	.section	.text._ZN14CollisionEventD2Ev,"axG",@progbits,_ZN14CollisionEventD5Ev,comdat
	.align 2
	.weak	_ZN14CollisionEventD2Ev
	.type	_ZN14CollisionEventD2Ev, @function
_ZN14CollisionEventD2Ev:
.LFB5328:
	.cfi_startproc
	endbr64
	ret
	.cfi_endproc
.LFE5328:
	.size	_ZN14CollisionEventD2Ev, .-_ZN14CollisionEventD2Ev
	.weak	_ZN14CollisionEventD1Ev
	.set	_ZN14CollisionEventD1Ev,_ZN14CollisionEventD2Ev
	.section	.text._ZN14CollisionEventD0Ev,"axG",@progbits,_ZN14CollisionEventD5Ev,comdat
	.align 2
	.weak	_ZN14CollisionEventD0Ev
	.type	_ZN14CollisionEventD0Ev, @function
_ZN14CollisionEventD0Ev:
.LFB5330:
	.cfi_startproc
	endbr64
	movl	$40, %esi
	jmp	_ZdlPvm@PLT
	.cfi_endproc
.LFE5330:
	.size	_ZN14CollisionEventD0Ev, .-_ZN14CollisionEventD0Ev
	.text
	.type	_ZL20__nv_init_managed_rtv, @function
_ZL20__nv_init_managed_rtv:
.LFB1:
	.cfi_startproc
	movb	_ZL22__nv_inited_managed_rt(%rip), %al
	testb	%al, %al
	jne	.L6
	pushq	%rax
	.cfi_def_cfa_offset 16
	movq	_ZL32__nv_fatbinhandle_for_managed_rt(%rip), %rdi
	call	__cudaInitModule@PLT
	movb	%al, _ZL22__nv_inited_managed_rt(%rip)
	popq	%rdx
	.cfi_def_cfa_offset 8
	ret
.L6:
	movb	%al, _ZL22__nv_inited_managed_rt(%rip)
	ret
	.cfi_endproc
.LFE1:
	.size	_ZL20__nv_init_managed_rtv, .-_ZL20__nv_init_managed_rtv
	.type	_ZL26__cudaUnregisterBinaryUtilv, @function
_ZL26__cudaUnregisterBinaryUtilv:
.LFB5353:
	.cfi_startproc
	endbr64
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	jmp	__cudaUnregisterFatBinary@PLT
	.cfi_endproc
.LFE5353:
	.size	_ZL26__cudaUnregisterBinaryUtilv, .-_ZL26__cudaUnregisterBinaryUtilv
	.section	.text._ZNSt13random_deviceD2Ev,"axG",@progbits,_ZNSt13random_deviceD5Ev,comdat
	.align 2
	.weak	_ZNSt13random_deviceD2Ev
	.type	_ZNSt13random_deviceD2Ev, @function
_ZNSt13random_deviceD2Ev:
.LFB4434:
	.cfi_startproc
	.cfi_personality 0x9b,DW.ref.__gxx_personality_v0
	.cfi_lsda 0x1b,.LLSDA4434
	endbr64
	pushq	%rax
	.cfi_def_cfa_offset 16
	call	_ZNSt13random_device7_M_finiEv@PLT
	popq	%rdx
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE4434:
	.globl	__gxx_personality_v0
	.section	.gcc_except_table._ZNSt13random_deviceD2Ev,"aG",@progbits,_ZNSt13random_deviceD5Ev,comdat
.LLSDA4434:
	.byte	0xff
	.byte	0xff
	.byte	0x1
	.uleb128 .LLSDACSE4434-.LLSDACSB4434
.LLSDACSB4434:
.LLSDACSE4434:
	.section	.text._ZNSt13random_deviceD2Ev,"axG",@progbits,_ZNSt13random_deviceD5Ev,comdat
	.size	_ZNSt13random_deviceD2Ev, .-_ZNSt13random_deviceD2Ev
	.weak	_ZNSt13random_deviceD1Ev
	.set	_ZNSt13random_deviceD1Ev,_ZNSt13random_deviceD2Ev
	.text
	.globl	_Z40__device_stub__Z21findEarliestCollisionvv
	.type	_Z40__device_stub__Z21findEarliestCollisionvv, @function
_Z40__device_stub__Z21findEarliestCollisionvv:
.LFB5375:
	.cfi_startproc
	endbr64
	subq	$88, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 72(%rsp)
	movabsq	$4294967297, %rax
	leaq	8(%rsp), %rcx
	movq	%rsp, %rdx
	leaq	28(%rsp), %rsi
	leaq	16(%rsp), %rdi
	movl	$1, 24(%rsp)
	movl	$1, 36(%rsp)
	movq	%rax, 16(%rsp)
	movq	%rax, 28(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L13
	pushq	8(%rsp)
	.cfi_def_cfa_offset 104
	leaq	_Z21findEarliestCollisionv(%rip), %rdi
	pushq	8(%rsp)
	.cfi_def_cfa_offset 112
	movq	44(%rsp), %rcx
	movl	52(%rsp), %r8d
	movq	32(%rsp), %rsi
	movl	40(%rsp), %edx
	leaq	80(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 104
	popq	%rdx
	.cfi_def_cfa_offset 96
.L13:
	movq	72(%rsp), %rax
	subq	%fs:40, %rax
	je	.L15
	call	__stack_chk_fail@PLT
.L15:
	addq	$88, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5375:
	.size	_Z40__device_stub__Z21findEarliestCollisionvv, .-_Z40__device_stub__Z21findEarliestCollisionvv
	.globl	_Z21findEarliestCollisionv
	.type	_Z21findEarliestCollisionv, @function
_Z21findEarliestCollisionv:
.LFB5376:
	.cfi_startproc
	endbr64
	jmp	_Z40__device_stub__Z21findEarliestCollisionvv
	.cfi_endproc
.LFE5376:
	.size	_Z21findEarliestCollisionv, .-_Z21findEarliestCollisionv
	.globl	_Z40__device_stub__Z21timeParticleCollisionvv
	.type	_Z40__device_stub__Z21timeParticleCollisionvv, @function
_Z40__device_stub__Z21timeParticleCollisionvv:
.LFB5377:
	.cfi_startproc
	endbr64
	subq	$88, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 72(%rsp)
	movabsq	$4294967297, %rax
	leaq	8(%rsp), %rcx
	movq	%rsp, %rdx
	leaq	28(%rsp), %rsi
	leaq	16(%rsp), %rdi
	movl	$1, 24(%rsp)
	movl	$1, 36(%rsp)
	movq	%rax, 16(%rsp)
	movq	%rax, 28(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L18
	pushq	8(%rsp)
	.cfi_def_cfa_offset 104
	leaq	_Z21timeParticleCollisionv(%rip), %rdi
	pushq	8(%rsp)
	.cfi_def_cfa_offset 112
	movq	44(%rsp), %rcx
	movl	52(%rsp), %r8d
	movq	32(%rsp), %rsi
	movl	40(%rsp), %edx
	leaq	80(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 104
	popq	%rdx
	.cfi_def_cfa_offset 96
.L18:
	movq	72(%rsp), %rax
	subq	%fs:40, %rax
	je	.L20
	call	__stack_chk_fail@PLT
.L20:
	addq	$88, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5377:
	.size	_Z40__device_stub__Z21timeParticleCollisionvv, .-_Z40__device_stub__Z21timeParticleCollisionvv
	.globl	_Z21timeParticleCollisionv
	.type	_Z21timeParticleCollisionv, @function
_Z21timeParticleCollisionv:
.LFB5378:
	.cfi_startproc
	endbr64
	jmp	_Z40__device_stub__Z21timeParticleCollisionvv
	.cfi_endproc
.LFE5378:
	.size	_Z21timeParticleCollisionv, .-_Z21timeParticleCollisionv
	.globl	_Z36__device_stub__Z17timeWallCollisionvv
	.type	_Z36__device_stub__Z17timeWallCollisionvv, @function
_Z36__device_stub__Z17timeWallCollisionvv:
.LFB5379:
	.cfi_startproc
	endbr64
	subq	$88, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 72(%rsp)
	movabsq	$4294967297, %rax
	leaq	8(%rsp), %rcx
	movq	%rsp, %rdx
	leaq	28(%rsp), %rsi
	leaq	16(%rsp), %rdi
	movl	$1, 24(%rsp)
	movl	$1, 36(%rsp)
	movq	%rax, 16(%rsp)
	movq	%rax, 28(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L23
	pushq	8(%rsp)
	.cfi_def_cfa_offset 104
	leaq	_Z17timeWallCollisionv(%rip), %rdi
	pushq	8(%rsp)
	.cfi_def_cfa_offset 112
	movq	44(%rsp), %rcx
	movl	52(%rsp), %r8d
	movq	32(%rsp), %rsi
	movl	40(%rsp), %edx
	leaq	80(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 104
	popq	%rdx
	.cfi_def_cfa_offset 96
.L23:
	movq	72(%rsp), %rax
	subq	%fs:40, %rax
	je	.L25
	call	__stack_chk_fail@PLT
.L25:
	addq	$88, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5379:
	.size	_Z36__device_stub__Z17timeWallCollisionvv, .-_Z36__device_stub__Z17timeWallCollisionvv
	.globl	_Z17timeWallCollisionv
	.type	_Z17timeWallCollisionv, @function
_Z17timeWallCollisionv:
.LFB5380:
	.cfi_startproc
	endbr64
	jmp	_Z36__device_stub__Z17timeWallCollisionvv
	.cfi_endproc
.LFE5380:
	.size	_Z17timeWallCollisionv, .-_Z17timeWallCollisionv
	.globl	_Z43__device_stub__Z24executeParticleCollisionvv
	.type	_Z43__device_stub__Z24executeParticleCollisionvv, @function
_Z43__device_stub__Z24executeParticleCollisionvv:
.LFB5381:
	.cfi_startproc
	endbr64
	subq	$88, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 72(%rsp)
	movabsq	$4294967297, %rax
	leaq	8(%rsp), %rcx
	movq	%rsp, %rdx
	leaq	28(%rsp), %rsi
	leaq	16(%rsp), %rdi
	movl	$1, 24(%rsp)
	movl	$1, 36(%rsp)
	movq	%rax, 16(%rsp)
	movq	%rax, 28(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L28
	pushq	8(%rsp)
	.cfi_def_cfa_offset 104
	leaq	_Z24executeParticleCollisionv(%rip), %rdi
	pushq	8(%rsp)
	.cfi_def_cfa_offset 112
	movq	44(%rsp), %rcx
	movl	52(%rsp), %r8d
	movq	32(%rsp), %rsi
	movl	40(%rsp), %edx
	leaq	80(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 104
	popq	%rdx
	.cfi_def_cfa_offset 96
.L28:
	movq	72(%rsp), %rax
	subq	%fs:40, %rax
	je	.L30
	call	__stack_chk_fail@PLT
.L30:
	addq	$88, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5381:
	.size	_Z43__device_stub__Z24executeParticleCollisionvv, .-_Z43__device_stub__Z24executeParticleCollisionvv
	.globl	_Z24executeParticleCollisionv
	.type	_Z24executeParticleCollisionv, @function
_Z24executeParticleCollisionv:
.LFB5382:
	.cfi_startproc
	endbr64
	jmp	_Z43__device_stub__Z24executeParticleCollisionvv
	.cfi_endproc
.LFE5382:
	.size	_Z24executeParticleCollisionv, .-_Z24executeParticleCollisionv
	.globl	_Z39__device_stub__Z20executeWallCollisionvv
	.type	_Z39__device_stub__Z20executeWallCollisionvv, @function
_Z39__device_stub__Z20executeWallCollisionvv:
.LFB5383:
	.cfi_startproc
	endbr64
	subq	$88, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 72(%rsp)
	movabsq	$4294967297, %rax
	leaq	8(%rsp), %rcx
	movq	%rsp, %rdx
	leaq	28(%rsp), %rsi
	leaq	16(%rsp), %rdi
	movl	$1, 24(%rsp)
	movl	$1, 36(%rsp)
	movq	%rax, 16(%rsp)
	movq	%rax, 28(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L33
	pushq	8(%rsp)
	.cfi_def_cfa_offset 104
	leaq	_Z20executeWallCollisionv(%rip), %rdi
	pushq	8(%rsp)
	.cfi_def_cfa_offset 112
	movq	44(%rsp), %rcx
	movl	52(%rsp), %r8d
	movq	32(%rsp), %rsi
	movl	40(%rsp), %edx
	leaq	80(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 104
	popq	%rdx
	.cfi_def_cfa_offset 96
.L33:
	movq	72(%rsp), %rax
	subq	%fs:40, %rax
	je	.L35
	call	__stack_chk_fail@PLT
.L35:
	addq	$88, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5383:
	.size	_Z39__device_stub__Z20executeWallCollisionvv, .-_Z39__device_stub__Z20executeWallCollisionvv
	.globl	_Z20executeWallCollisionv
	.type	_Z20executeWallCollisionv, @function
_Z20executeWallCollisionv:
.LFB5384:
	.cfi_startproc
	endbr64
	jmp	_Z39__device_stub__Z20executeWallCollisionvv
	.cfi_endproc
.LFE5384:
	.size	_Z20executeWallCollisionv, .-_Z20executeWallCollisionv
	.globl	_Z37__device_stub__Z18executeNoCollisionvv
	.type	_Z37__device_stub__Z18executeNoCollisionvv, @function
_Z37__device_stub__Z18executeNoCollisionvv:
.LFB5385:
	.cfi_startproc
	endbr64
	subq	$88, %rsp
	.cfi_def_cfa_offset 96
	movq	%fs:40, %rax
	movq	%rax, 72(%rsp)
	movabsq	$4294967297, %rax
	leaq	8(%rsp), %rcx
	movq	%rsp, %rdx
	leaq	28(%rsp), %rsi
	leaq	16(%rsp), %rdi
	movl	$1, 24(%rsp)
	movl	$1, 36(%rsp)
	movq	%rax, 16(%rsp)
	movq	%rax, 28(%rsp)
	call	__cudaPopCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L38
	pushq	8(%rsp)
	.cfi_def_cfa_offset 104
	leaq	_Z18executeNoCollisionv(%rip), %rdi
	pushq	8(%rsp)
	.cfi_def_cfa_offset 112
	movq	44(%rsp), %rcx
	movl	52(%rsp), %r8d
	movq	32(%rsp), %rsi
	movl	40(%rsp), %edx
	leaq	80(%rsp), %r9
	call	cudaLaunchKernel@PLT
	popq	%rax
	.cfi_def_cfa_offset 104
	popq	%rdx
	.cfi_def_cfa_offset 96
.L38:
	movq	72(%rsp), %rax
	subq	%fs:40, %rax
	je	.L40
	call	__stack_chk_fail@PLT
.L40:
	addq	$88, %rsp
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5385:
	.size	_Z37__device_stub__Z18executeNoCollisionvv, .-_Z37__device_stub__Z18executeNoCollisionvv
	.globl	_Z18executeNoCollisionv
	.type	_Z18executeNoCollisionv, @function
_Z18executeNoCollisionv:
.LFB5386:
	.cfi_startproc
	endbr64
	jmp	_Z37__device_stub__Z18executeNoCollisionvv
	.cfi_endproc
.LFE5386:
	.size	_Z18executeNoCollisionv, .-_Z18executeNoCollisionv
	.globl	_Z13moveParticlesP8Particle
	.type	_Z13moveParticlesP8Particle, @function
_Z13moveParticlesP8Particle:
.LFB5347:
	.cfi_startproc
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	xorl	%ebx, %ebx
	subq	$72, %rsp
	.cfi_def_cfa_offset 128
.L44:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L46
	call	_ZL20__nv_init_managed_rtv
.L46:
	movq	_ZL1n(%rip), %rdx
	movb	_ZL22__nv_inited_managed_rt(%rip), %al
	cmpl	%ebx, (%rdx)
	jle	.L104
	testb	%al, %al
	jne	.L45
	call	_ZL20__nv_init_managed_rtv
.L45:
	movq	_ZL5found(%rip), %rax
	movq	(%rax), %rax
	movl	$-1, (%rax,%rbx,4)
	incq	%rbx
	jmp	.L44
.L104:
	testb	%al, %al
	jne	.L48
	call	_ZL20__nv_init_managed_rtv
.L48:
	movq	_ZL23particleCollisionsCount(%rip), %rax
	xorl	%r10d, %r10d
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movl	%r10d, (%rax)
	jne	.L49
	call	_ZL20__nv_init_managed_rtv
.L49:
	movq	_ZL19wallCollisionsCount(%rip), %rax
	xorl	%r9d, %r9d
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movl	%r9d, (%rax)
	jne	.L50
	call	_ZL20__nv_init_managed_rtv
.L50:
	movq	_ZL17noCollisionsCount(%rip), %rax
	xorl	%r8d, %r8d
	movl	$1, 60(%rsp)
	movq	streams(%rip), %r9
	movl	%r8d, (%rax)
	movl	$67108865, %eax
	salq	$6, %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, 52(%rsp)
	jne	.L51
	movq	%r9, (%rsp)
	call	_ZL20__nv_init_managed_rtv
	movq	(%rsp), %r9
.L51:
	movq	_ZL1n(%rip), %rax
	movl	$64, %ecx
	xorl	%r8d, %r8d
	movl	(%rax), %eax
	decl	%eax
	cltd
	idivl	%ecx
	movl	60(%rsp), %ecx
	movq	52(%rsp), %rdx
	incl	%eax
	movl	%eax, 40(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 44(%rsp)
	movq	40(%rsp), %rdi
	movl	48(%rsp), %esi
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L52
	call	_Z36__device_stub__Z17timeWallCollisionvv
.L52:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movl	$1, 24(%rsp)
	movabsq	$68719476752, %rax
	movq	%rax, 16(%rsp)
	jne	.L53
	call	_ZL20__nv_init_managed_rtv
.L53:
	movq	_ZL1n(%rip), %rax
	movl	$16, %ecx
	movl	(%rax), %eax
	decl	%eax
	cltd
	idivl	%ecx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	leal	1(%rax), %ebx
	jne	.L54
	call	_ZL20__nv_init_managed_rtv
.L54:
	movq	_ZL1n(%rip), %rax
	movl	$16, %ecx
	movl	%ebx, 32(%rsp)
	xorl	%r8d, %r8d
	movq	8+streams(%rip), %r9
	movl	$1, %esi
	movl	$1, 36(%rsp)
	movl	(%rax), %eax
	decl	%eax
	cltd
	idivl	%ecx
	movl	24(%rsp), %ecx
	movq	16(%rsp), %rdx
	incl	%eax
	movl	%eax, 28(%rsp)
	movq	28(%rsp), %rdi
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L55
	call	_Z40__device_stub__Z21timeParticleCollisionvv
.L55:
	call	cudaDeviceSynchronize@PLT
	xorl	%ebx, %ebx
.L56:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L85
	call	_ZL20__nv_init_managed_rtv
.L85:
	movq	_ZL1n(%rip), %rdx
	movb	_ZL22__nv_inited_managed_rt(%rip), %al
	cmpl	%ebx, (%rdx)
	je	.L105
	movl	$67108865, %edi
	movl	$1, 60(%rsp)
	salq	$6, %rdi
	movq	%rdi, 52(%rsp)
	testb	%al, %al
	jne	.L57
	call	_ZL20__nv_init_managed_rtv
.L57:
	movq	_ZL1n(%rip), %rax
	movl	$64, %ecx
	xorl	%r9d, %r9d
	xorl	%r8d, %r8d
	movl	(%rax), %eax
	decl	%eax
	cltd
	idivl	%ecx
	movl	60(%rsp), %ecx
	movq	52(%rsp), %rdx
	incl	%eax
	movl	%eax, 40(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 44(%rsp)
	movq	40(%rsp), %rdi
	movl	48(%rsp), %esi
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L58
	call	_Z40__device_stub__Z21findEarliestCollisionvv
.L58:
	call	cudaDeviceSynchronize@PLT
	xorl	%r12d, %r12d
.L59:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L83
	call	_ZL20__nv_init_managed_rtv
.L83:
	movq	_ZL1n(%rip), %rax
	movb	_ZL22__nv_inited_managed_rt(%rip), %dl
	movl	%r12d, (%rsp)
	cmpl	%r12d, (%rax)
	jle	.L56
	testb	%dl, %dl
	jne	.L60
	call	_ZL20__nv_init_managed_rtv
.L60:
	movq	_ZL5found(%rip), %rax
	leaq	0(,%r12,4), %r13
	movq	(%rax), %rax
	cmpl	$-1, (%rax,%r12,4)
	jne	.L66
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L62
	call	_ZL20__nv_init_managed_rtv
.L62:
	movq	_ZL4temp(%rip), %rax
	imulq	$40, %r12, %rbp
	addq	(%rax), %rbp
	movb	_ZL22__nv_inited_managed_rt(%rip), %al
	movl	32(%rbp), %edx
	cmpl	$1, %edx
	jne	.L63
	movq	16(%rbp), %rdx
	movl	(%rdx), %r15d
	testb	%al, %al
	jne	.L64
	call	_ZL20__nv_init_managed_rtv
.L64:
	movq	_ZL4temp(%rip), %rdx
	movslq	%r15d, %r14
	imulq	$40, %r14, %rax
	movq	(%rdx), %rdx
	cmpl	$1, 32(%rdx,%rax)
	jne	.L66
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L67
	movq	%rax, 8(%rsp)
	call	_ZL20__nv_init_managed_rtv
	movq	8(%rsp), %rax
.L67:
	movq	_ZL4temp(%rip), %rdx
	movq	16(%rbp), %rcx
	addq	(%rdx), %rax
	movq	8(%rbp), %rdx
	movq	16(%rax), %rdi
	movq	8(%rax), %rax
	movl	(%rdx), %edx
	movl	(%rax), %eax
	testq	%rcx, %rcx
	je	.L68
	movl	(%rcx), %esi
	movl	(%rdi), %ecx
	cmpl	%ecx, %edx
	jne	.L93
	cmpl	%esi, %eax
	je	.L69
.L93:
	cmpl	%eax, %edx
	jne	.L66
	cmpl	%ecx, %esi
	jmp	.L102
.L68:
	cmpl	%eax, %edx
.L102:
	jne	.L66
.L69:
	movl	(%rsp), %eax
	cmpl	%eax, %r15d
	jle	.L66
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L72
	call	_ZL20__nv_init_managed_rtv
.L72:
	movq	_ZL5found(%rip), %rax
	xorl	%edi, %edi
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	(%rax), %rax
	movl	%edi, (%rax,%r13)
	jne	.L73
	call	_ZL20__nv_init_managed_rtv
.L73:
	movq	_ZL5found(%rip), %rax
	xorl	%esi, %esi
	addl	$2, %ebx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	(%rax), %rax
	movl	%esi, (%rax,%r14,4)
	jne	.L74
	call	_ZL20__nv_init_managed_rtv
.L74:
	movq	_ZL18particleCollisions(%rip), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	(%rax), %r13
	jne	.L75
	call	_ZL20__nv_init_managed_rtv
.L75:
	movq	_ZL23particleCollisionsCount(%rip), %rdx
	jmp	.L103
.L63:
	testl	%edx, %edx
	leal	1(%rbx), %ebx
	jne	.L76
	testb	%al, %al
	jne	.L77
	call	_ZL20__nv_init_managed_rtv
.L77:
	movq	_ZL5found(%rip), %rax
	xorl	%ecx, %ecx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	(%rax), %rax
	movl	%ecx, (%rax,%r13)
	jne	.L78
	call	_ZL20__nv_init_managed_rtv
.L78:
	movq	_ZL14wallCollisions(%rip), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	(%rax), %r13
	jne	.L79
	call	_ZL20__nv_init_managed_rtv
.L79:
	movq	_ZL19wallCollisionsCount(%rip), %rdx
	jmp	.L103
.L76:
	testb	%al, %al
	jne	.L80
	call	_ZL20__nv_init_managed_rtv
.L80:
	movq	_ZL5found(%rip), %rax
	xorl	%edx, %edx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	(%rax), %rax
	movl	%edx, (%rax,%r13)
	jne	.L81
	call	_ZL20__nv_init_managed_rtv
.L81:
	movq	_ZL12noCollisions(%rip), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	(%rax), %r13
	jne	.L82
	call	_ZL20__nv_init_managed_rtv
.L82:
	movq	_ZL17noCollisionsCount(%rip), %rdx
.L103:
	movslq	(%rdx), %rax
	leal	1(%rax), %ecx
	movl	%ecx, (%rdx)
	movq	%rbp, 0(%r13,%rax,8)
.L66:
	incq	%r12
	jmp	.L59
.L105:
	movl	$67108865, %esi
	movl	$1, 60(%rsp)
	movq	streams(%rip), %r9
	salq	$6, %rsi
	movq	%rsi, 52(%rsp)
	testb	%al, %al
	jne	.L87
	movq	%r9, (%rsp)
	call	_ZL20__nv_init_managed_rtv
	movq	(%rsp), %r9
.L87:
	movq	_ZL23particleCollisionsCount(%rip), %rax
	movl	$64, %ecx
	xorl	%r8d, %r8d
	movl	(%rax), %eax
	decl	%eax
	cltd
	idivl	%ecx
	movl	60(%rsp), %ecx
	movq	52(%rsp), %rdx
	incl	%eax
	movl	%eax, 40(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 44(%rsp)
	movq	40(%rsp), %rdi
	movl	48(%rsp), %esi
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L88
	call	_Z43__device_stub__Z24executeParticleCollisionvv
.L88:
	movl	$67108865, %eax
	movl	$1, 60(%rsp)
	movq	8+streams(%rip), %r9
	salq	$6, %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, 52(%rsp)
	jne	.L89
	movq	%r9, (%rsp)
	call	_ZL20__nv_init_managed_rtv
	movq	(%rsp), %r9
.L89:
	movq	_ZL19wallCollisionsCount(%rip), %rax
	movl	$64, %ecx
	xorl	%r8d, %r8d
	movl	(%rax), %eax
	decl	%eax
	cltd
	idivl	%ecx
	movl	60(%rsp), %ecx
	movq	52(%rsp), %rdx
	incl	%eax
	movl	%eax, 40(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 44(%rsp)
	movq	40(%rsp), %rdi
	movl	48(%rsp), %esi
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L90
	call	_Z39__device_stub__Z20executeWallCollisionvv
.L90:
	movl	$67108865, %eax
	movl	$1, 60(%rsp)
	movq	8+streams(%rip), %r9
	salq	$6, %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, 52(%rsp)
	jne	.L91
	movq	%r9, (%rsp)
	call	_ZL20__nv_init_managed_rtv
	movq	(%rsp), %r9
.L91:
	movq	_ZL1n(%rip), %rax
	movl	$64, %ecx
	xorl	%r8d, %r8d
	movl	(%rax), %eax
	decl	%eax
	cltd
	idivl	%ecx
	movl	60(%rsp), %ecx
	movq	52(%rsp), %rdx
	incl	%eax
	movl	%eax, 40(%rsp)
	movabsq	$4294967297, %rax
	movq	%rax, 44(%rsp)
	movq	40(%rsp), %rdi
	movl	48(%rsp), %esi
	call	__cudaPushCallConfiguration@PLT
	testl	%eax, %eax
	jne	.L92
	call	_Z37__device_stub__Z18executeNoCollisionvv
.L92:
	addq	$72, %rsp
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%rbp
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	jmp	cudaDeviceSynchronize@PLT
	.cfi_endproc
.LFE5347:
	.size	_Z13moveParticlesP8Particle, .-_Z13moveParticlesP8Particle
	.section	.rodata.str1.1,"aMS",@progbits,1
.LC0:
	.string	"_Z18executeNoCollisionv"
.LC1:
	.string	"_Z20executeWallCollisionv"
.LC2:
	.string	"_Z24executeParticleCollisionv"
.LC3:
	.string	"_Z17timeWallCollisionv"
.LC4:
	.string	"_Z21timeParticleCollisionv"
.LC5:
	.string	"_Z21findEarliestCollisionv"
.LC6:
	.string	"n"
.LC7:
	.string	"l"
.LC8:
	.string	"r"
.LC9:
	.string	"s"
.LC10:
	.string	"particles"
.LC11:
	.string	"particleCollisionTimes"
.LC12:
	.string	"wallCollisionTimes"
.LC13:
	.string	"temp"
.LC14:
	.string	"found"
.LC15:
	.string	"particleCollisions"
.LC16:
	.string	"particleCollisionsCount"
.LC17:
	.string	"wallCollisions"
.LC18:
	.string	"wallCollisionsCount"
.LC19:
	.string	"noCollisions"
.LC20:
	.string	"noCollisionsCount"
	.section	.text.startup,"ax",@progbits
	.type	_ZL24__sti____cudaRegisterAllv, @function
_ZL24__sti____cudaRegisterAllv:
.LFB5388:
	.cfi_startproc
	endbr64
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset 3, -16
	leaq	_ZL15__fatDeviceText(%rip), %rdi
	call	__cudaRegisterFatBinary@PLT
	pushq	$0
	.cfi_def_cfa_offset 24
	xorl	%r9d, %r9d
	orl	$-1, %r8d
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC0(%rip), %rdx
	movq	%rax, %rdi
	movq	%rax, %rbx
	pushq	$0
	.cfi_def_cfa_offset 40
	movq	%rdx, %rcx
	leaq	_Z18executeNoCollisionv(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 48
	movq	%rax, _ZL20__cudaFatCubinHandle(%rip)
	movq	%rax, _ZL32__nv_fatbinhandle_for_managed_rt(%rip)
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	xorl	%r9d, %r9d
	orl	$-1, %r8d
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC1(%rip), %rdx
	movq	%rbx, %rdi
	leaq	_Z20executeWallCollisionv(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	pushq	$0
	.cfi_def_cfa_offset 40
	pushq	$0
	.cfi_def_cfa_offset 48
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	xorl	%r9d, %r9d
	orl	$-1, %r8d
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC2(%rip), %rdx
	movq	%rbx, %rdi
	leaq	_Z24executeParticleCollisionv(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	pushq	$0
	.cfi_def_cfa_offset 40
	pushq	$0
	.cfi_def_cfa_offset 48
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	xorl	%r9d, %r9d
	orl	$-1, %r8d
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC3(%rip), %rdx
	movq	%rbx, %rdi
	leaq	_Z17timeWallCollisionv(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	pushq	$0
	.cfi_def_cfa_offset 40
	pushq	$0
	.cfi_def_cfa_offset 48
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	xorl	%r9d, %r9d
	orl	$-1, %r8d
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC4(%rip), %rdx
	movq	%rbx, %rdi
	leaq	_Z21timeParticleCollisionv(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	pushq	$0
	.cfi_def_cfa_offset 40
	pushq	$0
	.cfi_def_cfa_offset 48
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	xorl	%r9d, %r9d
	orl	$-1, %r8d
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC5(%rip), %rdx
	movq	%rbx, %rdi
	leaq	_Z21findEarliestCollisionv(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	pushq	$0
	.cfi_def_cfa_offset 40
	pushq	$0
	.cfi_def_cfa_offset 48
	call	__cudaRegisterFunction@PLT
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	xorl	%r8d, %r8d
	movq	%rbx, %rdi
	pushq	$0
	.cfi_def_cfa_offset 24
	leaq	.LC6(%rip), %rdx
	movl	$4, %r9d
	leaq	_ZL1n(%rip), %rsi
	pushq	$0
	.cfi_def_cfa_offset 32
	movq	%rdx, %rcx
	call	__cudaRegisterManagedVar@PLT
	popq	%rax
	.cfi_def_cfa_offset 24
	popq	%rdx
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC7(%rip), %rdx
	xorl	%r8d, %r8d
	movq	%rbx, %rdi
	movq	%rdx, %rcx
	movl	$4, %r9d
	leaq	_ZL1l(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rcx
	.cfi_def_cfa_offset 24
	popq	%rsi
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC8(%rip), %rdx
	xorl	%r8d, %r8d
	movq	%rbx, %rdi
	movq	%rdx, %rcx
	movl	$4, %r9d
	leaq	_ZL1r(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rdi
	.cfi_def_cfa_offset 24
	popq	%r8
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC9(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$4, %r9d
	leaq	_ZL1s(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%r9
	.cfi_def_cfa_offset 24
	popq	%r10
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC10(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL9particles(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%r11
	.cfi_def_cfa_offset 24
	popq	%rax
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC11(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL22particleCollisionTimes(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rax
	.cfi_def_cfa_offset 24
	popq	%rdx
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC12(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL18wallCollisionTimes(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rcx
	.cfi_def_cfa_offset 24
	popq	%rsi
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC13(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL4temp(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rdi
	.cfi_def_cfa_offset 24
	popq	%r8
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC14(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL5found(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%r9
	.cfi_def_cfa_offset 24
	popq	%r10
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC15(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL18particleCollisions(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%r11
	.cfi_def_cfa_offset 24
	popq	%rax
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC16(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$4, %r9d
	leaq	_ZL23particleCollisionsCount(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rax
	.cfi_def_cfa_offset 24
	popq	%rdx
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC17(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL14wallCollisions(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rcx
	.cfi_def_cfa_offset 24
	popq	%rsi
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC18(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$4, %r9d
	leaq	_ZL19wallCollisionsCount(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%rdi
	.cfi_def_cfa_offset 24
	popq	%r8
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC19(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movq	%rdx, %rcx
	movl	$8, %r9d
	leaq	_ZL12noCollisions(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	popq	%r9
	.cfi_def_cfa_offset 24
	popq	%r10
	.cfi_def_cfa_offset 16
	pushq	$0
	.cfi_def_cfa_offset 24
	pushq	$0
	.cfi_def_cfa_offset 32
	leaq	.LC20(%rip), %rdx
	movq	%rbx, %rdi
	xorl	%r8d, %r8d
	movl	$4, %r9d
	movq	%rdx, %rcx
	leaq	_ZL17noCollisionsCount(%rip), %rsi
	call	__cudaRegisterManagedVar@PLT
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	popq	%r11
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	call	__cudaRegisterFatBinaryEnd@PLT
	leaq	_ZL26__cudaUnregisterBinaryUtilv(%rip), %rdi
	popq	%rbx
	.cfi_def_cfa_offset 8
	jmp	atexit@PLT
	.cfi_endproc
.LFE5388:
	.size	_ZL24__sti____cudaRegisterAllv, .-_ZL24__sti____cudaRegisterAllv
	.section	.init_array,"aw"
	.align 8
	.quad	_ZL24__sti____cudaRegisterAllv
	.section	.rodata._ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_.str1.1,"aMS",@progbits,1
.LC21:
	.string	"basic_string: construction from null is not valid"
	.section	.text._ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_,"axG",@progbits,_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC5IS3_EEPKcRKS3_,comdat
	.align 2
	.weak	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_
	.type	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_, @function
_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_:
.LFB5716:
	.cfi_startproc
	endbr64
	pushq	%r12
	.cfi_def_cfa_offset 16
	.cfi_offset 12, -16
	pushq	%rbp
	.cfi_def_cfa_offset 24
	.cfi_offset 6, -24
	pushq	%rbx
	.cfi_def_cfa_offset 32
	.cfi_offset 3, -32
	subq	$16, %rsp
	.cfi_def_cfa_offset 48
	movq	%fs:40, %rax
	movq	%rax, 8(%rsp)
	xorl	%eax, %eax
	leaq	16(%rdi), %rax
	movq	%rax, (%rdi)
	testq	%rsi, %rsi
	jne	.L109
	movq	8(%rsp), %rax
	subq	%fs:40, %rax
	jne	.L114
	leaq	.LC21(%rip), %rdi
	call	_ZSt19__throw_logic_errorPKc@PLT
.L109:
	movq	%rdi, %rbx
	movq	%rsi, %rdi
	movq	%rsi, %rbp
	call	strlen@PLT
	movq	%rax, (%rsp)
	leaq	0(%rbp,%rax), %r12
	cmpq	$15, %rax
	jbe	.L111
	movq	%rsp, %rsi
	xorl	%edx, %edx
	movq	%rbx, %rdi
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@PLT
	movq	%rax, (%rbx)
	movq	(%rsp), %rax
	movq	%rax, 16(%rbx)
.L111:
	movq	(%rbx), %rdi
	movq	%r12, %rdx
	movq	%rbp, %rsi
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13_S_copy_charsEPcPKcS7_@PLT
	movq	(%rsp), %rax
	movq	(%rbx), %rdx
	movq	%rax, 8(%rbx)
	movb	$0, (%rdx,%rax)
	movq	8(%rsp), %rax
	subq	%fs:40, %rax
	je	.L112
.L114:
	call	__stack_chk_fail@PLT
.L112:
	addq	$16, %rsp
	.cfi_def_cfa_offset 32
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%rbp
	.cfi_def_cfa_offset 16
	popq	%r12
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5716:
	.size	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_, .-_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_
	.weak	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_
	.set	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_,_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_
	.section	.text._ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm,"axG",@progbits,_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm,comdat
	.align 2
	.weak	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm
	.type	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm, @function
_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm:
.LFB5800:
	.cfi_startproc
	endbr64
	movl	%esi, %eax
	movl	$1, %edx
	movq	%rax, (%rdi)
.L116:
	movq	-8(%rdi,%rdx,8), %rcx
	movq	%rcx, %rax
	shrq	$30, %rax
	xorq	%rcx, %rax
	imulq	$1812433253, %rax, %rax
	addl	%edx, %eax
	movq	%rax, (%rdi,%rdx,8)
	incq	%rdx
	cmpq	$624, %rdx
	jne	.L116
	movq	$624, 4992(%rdi)
	ret
	.cfi_endproc
.LFE5800:
	.size	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm, .-_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm
	.section	.text._ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv,"axG",@progbits,_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv,comdat
	.align 2
	.weak	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv
	.type	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv, @function
_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv:
.LFB6199:
	.cfi_startproc
	endbr64
	movq	%rdi, %rax
	xorl	%edx, %edx
	movl	$2567483615, %edi
.L120:
	movq	(%rax,%rdx,8), %rsi
	incq	%rdx
	movq	(%rax,%rdx,8), %rcx
	andq	$-2147483648, %rsi
	andl	$2147483647, %ecx
	orq	%rsi, %rcx
	movq	%rcx, %rsi
	shrq	%rsi
	xorq	3168(%rax,%rdx,8), %rsi
	andl	$1, %ecx
	je	.L119
	movq	%rdi, %rcx
.L119:
	xorq	%rsi, %rcx
	movq	%rcx, -8(%rax,%rdx,8)
	cmpq	$227, %rdx
	jne	.L120
	movl	$2567483615, %edi
.L122:
	movq	(%rax,%rdx,8), %rsi
	incq	%rdx
	movq	(%rax,%rdx,8), %rcx
	andq	$-2147483648, %rsi
	andl	$2147483647, %ecx
	orq	%rsi, %rcx
	movq	%rcx, %rsi
	shrq	%rsi
	xorq	-1824(%rax,%rdx,8), %rsi
	andl	$1, %ecx
	je	.L121
	movq	%rdi, %rcx
.L121:
	xorq	%rsi, %rcx
	movq	%rcx, -8(%rax,%rdx,8)
	cmpq	$623, %rdx
	jne	.L122
	movq	4984(%rax), %rdx
	movq	(%rax), %rcx
	andq	$-2147483648, %rdx
	andl	$2147483647, %ecx
	orq	%rcx, %rdx
	movq	%rdx, %rcx
	shrq	%rcx
	xorq	3168(%rax), %rcx
	andl	$1, %edx
	je	.L123
	movl	$2567483615, %edx
.L123:
	xorq	%rcx, %rdx
	movq	%rdx, 4984(%rax)
	xorl	%edx, %edx
	movq	%rdx, 4992(%rax)
	ret
	.cfi_endproc
.LFE6199:
	.size	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv, .-_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv
	.section	.text._ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_,"axG",@progbits,_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_,comdat
	.align 2
	.weak	_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_
	.type	_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_, @function
_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_:
.LFB5805:
	.cfi_startproc
	endbr64
	pushq	%r12
	.cfi_def_cfa_offset 16
	.cfi_offset 12, -16
	xorps	%xmm1, %xmm1
	movl	$2, %r12d
	pushq	%rbp
	.cfi_def_cfa_offset 24
	.cfi_offset 6, -24
	movq	%rdi, %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 32
	.cfi_offset 3, -32
	movq	%rsi, %rbx
	subq	$16, %rsp
	.cfi_def_cfa_offset 48
	movsd	.LC23(%rip), %xmm3
	movsd	%xmm3, (%rsp)
.L139:
	cmpq	$623, 4992(%rbx)
	jbe	.L136
	movq	%rbx, %rdi
	movsd	%xmm1, 8(%rsp)
	call	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv
	movsd	8(%rsp), %xmm1
.L136:
	movq	4992(%rbx), %rax
	leaq	1(%rax), %rdx
	movq	(%rbx,%rax,8), %rax
	movq	%rdx, 4992(%rbx)
	movq	%rax, %rdx
	shrq	$11, %rdx
	movl	%edx, %edx
	xorq	%rdx, %rax
	movq	%rax, %rdx
	salq	$7, %rdx
	andl	$2636928640, %edx
	xorq	%rdx, %rax
	movq	%rax, %rdx
	salq	$15, %rdx
	andl	$4022730752, %edx
	xorq	%rdx, %rax
	movq	%rax, %rdx
	shrq	$18, %rdx
	xorq	%rdx, %rax
	js	.L137
	cvtsi2sdq	%rax, %xmm0
	jmp	.L138
.L137:
	movq	%rax, %rdx
	andl	$1, %eax
	shrq	%rdx
	orq	%rax, %rdx
	cvtsi2sdq	%rdx, %xmm0
	addsd	%xmm0, %xmm0
.L138:
	mulsd	(%rsp), %xmm0
	flds	.LC25(%rip)
	decl	%r12d
	fmull	(%rsp)
	addsd	%xmm0, %xmm1
	fstpl	(%rsp)
	je	.L144
	movl	$1, %r12d
	jmp	.L139
.L144:
	divsd	(%rsp), %xmm1
	comisd	.LC23(%rip), %xmm1
	jb	.L140
	movsd	.LC24(%rip), %xmm1
.L140:
	movsd	0(%rbp), %xmm2
	movsd	8(%rbp), %xmm0
	addq	$16, %rsp
	.cfi_def_cfa_offset 32
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%rbp
	.cfi_def_cfa_offset 16
	subsd	%xmm2, %xmm0
	popq	%r12
	.cfi_def_cfa_offset 8
	mulsd	%xmm1, %xmm0
	addsd	%xmm2, %xmm0
	ret
	.cfi_endproc
.LFE5805:
	.size	_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_, .-_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_
	.section	.rodata.str1.1
.LC28:
	.string	"%d %lf %lf %lf %lf"
.LC29:
	.string	"print"
.LC30:
	.string	" "
.LC31:
	.string	"%d %.8lf %.8lf %.8lf %.8lf"
.LC32:
	.string	"%d %.8lf %.8lf %.8lf %.8lf %d %d"
	.section	.text.startup
	.globl	main
	.type	main, @function
main:
.LFB5343:
	.cfi_startproc
	.cfi_personality 0x9b,DW.ref.__gxx_personality_v0
	.cfi_lsda 0x1b,.LLSDA5343
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	xorl	%edi, %edi
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	subq	$584, %rsp
	.cfi_def_cfa_offset 640
	movq	%fs:40, %rax
	movq	%rax, 568(%rsp)
	xorl	%eax, %eax
	leaq	120(%rsp), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rdi, 112(%rsp)
	movq	%rax, 104(%rsp)
	leaq	104(%rsp), %rax
	movb	$0, 120(%rsp)
	movq	%rax, 16(%rsp)
	je	.L146
.L148:
	movq	_ZL1n(%rip), %rsi
	leaq	_ZSt3cin(%rip), %rdi
.LEHB0:
	call	_ZNSirsERi@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, %rbx
	jne	.L149
	jmp	.L226
.L146:
	call	_ZL20__nv_init_managed_rtv
	jmp	.L148
.L226:
	call	_ZL20__nv_init_managed_rtv
.L149:
	movq	_ZL1l(%rip), %rsi
	movq	%rbx, %rdi
	call	_ZNSirsERi@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, %rbx
	jne	.L150
	call	_ZL20__nv_init_managed_rtv
.L150:
	movq	_ZL1r(%rip), %rsi
	movq	%rbx, %rdi
	call	_ZNSirsERi@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, %rbx
	jne	.L151
	call	_ZL20__nv_init_managed_rtv
.L151:
	movq	_ZL1s(%rip), %rsi
	movq	%rbx, %rdi
	call	_ZNSirsERi@PLT
	movq	16(%rsp), %rsi
	movq	%rax, %rdi
	call	_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE@PLT
	leaq	rd(%rip), %rdi
	call	_ZNSt13random_device9_M_getvalEv@PLT
	leaq	rng(%rip), %rbp
	movl	%eax, %esi
	movq	%rbp, %rdi
	call	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L152
	call	_ZL20__nv_init_managed_rtv
.L152:
	movq	_ZL1l(%rip), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movl	(%rax), %ebx
	jne	.L153
	call	_ZL20__nv_init_managed_rtv
.L153:
	movq	_ZL1r(%rip), %rax
	subl	(%rax), %ebx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	cvtsi2sdl	%ebx, %xmm4
	movq	%xmm4, %rbx
	jne	.L154
	call	_ZL20__nv_init_managed_rtv
.L154:
	movq	_ZL1r(%rip), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rbx, 80(%rsp)
	cvtsi2sdl	(%rax), %xmm0
	movsd	%xmm0, 72(%rsp)
	jne	.L155
	call	_ZL20__nv_init_managed_rtv
.L155:
	movq	_ZL1l(%rip), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	cvtsi2sdl	(%rax), %xmm0
	mulsd	.LC27(%rip), %xmm0
	movq	%xmm0, %rbx
	jne	.L156
	call	_ZL20__nv_init_managed_rtv
.L156:
	movq	_ZL1l(%rip), %rax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	cvtsi2sdl	(%rax), %xmm5
	movq	%xmm5, %r12
	jne	.L157
	call	_ZL20__nv_init_managed_rtv
.L157:
	movq	_ZL1r(%rip), %rax
	movq	%r12, %xmm0
	movq	%rbx, 96(%rsp)
	movl	(%rax), %eax
	sall	$3, %eax
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	cvtsi2sdl	%eax, %xmm1
	divsd	%xmm1, %xmm0
	movsd	%xmm0, 88(%rsp)
	jne	.L158
	call	_ZL20__nv_init_managed_rtv
.L158:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	imulq	$48, %rbx, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L159
	call	_ZL20__nv_init_managed_rtv
.L159:
	movq	_ZL9particles(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	xorl	%ebx, %ebx
	leaq	.LC28(%rip), %r12
.L160:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L165
	call	_ZL20__nv_init_managed_rtv
.L165:
	movq	_ZL1n(%rip), %rax
	cmpl	%ebx, (%rax)
	jle	.L167
	leaq	48(%rsp), %rcx
	leaq	40(%rsp), %rdx
	movq	%r12, %rdi
	xorl	%eax, %eax
	leaq	36(%rsp), %rsi
	leaq	64(%rsp), %r9
	leaq	56(%rsp), %r8
	call	__isoc23_scanf@PLT
	movl	%eax, %edx
	movb	_ZL22__nv_inited_managed_rt(%rip), %al
	testl	%edx, %edx
	jle	.L167
	testb	%al, %al
	jne	.L162
	call	_ZL20__nv_init_managed_rtv
.L162:
	movsd	64(%rsp), %xmm6
	movsd	56(%rsp), %xmm7
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	48(%rsp), %r15
	movq	40(%rsp), %r13
	movl	36(%rsp), %r14d
	movsd	%xmm6, 8(%rsp)
	movsd	%xmm7, 24(%rsp)
	jne	.L163
	call	_ZL20__nv_init_managed_rtv
.L163:
	movq	_ZL9particles(%rip), %rdx
	movsd	24(%rsp), %xmm4
	imulq	$48, %rbx, %rax
	xorl	%esi, %esi
	movsd	8(%rsp), %xmm5
	incq	%rbx
	addq	(%rdx), %rax
	movl	%r14d, (%rax)
	movq	%r13, 8(%rax)
	movq	%r15, 16(%rax)
	movq	%rsi, 40(%rax)
	movsd	%xmm4, 24(%rax)
	movsd	%xmm5, 32(%rax)
	jmp	.L160
.L167:
	movl	%ebx, %r12d
	movslq	%ebx, %rbx
	leaq	72(%rsp), %r14
	imulq	$48, %rbx, %rbx
.L164:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L169
	call	_ZL20__nv_init_managed_rtv
.L169:
	movq	_ZL1n(%rip), %rax
	cmpl	%r12d, (%rax)
	jle	.L227
	movq	%rbp, %rsi
	movq	%r14, %rdi
	leaq	88(%rsp), %r13
	call	_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_
	movq	%rbp, %rsi
	movq	%r14, %rdi
	movsd	%xmm0, 8(%rsp)
	call	_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_
	movq	%r13, %rdi
	movq	%rbp, %rsi
	movq	%xmm0, %r15
	call	_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_
	movq	%r13, %rdi
	movq	%rbp, %rsi
	movsd	%xmm0, 24(%rsp)
	call	_ZNSt25uniform_real_distributionIdEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEdRT_
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%xmm0, %r13
	jne	.L168
	call	_ZL20__nv_init_managed_rtv
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L168
	call	_ZL20__nv_init_managed_rtv
.L168:
	movq	_ZL9particles(%rip), %rax
	movsd	8(%rsp), %xmm6
	movsd	24(%rsp), %xmm7
	movq	(%rax), %rcx
	addq	%rbx, %rcx
	movl	%r12d, (%rcx)
	movq	%rcx, %rax
	incl	%r12d
	movq	%r15, 16(%rcx)
	movq	%r13, 32(%rcx)
	movsd	%xmm6, 8(%rcx)
	movsd	%xmm7, 24(%rcx)
	xorl	%ecx, %ecx
	movq	%rcx, 40(%rax)
	jmp	.L164
.L227:
	leaq	streams(%rip), %rdi
	call	cudaStreamCreate@PLT
	leaq	8+streams(%rip), %rdi
	call	cudaStreamCreate@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L171
	call	_ZL20__nv_init_managed_rtv
.L171:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	salq	$3, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L172
	call	_ZL20__nv_init_managed_rtv
.L172:
	movq	_ZL22particleCollisionTimes(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	xorl	%ebx, %ebx
.L173:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L176
	call	_ZL20__nv_init_managed_rtv
.L176:
	movq	_ZL1n(%rip), %rdx
	movb	_ZL22__nv_inited_managed_rt(%rip), %al
	cmpl	%ebx, (%rdx)
	jle	.L228
	testb	%al, %al
	jne	.L174
	call	_ZL20__nv_init_managed_rtv
.L174:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbp
	salq	$3, %rbp
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L175
	call	_ZL20__nv_init_managed_rtv
.L175:
	movq	_ZL22particleCollisionTimes(%rip), %rax
	movl	$1, %edx
	movq	%rbp, %rsi
	movq	(%rax), %rax
	leaq	(%rax,%rbx,8), %rdi
	call	cudaMallocManaged@PLT
	incq	%rbx
	jmp	.L173
.L228:
	testb	%al, %al
	jne	.L178
	call	_ZL20__nv_init_managed_rtv
.L178:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	salq	$3, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L179
	call	_ZL20__nv_init_managed_rtv
.L179:
	movq	_ZL18wallCollisionTimes(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L180
	call	_ZL20__nv_init_managed_rtv
.L180:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	salq	$2, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L181
	call	_ZL20__nv_init_managed_rtv
.L181:
	movq	_ZL5found(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L182
	call	_ZL20__nv_init_managed_rtv
.L182:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	salq	$3, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L183
	call	_ZL20__nv_init_managed_rtv
.L183:
	movq	_ZL18particleCollisions(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L184
	call	_ZL20__nv_init_managed_rtv
.L184:
	movq	_ZL23particleCollisionsCount(%rip), %rdi
	movl	$1, %edx
	movl	$4, %esi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L185
	call	_ZL20__nv_init_managed_rtv
.L185:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	salq	$3, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L186
	call	_ZL20__nv_init_managed_rtv
.L186:
	movq	_ZL14wallCollisions(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L187
	call	_ZL20__nv_init_managed_rtv
.L187:
	movq	_ZL19wallCollisionsCount(%rip), %rdi
	movl	$1, %edx
	movl	$4, %esi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L188
	call	_ZL20__nv_init_managed_rtv
.L188:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	salq	$3, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L189
	call	_ZL20__nv_init_managed_rtv
.L189:
	movq	_ZL12noCollisions(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L190
	call	_ZL20__nv_init_managed_rtv
.L190:
	movq	_ZL17noCollisionsCount(%rip), %rdi
	movl	$1, %edx
	movl	$4, %esi
	call	cudaMallocManaged@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L191
	call	_ZL20__nv_init_managed_rtv
.L191:
	movq	_ZL1n(%rip), %rax
	movslq	(%rax), %rbx
	imulq	$40, %rbx, %rbx
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L192
	call	_ZL20__nv_init_managed_rtv
.L192:
	movq	_ZL4temp(%rip), %rdi
	movl	$1, %edx
	movq	%rbx, %rsi
	call	cudaMallocManaged@PLT
	call	_ZNSt6chrono3_V212system_clock3nowEv@PLT
	xorl	%ebx, %ebx
	leaq	.LC29(%rip), %r14
.L193:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L201
	call	_ZL20__nv_init_managed_rtv
.L201:
	movq	_ZL1s(%rip), %rax
	cmpl	%ebx, (%rax)
	jle	.L229
	leaq	104(%rsp), %rdi
	movq	%r14, %rsi
	call	_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc@PLT
	testl	%eax, %eax
	je	.L215
.L200:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L195
	jmp	.L230
.L215:
	xorl	%ebp, %ebp
	leaq	_ZSt4cout(%rip), %r15
.L194:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L198
	call	_ZL20__nv_init_managed_rtv
.L198:
	movq	_ZL1n(%rip), %rax
	cmpl	%ebp, (%rax)
	jle	.L200
	movl	%ebx, %esi
	movq	%r15, %rdi
	call	_ZNSolsEi@PLT
	movq	%rax, %rdi
	leaq	.LC30(%rip), %rsi
	call	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, %r12
	jne	.L197
	call	_ZL20__nv_init_managed_rtv
.L197:
	movq	_ZL9particles(%rip), %rdx
	imulq	$48, %rbp, %rax
	leaq	168(%rsp), %r13
	movl	$200, %esi
	movq	%r13, %rdi
	leaq	.LC31(%rip), %r8
	movl	$200, %ecx
	addq	(%rdx), %rax
	movl	$2, %edx
	movsd	8(%rax), %xmm0
	movsd	32(%rax), %xmm3
	movsd	24(%rax), %xmm2
	movsd	16(%rax), %xmm1
	movl	(%rax), %r9d
	movb	$4, %al
	call	__snprintf_chk@PLT
	leaq	136(%rsp), %rax
	leaq	56(%rsp), %rdx
	movq	%r13, %rsi
	movq	%rax, %rdi
	movq	%rax, 8(%rsp)
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_
.LEHE0:
	movq	8(%rsp), %rsi
	movq	%r12, %rdi
.LEHB1:
	call	_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE@PLT
	movq	%rax, %rdi
	call	_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_@PLT
.LEHE1:
	movq	8(%rsp), %rdi
	incq	%rbp
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@PLT
	jmp	.L194
.L230:
.LEHB2:
	call	_ZL20__nv_init_managed_rtv
.L195:
	movq	_ZL9particles(%rip), %rax
	movq	(%rax), %rdi
	call	_Z13moveParticlesP8Particle
	incl	%ebx
	jmp	.L193
.L229:
	call	_ZNSt6chrono3_V212system_clock3nowEv@PLT
	xorl	%ebx, %ebx
	leaq	_ZSt4cout(%rip), %r14
.L203:
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L206
	call	_ZL20__nv_init_managed_rtv
.L206:
	movq	_ZL1n(%rip), %rax
	cmpl	%ebx, (%rax)
	jle	.L231
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	jne	.L204
	call	_ZL20__nv_init_managed_rtv
.L204:
	movq	_ZL1s(%rip), %rax
	movq	%r14, %rdi
	movl	(%rax), %esi
	call	_ZNSolsEi@PLT
	movq	%rax, %rdi
	leaq	.LC30(%rip), %rsi
	call	_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@PLT
	cmpb	$0, _ZL22__nv_inited_managed_rt(%rip)
	movq	%rax, %r12
	jne	.L205
	call	_ZL20__nv_init_managed_rtv
.L205:
	movq	_ZL9particles(%rip), %rdx
	imulq	$48, %rbx, %rax
	leaq	368(%rsp), %r13
	movl	$200, %esi
	movq	%r13, %rdi
	leaq	.LC32(%rip), %r8
	movl	$200, %ecx
	addq	(%rdx), %rax
	movl	44(%rax), %edx
	movsd	32(%rax), %xmm3
	movsd	24(%rax), %xmm2
	movsd	16(%rax), %xmm1
	movsd	8(%rax), %xmm0
	pushq	%rdx
	.cfi_def_cfa_offset 648
	movl	40(%rax), %edx
	pushq	%rdx
	.cfi_def_cfa_offset 656
	movl	(%rax), %r9d
	movl	$2, %edx
	movb	$4, %al
	call	__snprintf_chk@PLT
	popq	%rax
	.cfi_def_cfa_offset 648
	popq	%rdx
	.cfi_def_cfa_offset 640
	movq	%r13, %rsi
	leaq	136(%rsp), %rbp
	leaq	64(%rsp), %rdx
	movq	%rbp, %rdi
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_
.LEHE2:
	movq	%rbp, %rsi
	movq	%r12, %rdi
.LEHB3:
	call	_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE@PLT
	movq	%rax, %rdi
	call	_ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_@PLT
.LEHE3:
	movq	%rbp, %rdi
	incq	%rbx
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@PLT
	jmp	.L203
.L231:
	leaq	104(%rsp), %rdi
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@PLT
	movq	568(%rsp), %rax
	subq	%fs:40, %rax
	je	.L212
	jmp	.L223
.L217:
	endbr64
	movq	%rax, %rbx
.L208:
	movq	8(%rsp), %rdi
	jmp	.L225
.L218:
	endbr64
	movq	%rax, %rbx
.L210:
	movq	%rbp, %rdi
.L225:
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@PLT
	jmp	.L209
.L216:
	endbr64
	movq	%rax, %rbx
.L209:
	movq	16(%rsp), %rdi
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@PLT
	movq	568(%rsp), %rax
	subq	%fs:40, %rax
	jne	.L223
	movq	%rbx, %rdi
.LEHB4:
	call	_Unwind_Resume@PLT
.LEHE4:
.L223:
	call	__stack_chk_fail@PLT
.L212:
	addq	$584, %rsp
	.cfi_def_cfa_offset 56
	xorl	%eax, %eax
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%rbp
	.cfi_def_cfa_offset 40
	popq	%r12
	.cfi_def_cfa_offset 32
	popq	%r13
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc
.LFE5343:
	.section	.gcc_except_table,"a",@progbits
.LLSDA5343:
	.byte	0xff
	.byte	0xff
	.byte	0x1
	.uleb128 .LLSDACSE5343-.LLSDACSB5343
.LLSDACSB5343:
	.uleb128 .LEHB0-.LFB5343
	.uleb128 .LEHE0-.LEHB0
	.uleb128 .L216-.LFB5343
	.uleb128 0
	.uleb128 .LEHB1-.LFB5343
	.uleb128 .LEHE1-.LEHB1
	.uleb128 .L217-.LFB5343
	.uleb128 0
	.uleb128 .LEHB2-.LFB5343
	.uleb128 .LEHE2-.LEHB2
	.uleb128 .L216-.LFB5343
	.uleb128 0
	.uleb128 .LEHB3-.LFB5343
	.uleb128 .LEHE3-.LEHB3
	.uleb128 .L218-.LFB5343
	.uleb128 0
	.uleb128 .LEHB4-.LFB5343
	.uleb128 .LEHE4-.LEHB4
	.uleb128 0
	.uleb128 0
.LLSDACSE5343:
	.section	.text.startup
	.size	main, .-main
	.section	.rodata.str1.1
.LC33:
	.string	"default"
	.section	.text.startup
	.type	_GLOBAL__sub_I_rng, @function
_GLOBAL__sub_I_rng:
.LFB6206:
	.cfi_startproc
	.cfi_personality 0x9b,DW.ref.__gxx_personality_v0
	.cfi_lsda 0x1b,.LLSDA6206
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movl	$5489, %esi
	leaq	rng(%rip), %rdi
	leaq	rd(%rip), %rbp
	pushq	%rbx
	.cfi_def_cfa_offset 24
	.cfi_offset 3, -24
	subq	$56, %rsp
	.cfi_def_cfa_offset 80
	movq	%fs:40, %rax
	movq	%rax, 40(%rsp)
	xorl	%eax, %eax
	leaq	8(%rsp), %rbx
	call	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm
	leaq	.LC33(%rip), %rsi
	movq	%rbx, %rdi
	leaq	7(%rsp), %rdx
.LEHB5:
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_
.LEHE5:
	movq	%rbx, %rsi
	movq	%rbp, %rdi
.LEHB6:
	call	_ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE@PLT
.LEHE6:
	movq	%rbx, %rdi
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@PLT
	movq	40(%rsp), %rax
	subq	%fs:40, %rax
	jne	.L239
	addq	$56, %rsp
	.cfi_remember_state
	.cfi_def_cfa_offset 24
	movq	%rbp, %rsi
	leaq	__dso_handle(%rip), %rdx
	popq	%rbx
	.cfi_def_cfa_offset 16
	leaq	_ZNSt13random_deviceD1Ev(%rip), %rdi
	popq	%rbp
	.cfi_def_cfa_offset 8
	jmp	__cxa_atexit@PLT
.L237:
	.cfi_restore_state
	endbr64
	movq	%rax, %rbp
.L234:
	movq	%rbx, %rdi
	call	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv@PLT
	movq	40(%rsp), %rax
	subq	%fs:40, %rax
	je	.L235
.L239:
	call	__stack_chk_fail@PLT
.L235:
	movq	%rbp, %rdi
.LEHB7:
	call	_Unwind_Resume@PLT
.LEHE7:
	.cfi_endproc
.LFE6206:
	.section	.gcc_except_table
.LLSDA6206:
	.byte	0xff
	.byte	0xff
	.byte	0x1
	.uleb128 .LLSDACSE6206-.LLSDACSB6206
.LLSDACSB6206:
	.uleb128 .LEHB5-.LFB6206
	.uleb128 .LEHE5-.LEHB5
	.uleb128 0
	.uleb128 0
	.uleb128 .LEHB6-.LFB6206
	.uleb128 .LEHE6-.LEHB6
	.uleb128 .L237-.LFB6206
	.uleb128 0
	.uleb128 .LEHB7-.LFB6206
	.uleb128 .LEHE7-.LEHB7
	.uleb128 0
	.uleb128 0
.LLSDACSE6206:
	.section	.text.startup
	.size	_GLOBAL__sub_I_rng, .-_GLOBAL__sub_I_rng
	.section	.init_array
	.align 8
	.quad	_GLOBAL__sub_I_rng
	.section	.nvFatBinSegment,"aw"
	.align 8
	.type	_ZL15__fatDeviceText, @object
	.size	_ZL15__fatDeviceText, 24
_ZL15__fatDeviceText:
	.long	1180844977
	.long	1
	.quad	fatbinData
	.quad	0
	.local	_ZL20__cudaFatCubinHandle
	.comm	_ZL20__cudaFatCubinHandle,8,8
	.section	__nv_managed_data__,"aw"
	.align 8
	.type	_ZL17noCollisionsCount, @object
	.size	_ZL17noCollisionsCount, 8
_ZL17noCollisionsCount:
	.zero	8
	.align 8
	.type	_ZL12noCollisions, @object
	.size	_ZL12noCollisions, 8
_ZL12noCollisions:
	.zero	8
	.align 8
	.type	_ZL19wallCollisionsCount, @object
	.size	_ZL19wallCollisionsCount, 8
_ZL19wallCollisionsCount:
	.zero	8
	.align 8
	.type	_ZL14wallCollisions, @object
	.size	_ZL14wallCollisions, 8
_ZL14wallCollisions:
	.zero	8
	.align 8
	.type	_ZL23particleCollisionsCount, @object
	.size	_ZL23particleCollisionsCount, 8
_ZL23particleCollisionsCount:
	.zero	8
	.align 8
	.type	_ZL18particleCollisions, @object
	.size	_ZL18particleCollisions, 8
_ZL18particleCollisions:
	.zero	8
	.align 8
	.type	_ZL5found, @object
	.size	_ZL5found, 8
_ZL5found:
	.zero	8
	.align 8
	.type	_ZL4temp, @object
	.size	_ZL4temp, 8
_ZL4temp:
	.zero	8
	.align 8
	.type	_ZL18wallCollisionTimes, @object
	.size	_ZL18wallCollisionTimes, 8
_ZL18wallCollisionTimes:
	.zero	8
	.align 8
	.type	_ZL22particleCollisionTimes, @object
	.size	_ZL22particleCollisionTimes, 8
_ZL22particleCollisionTimes:
	.zero	8
	.align 8
	.type	_ZL9particles, @object
	.size	_ZL9particles, 8
_ZL9particles:
	.zero	8
	.globl	streams
	.bss
	.align 16
	.type	streams, @object
	.size	streams, 16
streams:
	.zero	16
	.section	__nv_managed_data__
	.align 8
	.type	_ZL1s, @object
	.size	_ZL1s, 8
_ZL1s:
	.zero	8
	.align 8
	.type	_ZL1r, @object
	.size	_ZL1r, 8
_ZL1r:
	.zero	8
	.align 8
	.type	_ZL1l, @object
	.size	_ZL1l, 8
_ZL1l:
	.zero	8
	.align 8
	.type	_ZL1n, @object
	.size	_ZL1n, 8
_ZL1n:
	.zero	8
	.globl	rd
	.bss
	.align 32
	.type	rd, @object
	.size	rd, 5000
rd:
	.zero	5000
	.globl	rng
	.align 32
	.type	rng, @object
	.size	rng, 5000
rng:
	.zero	5000
	.local	_ZL32__nv_fatbinhandle_for_managed_rt
	.comm	_ZL32__nv_fatbinhandle_for_managed_rt,8,8
	.local	_ZL22__nv_inited_managed_rt
	.comm	_ZL22__nv_inited_managed_rt,1,1
	.section	.rodata.cst8,"aM",@progbits,8
	.align 8
.LC23:
	.long	0
	.long	1072693248
	.align 8
.LC24:
	.long	-1
	.long	1072693247
	.section	.rodata.cst4,"aM",@progbits,4
	.align 4
.LC25:
	.long	1333788672
	.section	.rodata.cst8
	.align 8
.LC27:
	.long	0
	.long	1070596096
	.hidden	DW.ref.__gxx_personality_v0
	.weak	DW.ref.__gxx_personality_v0
	.section	.data.rel.local.DW.ref.__gxx_personality_v0,"awG",@progbits,DW.ref.__gxx_personality_v0,comdat
	.align 8
	.type	DW.ref.__gxx_personality_v0, @object
	.size	DW.ref.__gxx_personality_v0, 8
DW.ref.__gxx_personality_v0:
	.quad	__gxx_personality_v0
	.hidden	__dso_handle
	.ident	"GCC: (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	1f - 0f
	.long	4f - 1f
	.long	5
0:
	.string	"GNU"
1:
	.align 8
	.long	0xc0000002
	.long	3f - 2f
2:
	.long	0x3
3:
	.align 8
4:


#include <hip/hip_runtime.h>
#include <iostream>
#include <cmath>
#include <vector> 
#include <algorithm>
#include <chrono>
#include <random>
#include <atomic>
#include <stdio.h>

#define NUM_STREAMS 2

using namespace std;

mt19937 rng;
random_device rd;
__managed__ int n, l, r, s;


class Particle
{ 
	public: 
		operator string() const { 
			char buffer [200];
			snprintf(buffer, 200, "%d %.8lf %.8lf %.8lf %.8lf", i, x, y, vX, vY); 
			return buffer;
		}

		int i;
		double x;
		double y;
		double vX;
		double vY; 
		int pColl;
		int wColl;

		Particle() {};

		Particle(int i, double x, double y, double vX, double vY, int l) 
		{
			this -> i = i;
			this -> x = x;
			this -> y = y;
			this -> vX = vX;
			this -> vY = vY;
			this -> pColl = 0;
			this -> wColl = 0;
		}
		__device__ __host__ int getIndex()
		{
			return this->i;
		}
		
		string getFullRepresentation()
		{
			
			char buffer[200];
			snprintf(buffer, 200, "%d %.8lf %.8lf %.8lf %.8lf %d %d", i, x, y, vX, vY, pColl, wColl); 
			string res(buffer);
			return res;
		}
}; 


class CollisionEvent 
{
	public:
		const static int WALL = 0;
		const static int PARTICLE = 1;
		const static int NONE = 2;

		Particle* first;
		Particle* second;
		double time;
		int type;

		__host__ __device__ bool operator == (CollisionEvent other)
		{
			int firstIndex = (*this->first).getIndex();
			int otherFirstIndex = (*other.first).getIndex();
            if (this->second != nullptr)
			{
				int secondIndex = (*this->second).getIndex();
				int otherSecondIndex = (*other.second).getIndex();
		        return (firstIndex == otherSecondIndex && secondIndex == otherFirstIndex) ||
					(firstIndex == otherFirstIndex && secondIndex == otherSecondIndex);
			}
			return (firstIndex == otherFirstIndex);
		}


		__host__ __device__ bool operator < (CollisionEvent other)
		{
			if (this->time == other.getTime()) return this->getSmallestIndex() > other.getSmallestIndex(); 
			return this->time > other.getTime();
		}

		__host__ __device__ CollisionEvent() {}

		__host__ __device__ virtual ~CollisionEvent() {}

		// wall collision event
		__host__ __device__ CollisionEvent(Particle* first, double time)
		{
			this->first = first;
			this->second = nullptr;
			this->time = time;
			this->type = this->WALL;
		}

		// particle collision event
		__host__ __device__ CollisionEvent(Particle* first, Particle* second, double time)
		{
			this->first = first;
			this->second = second;
			this->time = time;
			this->type = this->PARTICLE;
		}

		// no collision event
		__host__ __device__ CollisionEvent(Particle* first)
		{
			this->first = first;
			this->second = nullptr;
			this->time = 1.0;
			this->type = this->NONE;
		}

		__host__ __device__ double getTime()
		{
			return this->time;
		}

		__host__ __device__ int getType()
		{
			return this->type;
		}

		__host__ __device__ double getSmallestIndex()
		{
			if (this->second != nullptr)
			{
				return (*first).getIndex() < (*second).getIndex() ? (*first).getIndex() : (*second).getIndex();
			}
			return (*first).getIndex();
		}
};


// cuda streams
hipStream_t streams[NUM_STREAMS];

// particle objects
__managed__ Particle* particles;

// collision times
__managed__ double** particleCollisionTimes;
__managed__ double* wallCollisionTimes;

// collision events
__managed__ CollisionEvent* temp;
__managed__ int* found;

__managed__ CollisionEvent** particleCollisions;
__managed__ int particleCollisionsCount;

__managed__ CollisionEvent** wallCollisions;
__managed__ int wallCollisionsCount;

__managed__ CollisionEvent** noCollisions;
__managed__ int noCollisionsCount;

// function headers
__host__ void moveParticles(Particle* particles);
__global__ void findEarliestCollision();
__global__ void timeParticleCollision();
__global__ void timeWallCollision();
__global__ void executeParticleCollision();
__global__ void executeWallCollision();
__global__ void executeNoCollision();

__host__ int main (void)
{
	string command;
	cin >> n >> l >> r >> s >> command;

	rng.seed(rd());
	uniform_real_distribution<double> pos(r, l-r);
	uniform_real_distribution<double> velocity((double)l/(8*r), (double)l/4);
	hipError_t cudaStatus = hipMallocManaged(&particles, sizeof(Particle) * n);
	int scanned;
	for (scanned = 0; scanned < n; ++scanned)
	{
		int index; 
		double x;
		double y;
		double vX;
		double vY; 
		int count;
		count = scanf("%d %lf %lf %lf %lf", &index, &x, &y, &vX, &vY);
		if (count == EOF || count <= 0) break;

		particles[scanned] = Particle(index, x, y, vX, vY, l);
	}
	for (int j = scanned; j < n; j++)
	{
		double x = pos(rng);
		double y = pos(rng);
		double vX = velocity(rng);
		double vY = velocity(rng);
		particles[scanned] = Particle(j, x, y, vX, vY, l);
	}


	for (int i = 0; i < NUM_STREAMS; ++i) 
	{
		hipStreamCreate(&streams[i]);
	}
	hipMallocManaged(&particleCollisionTimes, sizeof(double*) * n);
	for (int i = 0; i < n; ++i)
	{
		hipMallocManaged(&particleCollisionTimes[i], sizeof(double) * n);
	}
	hipMallocManaged(&wallCollisionTimes, sizeof(double) * n);
	hipMallocManaged(&found, sizeof(int) * n);
	hipMallocManaged(&particleCollisions, sizeof(CollisionEvent*) * n);
	hipMallocManaged((void**) &particleCollisionsCount, sizeof(int));
	hipMallocManaged(&wallCollisions, sizeof(CollisionEvent*) * n);
	hipMallocManaged((void**) &wallCollisionsCount, sizeof(int));
	hipMallocManaged(&noCollisions, sizeof(CollisionEvent*) * n);
	hipMallocManaged((void**) &noCollisionsCount, sizeof(int));
	hipMallocManaged(&temp, sizeof(CollisionEvent) * n);

	auto start = chrono::high_resolution_clock::now();
	for (int i = 0; i < s; ++i)
	{
		if (!command.compare("print"))
		{
			for (int j = 0; j < n; ++j)
			{
				cout << i << " " << (string) particles[j] << endl;
			}
		}
		moveParticles(particles);
	}

	auto finish = std::chrono::high_resolution_clock::now();
	for (int j = 0; j < n; ++j)
	{
		cout << s << " " << particles[j].getFullRepresentation() << endl;
	}
	double timeTaken = (double)chrono::duration_cast<chrono::nanoseconds>(finish-start).count()/1000000000;
	// printf("Time taken: %.5f s\n", timeTaken);
	return 0;
}


__host__ void moveParticles(Particle* particles) 
{
	for (int i = 0; i < n; ++i) found[i] = -1;
	particleCollisionsCount = 0;	
	wallCollisionsCount = 0;
	noCollisionsCount = 0;
	
	// calculate collision times
	timeWallCollision<<<(n-1)/64+1, 64, 0, streams[0]>>>();
	
	dim3 threadsPerBlock(16, 16, 1);
	dim3 blocksPerGrid((n-1)/16 + 1, (n-1)/16 + 1);
	timeParticleCollision<<<blocksPerGrid, threadsPerBlock, 0, streams[1]>>>();

	hipDeviceSynchronize();
	
	// find valid collisions
	int foundCount = 0;
	while (foundCount != n)
	{  
		findEarliestCollision<<<(n-1)/64+1,64>>>();
		hipDeviceSynchronize();
		for (int i = 0; i < n; ++i)
		{
			if (found[i] != -1) continue;
			CollisionEvent* e = &temp[i];
			// particle-particle collision
			if ((*e).getType() == CollisionEvent::PARTICLE)
			{
				int otherIndex = (*(*e).second).getIndex();
				if (temp[otherIndex].getType() == CollisionEvent::PARTICLE)
				{
					if ((*e) == temp[otherIndex] && i < otherIndex) 
					{
						found[i] = 0;
						found[otherIndex] = 0;
						foundCount += 2;
						particleCollisions[particleCollisionsCount++] = e;
					}
				}
			}
			// particle-wall collision
			else if ((*e).getType() == CollisionEvent::WALL)
			{
				found[i] = 0;
				++foundCount;
				wallCollisions[wallCollisionsCount++] = e;
			}
			// no collision
			else
			{
				found[i] = 0;
				++foundCount;
				noCollisions[noCollisionsCount++] = e;
			}
		}
	}

	// apply valid collisions
	executeParticleCollision<<<(particleCollisionsCount-1)/64+1, 64, 0, streams[0]>>>();
	executeWallCollision<<<(wallCollisionsCount-1)/64+1, 64, 0, streams[1]>>>();
	executeNoCollision<<<(n-1)/64+1, 64, 0, streams[1]>>>(); 
	hipDeviceSynchronize();
}

__global__ void findEarliestCollision()
{
	int index = blockIdx.x * blockDim.x + threadIdx.x;

	if (index >= n || found[index] != -1) return;
	// first assume no collision
	temp[index] = CollisionEvent(&particles[index]);

	// check for particle-wall collision
	if (wallCollisionTimes[index] < temp[index].getTime() && wallCollisionTimes[index] < 1)
	{
		temp[index] = CollisionEvent(&particles[index], wallCollisionTimes[index]);
	}

	// check for particle-particle collision
	for (int j = 0; j < n; ++j)
	{
		if (index == j || found[j] != -1) continue;
        double time = particleCollisionTimes[index][j];

		if (time > -1 && time < temp[index].getTime() && time < 1) {
			temp[index] = CollisionEvent(&particles[index], &particles[j], time);
		}
	}

}


// "input": 2 Particles
// "output": Returns time taken before collision occurs if they collide, negative value otherwise.
__global__ void timeParticleCollision()
{
	int firstIndex = blockIdx.x * blockDim.x + threadIdx.x;
	int secondIndex = blockIdx.y * blockDim.y + threadIdx.y;
	if (firstIndex >= n || secondIndex >= n || firstIndex >= secondIndex) return;
	else
	{
		Particle first = particles[firstIndex];
		Particle second = particles[secondIndex];
		//a, b and c are as in the quadratic formula representation.
		//t, the time taken for the 2 circles to touch, is the unknown variable we are solving for
		//by taking difference in circle centres, setting an unknown t for collision time, and then taking distance moved in time t,
		//we can solve for t such that the circle centers are <= 2r and therefore collide. 4r^2 is to solve for radius distance.
		double c = pow((first.x-second.x), 2) + pow((first.y - second.y), 2) - 4*r*r;
		double b = 2*((first.x - second.x)*(first.vX - second.vX) + (first.y - second.y)*(first.vY-second.vY));
		double a = pow((first.vX-second.vX), 2) + pow((first.vY - second.vY), 2);
		//check for solution
		double solfirst;
		if (b*b-4*a*c < 0)
		{
			solfirst = 100000.0;
		} 
		else
		{
			//else if there is a solution, the one with smaller value should be the main collision. Second value is after the 2 circles phase through each other
			solfirst = (-sqrt(b*b-4*a*c)-b)/(2*a);
			if (solfirst < 0)
			{
				solfirst = (sqrt(b*b-4*a*c)-b)/(2*a);
				if (solfirst > 0) solfirst = 0;
				else solfirst = 100000.0;
			}
		}
		particleCollisionTimes[first.i][second.i] = solfirst;
		particleCollisionTimes[second.i][first.i] = solfirst;
	}
}

// "input": 1 Particle
// "output": Returns time taken before collision occurs if it collides with wall, negative value otherwise.
__global__ void timeWallCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex >=n) {
		return;
	}
	else
	{
		Particle particle = particles[particleIndex];
		//check for x wall, y wall collisions
		double xCollide = particle.vX < 0 ? (particle.x-r)/(0-particle.vX) : ((double)l-particle.x-r)/particle.vX;
		double yCollide = particle.vY < 0 ? (particle.y-r)/(0-particle.vY) : ((double)l-particle.y-r)/particle.vY;
		wallCollisionTimes[particle.i] = fmin(xCollide, yCollide);
	}
}

__global__ void executeParticleCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex < particleCollisionsCount)
	{
		CollisionEvent *e = particleCollisions[particleIndex];
		Particle *first = e->first;
		Particle *second = e->second;
		double time = e->time;
		if (first->getIndex() >= second->getIndex())
			return;
		//move them to proper position first
		first->x += time * first->vX;
		first->y += time * first->vY;
		second->x += time * second->vX;
		second->y += time * second->vY;

		//perform collision here
		//find normal vector
		double normalX = first->x - second->x;
		double normalY = first->y - second->y;
		double normalMag = sqrt(pow(normalX, 2) + pow(normalY, 2));
		normalX = normalX/normalMag; normalY = normalY/normalMag;
		double tangentX = -normalY;
		double tangentY = normalX;
		//compute velocity vectors wrt to normal and tangent
		double vFirstNormal = normalX * first->vX + normalY * first->vY;
		double vFirstTangent = tangentX * first->vX + tangentY * first->vY;
		double vSecondNormal = normalX * second->vX + normalY * second->vY;
		double vSecondTangent = tangentX * second->vX + tangentY * second->vY;
		//collision simply swaps velocities
		double temp = vFirstNormal;
		vFirstNormal = vSecondNormal;
		vSecondNormal = temp;
		first->vX = vFirstNormal * normalX + vFirstTangent * tangentX;
		first->vY = vFirstNormal * normalY + vFirstTangent * tangentY;
		second->vX = vSecondNormal * normalX + vSecondTangent * tangentX;
		second->vY = vSecondNormal * normalY + vSecondTangent * tangentY;
		//eliminate negative 0s
		if (first->vX == -0.0) first->vX = 0.0;
		if (first->vY == -0.0) first->vY = 0.0;
		if (second->vX == -0.0) second->vX = 0.0;
		if (second->vY == -0.0) second->vY = 0.0;
		//Continue to move them here
		//Check for wall collisions and stop the particle at wall if so
		double timeToMove;
		double xCollide = first->vX < 0 ? (first->x-r)/(0-first->vX) : ((double)l-r-first->x)/first->vX;
		double yCollide = first->vY < 0 ? (first->y-r)/(0-first->vY) : ((double)l-r-first->y)/first->vY;
		if (xCollide >= 1-time && yCollide >= 1-time) 
		{
			timeToMove = 1-time;
		}
		else
		{
			timeToMove = fmin(xCollide, yCollide);
		}
		first->x += timeToMove * first->vX;
		first->y += timeToMove * first->vY;
		
		xCollide = second->vX < 0 ? (second->x-r)/(0-second->vX) : ((double)l-r-second->x)/second->vX;
		yCollide = second->vY < 0 ? (second->y-r)/(0-second->vY) : ((double)l-r-second->y)/second->vY;
		if (xCollide >= 1-time && yCollide >= 1-time) 
		{
			timeToMove = 1-time;
		}
		else
		{
			timeToMove = fmin(xCollide, yCollide);
		}
		second->x += timeToMove * second->vX;
		second->y += timeToMove * second->vY;
		first->pColl++;
		second->pColl++;
	}
}

__global__ void executeWallCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex < wallCollisionsCount)
	{
		CollisionEvent *e = wallCollisions[particleIndex];
		Particle *first = e->first;
		//check for x wall collisions
		//check for y wall collisions
		double xCollide = first->vX < 0 ? (first->x-r)/(0-first->vX) : ((double)l-first->x-r)/first->vX;
		double yCollide = first->vY < 0 ? (first->y-r)/(0-first->vY) : ((double)l-first->y-r)/first->vY;
		double earlierTime = fmin(xCollide, yCollide);
		double laterTime = fmax(xCollide, yCollide);
		first->x += earlierTime * first->vX;
		first->y += earlierTime * first->vY;
		//Reverse direction depending on which collision happens first
		if (xCollide <= yCollide) {
			first->vX = -first->vX;
		}	
		if (yCollide <= xCollide) {
			first->vY = -first->vY;
		}
		//artificially set timing to allow particle to continue after hitting corner
		if (xCollide == yCollide) {
			laterTime = 1;
		}
		first->x += (fmin(1.0, laterTime)-earlierTime) * first->vX;	
		first->y += (fmin(1.0, laterTime)-earlierTime) * first->vY;
		first->wColl++;
	}
}

__global__ void executeNoCollision()
{
	int particleIndex = blockIdx.x * blockDim.x + threadIdx.x;
	if (particleIndex < noCollisionsCount)
	{
		CollisionEvent *e = noCollisions[particleIndex];
		Particle *first = e->first;
		first->x += first->vX;
		first->y += first->vY;
	}
}

	.text
	.file	"cuda-simulator.hip"
                                        # Start of file scope inline assembly
	.globl	_ZSt21ios_base_library_initv

                                        # End of file scope inline assembly
	.section	.text._ZNSt13random_deviceC2Ev,"axG",@progbits,_ZNSt13random_deviceC2Ev,comdat
	.weak	_ZNSt13random_deviceC2Ev        # -- Begin function _ZNSt13random_deviceC2Ev
	.p2align	1, 0x90
	.type	_ZNSt13random_deviceC2Ev,@function
_ZNSt13random_deviceC2Ev:               # @_ZNSt13random_deviceC2Ev
.Lfunc_begin0:
	.cfi_startproc
	.cfi_personality 3, __gxx_personality_v0
	.cfi_lsda 3, .Lexception0
# %bb.0:                                # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_.exit
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%rbx
	.cfi_def_cfa_offset 32
	subq	$32, %rsp
	.cfi_def_cfa_offset 64
	.cfi_offset %rbx, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	movq	%rdi, %rbx
	leaq	16(%rsp), %r15
	movq	%r15, -16(%r15)
	movq	%rsp, %r14
	movl	$.L.str.4, %esi
	movl	$.L.str.4+7, %edx
	movq	%r14, %rdi
	callq	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag
.Ltmp0:
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
.Ltmp1:
# %bb.1:
	movq	(%rsp), %rdi
	cmpq	%r15, %rdi
	je	.LBB0_3
# %bb.2:                                # %_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv.exit.i.i
	callq	_ZdlPv
.LBB0_3:                                # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev.exit
	addq	$32, %rsp
	.cfi_def_cfa_offset 32
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.LBB0_4:
	.cfi_def_cfa_offset 64
.Ltmp2:
	movq	%rax, %rbx
	movq	(%rsp), %rdi
	cmpq	%r15, %rdi
	je	.LBB0_6
# %bb.5:                                # %_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv.exit.i.i4
	callq	_ZdlPv
.LBB0_6:                                # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev.exit6
	movq	%rbx, %rdi
	callq	_Unwind_Resume@PLT
.Lfunc_end0:
	.size	_ZNSt13random_deviceC2Ev, .Lfunc_end0-_ZNSt13random_deviceC2Ev
	.cfi_endproc
	.section	.gcc_except_table._ZNSt13random_deviceC2Ev,"aG",@progbits,_ZNSt13random_deviceC2Ev,comdat
	.p2align	2, 0x0
GCC_except_table0:
.Lexception0:
	.byte	255                             # @LPStart Encoding = omit
	.byte	255                             # @TType Encoding = omit
	.byte	1                               # Call site Encoding = uleb128
	.uleb128 .Lcst_end0-.Lcst_begin0
.Lcst_begin0:
	.uleb128 .Lfunc_begin0-.Lfunc_begin0    # >> Call Site 1 <<
	.uleb128 .Ltmp0-.Lfunc_begin0           #   Call between .Lfunc_begin0 and .Ltmp0
	.byte	0                               #     has no landing pad
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp0-.Lfunc_begin0           # >> Call Site 2 <<
	.uleb128 .Ltmp1-.Ltmp0                  #   Call between .Ltmp0 and .Ltmp1
	.uleb128 .Ltmp2-.Lfunc_begin0           #     jumps to .Ltmp2
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp1-.Lfunc_begin0           # >> Call Site 3 <<
	.uleb128 .Lfunc_end0-.Ltmp1             #   Call between .Ltmp1 and .Lfunc_end0
	.byte	0                               #     has no landing pad
	.byte	0                               #   On action: cleanup
.Lcst_end0:
	.p2align	2, 0x0
                                        # -- End function
	.section	.text._ZNSt13random_deviceD2Ev,"axG",@progbits,_ZNSt13random_deviceD2Ev,comdat
	.weak	_ZNSt13random_deviceD2Ev        # -- Begin function _ZNSt13random_deviceD2Ev
	.p2align	1, 0x90
	.type	_ZNSt13random_deviceD2Ev,@function
_ZNSt13random_deviceD2Ev:               # @_ZNSt13random_deviceD2Ev
.Lfunc_begin1:
	.cfi_startproc
	.cfi_personality 3, __gxx_personality_v0
	.cfi_lsda 3, .Lexception1
# %bb.0:
	pushq	%rax
	.cfi_def_cfa_offset 16
.Ltmp3:
	callq	_ZNSt13random_device7_M_finiEv
.Ltmp4:
# %bb.1:
	popq	%rax
	.cfi_def_cfa_offset 8
	retq
.LBB1_2:
	.cfi_def_cfa_offset 16
.Ltmp5:
	movq	%rax, %rdi
	callq	__clang_call_terminate
.Lfunc_end1:
	.size	_ZNSt13random_deviceD2Ev, .Lfunc_end1-_ZNSt13random_deviceD2Ev
	.cfi_endproc
	.section	.gcc_except_table._ZNSt13random_deviceD2Ev,"aG",@progbits,_ZNSt13random_deviceD2Ev,comdat
	.p2align	2, 0x0
GCC_except_table1:
.Lexception1:
	.byte	255                             # @LPStart Encoding = omit
	.byte	3                               # @TType Encoding = udata4
	.uleb128 .Lttbase0-.Lttbaseref0
.Lttbaseref0:
	.byte	1                               # Call site Encoding = uleb128
	.uleb128 .Lcst_end1-.Lcst_begin1
.Lcst_begin1:
	.uleb128 .Ltmp3-.Lfunc_begin1           # >> Call Site 1 <<
	.uleb128 .Ltmp4-.Ltmp3                  #   Call between .Ltmp3 and .Ltmp4
	.uleb128 .Ltmp5-.Lfunc_begin1           #     jumps to .Ltmp5
	.byte	1                               #   On action: 1
.Lcst_end1:
	.byte	1                               # >> Action Record 1 <<
                                        #   Catch TypeInfo 1
	.byte	0                               #   No further actions
	.p2align	2, 0x0
                                        # >> Catch TypeInfos <<
	.long	0                               # TypeInfo 1
.Lttbase0:
	.p2align	2, 0x0
                                        # -- End function
	.section	.rodata.cst8,"aM",@progbits,8
	.p2align	3, 0x0                          # -- Begin function main
.LCPI2_0:
	.quad	0x3fd0000000000000              # double 0.25
	.text
	.globl	main
	.type	main,@function
main:                                   # @main
.Lfunc_begin2:
	.cfi_startproc
	.cfi_personality 3, __gxx_personality_v0
	.cfi_lsda 3, .Lexception2
# %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	pushq	%r15
	.cfi_def_cfa_offset 24
	pushq	%r14
	.cfi_def_cfa_offset 32
	pushq	%r13
	.cfi_def_cfa_offset 40
	pushq	%r12
	.cfi_def_cfa_offset 48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	subq	$152, %rsp
	.cfi_def_cfa_offset 208
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	leaq	136(%rsp), %rax
	movq	%rax, -16(%rax)
	movq	$0, -8(%rax)
	movb	$0, (%rax)
	movq	n(%rip), %rsi
.Ltmp6:
	movl	$_ZSt3cin, %edi
	callq	_ZNSirsERi
.Ltmp7:
# %bb.1:
	movq	l(%rip), %rsi
.Ltmp8:
	movq	%rax, %rdi
	callq	_ZNSirsERi
.Ltmp9:
# %bb.2:
	movq	r(%rip), %rsi
.Ltmp10:
	movq	%rax, %rdi
	callq	_ZNSirsERi
.Ltmp11:
# %bb.3:
	movq	s(%rip), %rsi
.Ltmp12:
	movq	%rax, %rdi
	callq	_ZNSirsERi
.Ltmp13:
# %bb.4:
.Ltmp14:
	leaq	120(%rsp), %rsi
	movq	%rax, %rdi
	callq	_ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE
.Ltmp15:
# %bb.5:
.Ltmp16:
	movl	$rd, %edi
	callq	_ZNSt13random_device9_M_getvalEv
.Ltmp17:
# %bb.6:                                # %_ZNSt13random_deviceclEv.exit
	movl	%eax, %eax
	movq	%rax, rng(%rip)
	movl	$1, %ecx
.LBB2_7:                                # =>This Inner Loop Header: Depth=1
	movq	%rax, %rdx
	shrq	$30, %rdx
	xorl	%eax, %edx
	imull	$1812433253, %edx, %eax         # imm = 0x6C078965
	addl	%ecx, %eax
	movq	%rax, rng(,%rcx,8)
	incq	%rcx
	cmpq	$624, %rcx                      # imm = 0x270
	jne	.LBB2_7
# %bb.8:
	movq	$624, rng+4992(%rip)            # imm = 0x270
	movq	r(%rip), %rax
	movl	(%rax), %ebx
	movq	l(%rip), %rax
	movl	(%rax), %r14d
	movq	n(%rip), %rax
	movslq	(%rax), %rax
	shlq	$4, %rax
	leaq	(%rax,%rax,2), %rsi
	movq	particles(%rip), %rdi
.Ltmp19:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp20:
# %bb.9:                                # %_ZL16hipMallocManagedI8ParticleE10hipError_tPPT_mj.exit.preheader
	movq	n(%rip), %rax
	movl	(%rax), %eax
	testl	%eax, %eax
	jle	.LBB2_10
# %bb.11:                               # %.lr.ph.preheader
	movl	%r14d, (%rsp)                   # 4-byte Spill
	movl	%ebx, 8(%rsp)                   # 4-byte Spill
	movl	$44, %ebx
	leaq	24(%rsp), %r14
	leaq	112(%rsp), %r15
	leaq	104(%rsp), %r12
	leaq	96(%rsp), %r13
	xorl	%ebp, %ebp
.LBB2_12:                               # %.lr.ph
                                        # =>This Inner Loop Header: Depth=1
.Ltmp22:
	movl	$.L.str, %edi
	leaq	20(%rsp), %rsi
	movq	%r14, %rdx
	movq	%r15, %rcx
	movq	%r12, %r8
	movq	%r13, %r9
	xorl	%eax, %eax
	callq	__isoc23_scanf
.Ltmp23:
# %bb.13:                               #   in Loop: Header=BB2_12 Depth=1
	testl	%eax, %eax
	jle	.LBB2_14
# %bb.17:                               # %_ZL16hipMallocManagedI8ParticleE10hipError_tPPT_mj.exit
                                        #   in Loop: Header=BB2_12 Depth=1
	movl	20(%rsp), %eax
	movsd	24(%rsp), %xmm0                 # xmm0 = mem[0],zero
	movsd	112(%rsp), %xmm1                # xmm1 = mem[0],zero
	movsd	104(%rsp), %xmm2                # xmm2 = mem[0],zero
	movsd	96(%rsp), %xmm3                 # xmm3 = mem[0],zero
	movq	particles(%rip), %rcx
	movq	(%rcx), %rcx
	movl	%eax, -44(%rcx,%rbx)
	movsd	%xmm0, -36(%rcx,%rbx)
	movsd	%xmm1, -28(%rcx,%rbx)
	movsd	%xmm2, -20(%rcx,%rbx)
	movsd	%xmm3, -12(%rcx,%rbx)
	movq	$0, -4(%rcx,%rbx)
	incq	%rbp
	movq	n(%rip), %rax
	movslq	(%rax), %rax
	addq	$48, %rbx
	cmpq	%rax, %rbp
	jl	.LBB2_12
	jmp	.LBB2_18
.LBB2_10:
	xorl	%ebp, %ebp
	jmp	.LBB2_19
.LBB2_14:
	movq	n(%rip), %rax
	movl	(%rax), %eax
.LBB2_18:                               # %.loopexit130.loopexit
	movl	8(%rsp), %ebx                   # 4-byte Reload
	movl	(%rsp), %r14d                   # 4-byte Reload
.LBB2_19:                               # %.loopexit130
	cmpl	%eax, %ebp
	jge	.LBB2_26
# %bb.20:                               # %.lr.ph139
	xorps	%xmm1, %xmm1
	cvtsi2sd	%ebx, %xmm1
	xorps	%xmm2, %xmm2
	cvtsi2sd	%r14d, %xmm2
	subl	%ebx, %r14d
	xorps	%xmm3, %xmm3
	cvtsi2sd	%r14d, %xmm3
	shll	$3, %ebx
	xorps	%xmm0, %xmm0
	cvtsi2sd	%ebx, %xmm0
	movapd	%xmm2, %xmm4
	divsd	%xmm0, %xmm4
	mulsd	.LCPI2_0(%rip), %xmm2
	movsd	%xmm1, 80(%rsp)                 # 8-byte Spill
	subsd	%xmm1, %xmm3
	movsd	%xmm3, 64(%rsp)                 # 8-byte Spill
	movsd	%xmm4, 56(%rsp)                 # 8-byte Spill
	subsd	%xmm4, %xmm2
	movsd	%xmm2, 72(%rsp)                 # 8-byte Spill
	movl	%ebp, %eax
	leaq	(%rax,%rax,2), %rbx
	shlq	$4, %rbx
.LBB2_21:                               # =>This Inner Loop Header: Depth=1
.Ltmp25:
	movl	$rng, %edi
	callq	_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
	movsd	%xmm0, 8(%rsp)                  # 8-byte Spill
.Ltmp26:
# %bb.22:                               #   in Loop: Header=BB2_21 Depth=1
.Ltmp28:
	movl	$rng, %edi
	callq	_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
	movsd	%xmm0, (%rsp)                   # 8-byte Spill
.Ltmp29:
# %bb.23:                               #   in Loop: Header=BB2_21 Depth=1
.Ltmp31:
	movl	$rng, %edi
	callq	_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
	movsd	%xmm0, 88(%rsp)                 # 8-byte Spill
.Ltmp32:
# %bb.24:                               #   in Loop: Header=BB2_21 Depth=1
.Ltmp34:
	movl	$rng, %edi
	callq	_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
.Ltmp35:
# %bb.25:                               #   in Loop: Header=BB2_21 Depth=1
	movsd	64(%rsp), %xmm2                 # 8-byte Reload
                                        # xmm2 = mem[0],zero
	movsd	8(%rsp), %xmm3                  # 8-byte Reload
                                        # xmm3 = mem[0],zero
	mulsd	%xmm2, %xmm3
	movsd	80(%rsp), %xmm1                 # 8-byte Reload
                                        # xmm1 = mem[0],zero
	addsd	%xmm1, %xmm3
	movsd	(%rsp), %xmm4                   # 8-byte Reload
                                        # xmm4 = mem[0],zero
	mulsd	%xmm2, %xmm4
	addsd	%xmm1, %xmm4
	movsd	72(%rsp), %xmm1                 # 8-byte Reload
                                        # xmm1 = mem[0],zero
	movsd	88(%rsp), %xmm5                 # 8-byte Reload
                                        # xmm5 = mem[0],zero
	mulsd	%xmm1, %xmm5
	movsd	56(%rsp), %xmm2                 # 8-byte Reload
                                        # xmm2 = mem[0],zero
	addsd	%xmm2, %xmm5
	mulsd	%xmm1, %xmm0
	addsd	%xmm2, %xmm0
	movq	particles(%rip), %rax
	movq	(%rax), %rax
	movl	%ebp, (%rax,%rbx)
	movsd	%xmm3, 8(%rax,%rbx)
	movsd	%xmm4, 16(%rax,%rbx)
	movsd	%xmm5, 24(%rax,%rbx)
	movsd	%xmm0, 32(%rax,%rbx)
	movq	$0, 40(%rax,%rbx)
	incl	%ebp
	movq	n(%rip), %rax
	cmpl	(%rax), %ebp
	jl	.LBB2_21
.LBB2_26:                               # %.preheader129
.Ltmp37:
	movl	$streams, %edi
	callq	hipStreamCreate
.Ltmp38:
# %bb.27:
.Ltmp39:
	movl	$streams+8, %edi
	callq	hipStreamCreate
.Ltmp40:
# %bb.28:
	movq	n(%rip), %rax
	movslq	(%rax), %rsi
	shlq	$3, %rsi
	movq	particleCollisionTimes(%rip), %rdi
.Ltmp42:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp43:
# %bb.29:                               # %_ZL16hipMallocManagedIPdE10hipError_tPPT_mj.exit.preheader
	movq	n(%rip), %rax
	movslq	(%rax), %rsi
	testq	%rsi, %rsi
	jle	.LBB2_33
# %bb.30:                               # %.lr.ph142.preheader
	xorl	%ebx, %ebx
	xorl	%r14d, %r14d
	movl	%esi, %eax
.LBB2_31:                               # %.lr.ph142
                                        # =>This Inner Loop Header: Depth=1
	movq	particleCollisionTimes(%rip), %rcx
	movq	(%rcx), %rdi
	addq	%rbx, %rdi
	movslq	%eax, %rsi
	shlq	$3, %rsi
.Ltmp44:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp45:
# %bb.32:                               # %_ZL16hipMallocManagedIdE10hipError_tPPT_mj.exit79
                                        #   in Loop: Header=BB2_31 Depth=1
	incq	%r14
	movq	n(%rip), %rax
	movl	(%rax), %eax
	movslq	%eax, %rsi
	addq	$8, %rbx
	cmpq	%rsi, %r14
	jl	.LBB2_31
.LBB2_33:                               # %_ZL16hipMallocManagedIPdE10hipError_tPPT_mj.exit._crit_edge
	shlq	$3, %rsi
	movq	wallCollisionTimes(%rip), %rdi
.Ltmp47:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp48:
# %bb.34:                               # %_ZL16hipMallocManagedIdE10hipError_tPPT_mj.exit
	movq	n(%rip), %rax
	movslq	(%rax), %rsi
	shlq	$2, %rsi
	movq	found(%rip), %rdi
.Ltmp49:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp50:
# %bb.35:                               # %_ZL16hipMallocManagedIiE10hipError_tPPT_mj.exit
	movq	n(%rip), %rax
	movslq	(%rax), %rsi
	shlq	$3, %rsi
	movq	particleCollisions(%rip), %rdi
.Ltmp51:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp52:
# %bb.36:                               # %_ZL16hipMallocManagedIP14CollisionEventE10hipError_tPPT_mj.exit
	movq	particleCollisionsCount(%rip), %rdi
.Ltmp53:
	movl	$4, %esi
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp54:
# %bb.37:
	movq	n(%rip), %rax
	movslq	(%rax), %rsi
	shlq	$3, %rsi
	movq	wallCollisions(%rip), %rdi
.Ltmp55:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp56:
# %bb.38:                               # %_ZL16hipMallocManagedIP14CollisionEventE10hipError_tPPT_mj.exit80
	movq	wallCollisionsCount(%rip), %rdi
.Ltmp57:
	movl	$4, %esi
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp58:
# %bb.39:
	movq	n(%rip), %rax
	movslq	(%rax), %rsi
	shlq	$3, %rsi
	movq	noCollisions(%rip), %rdi
.Ltmp59:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp60:
# %bb.40:                               # %_ZL16hipMallocManagedIP14CollisionEventE10hipError_tPPT_mj.exit81
	movq	noCollisionsCount(%rip), %rdi
.Ltmp61:
	movl	$4, %esi
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp62:
# %bb.41:
	movq	n(%rip), %rax
	movslq	(%rax), %rax
	shlq	$3, %rax
	leaq	(%rax,%rax,4), %rsi
	movq	temp(%rip), %rdi
.Ltmp63:
	movl	$1, %edx
	callq	hipMallocManaged
.Ltmp64:
# %bb.42:                               # %_ZL16hipMallocManagedI14CollisionEventE10hipError_tPPT_mj.exit
	callq	_ZNSt6chrono3_V212system_clock3nowEv
	movq	s(%rip), %rax
	cmpl	$0, (%rax)
	leaq	40(%rsp), %r13
	jle	.LBB2_59
# %bb.43:                               # %.lr.ph147
	xorl	%ebx, %ebx
	leaq	24(%rsp), %r15
.LBB2_44:                               # =>This Loop Header: Depth=1
                                        #     Child Loop BB2_47 Depth 2
	movl	$.L.str.2, %esi
	leaq	120(%rsp), %rdi
	callq	_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc
	testl	%eax, %eax
	jne	.LBB2_57
# %bb.45:                               # %.preheader
                                        #   in Loop: Header=BB2_44 Depth=1
	movq	n(%rip), %rax
	cmpl	$0, (%rax)
	jle	.LBB2_57
# %bb.46:                               # %.lr.ph145.preheader
                                        #   in Loop: Header=BB2_44 Depth=1
	xorl	%ebp, %ebp
	xorl	%r14d, %r14d
.LBB2_47:                               # %.lr.ph145
                                        #   Parent Loop BB2_44 Depth=1
                                        # =>  This Inner Loop Header: Depth=2
.Ltmp66:
	movl	$_ZSt4cout, %edi
	movl	%ebx, %esi
	callq	_ZNSolsEi
.Ltmp67:
# %bb.48:                               #   in Loop: Header=BB2_47 Depth=2
.Ltmp68:
	movq	%rax, %r12
	movl	$.L.str.3, %esi
	movl	$1, %edx
	movq	%rax, %rdi
	callq	_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
.Ltmp69:
# %bb.49:                               # %_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc.exit
                                        #   in Loop: Header=BB2_47 Depth=2
	movq	particles(%rip), %rax
	movq	(%rax), %rsi
	addq	%rbp, %rsi
.Ltmp71:
	movq	%r15, %rdi
	callq	_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
.Ltmp72:
# %bb.50:                               #   in Loop: Header=BB2_47 Depth=2
	movq	24(%rsp), %rsi
	movq	32(%rsp), %rdx
.Ltmp74:
	movq	%r12, %rdi
	callq	_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
.Ltmp75:
# %bb.51:                               # %_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE.exit
                                        #   in Loop: Header=BB2_47 Depth=2
	movq	%rax, %r12
	movq	(%rax), %rax
	movq	-24(%rax), %rdi
	addq	%r12, %rdi
.Ltmp76:
	movl	$10, %esi
	callq	_ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc
.Ltmp77:
# %bb.52:                               # %.noexc
                                        #   in Loop: Header=BB2_47 Depth=2
.Ltmp78:
	movsbl	%al, %esi
	movq	%r12, %rdi
	callq	_ZNSo3putEc
.Ltmp79:
# %bb.53:                               # %.noexc100
                                        #   in Loop: Header=BB2_47 Depth=2
.Ltmp80:
	movq	%rax, %rdi
	callq	_ZNSo5flushEv
.Ltmp81:
# %bb.54:                               # %_ZNSolsEPFRSoS_E.exit
                                        #   in Loop: Header=BB2_47 Depth=2
	movq	24(%rsp), %rdi
	cmpq	%r13, %rdi
	je	.LBB2_56
# %bb.55:                               # %_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv.exit.i.i
                                        #   in Loop: Header=BB2_47 Depth=2
	callq	_ZdlPv
.LBB2_56:                               # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev.exit
                                        #   in Loop: Header=BB2_47 Depth=2
	incq	%r14
	movq	n(%rip), %rax
	movslq	(%rax), %rax
	addq	$48, %rbp
	cmpq	%rax, %r14
	jl	.LBB2_47
.LBB2_57:                               # %.loopexit
                                        #   in Loop: Header=BB2_44 Depth=1
.Ltmp83:
	callq	_Z13moveParticlesP8Particle
.Ltmp84:
# %bb.58:                               #   in Loop: Header=BB2_44 Depth=1
	incl	%ebx
	movq	s(%rip), %rax
	cmpl	(%rax), %ebx
	jl	.LBB2_44
.LBB2_59:                               # %._crit_edge
	callq	_ZNSt6chrono3_V212system_clock3nowEv
	movq	n(%rip), %rax
	cmpl	$0, (%rax)
	jle	.LBB2_71
# %bb.60:                               # %.lr.ph150
	xorl	%r15d, %r15d
	leaq	24(%rsp), %rbx
	xorl	%r12d, %r12d
.LBB2_61:                               # =>This Inner Loop Header: Depth=1
	movq	s(%rip), %rax
	movl	(%rax), %esi
.Ltmp86:
	movl	$_ZSt4cout, %edi
	callq	_ZNSolsEi
.Ltmp87:
# %bb.62:                               #   in Loop: Header=BB2_61 Depth=1
.Ltmp88:
	movq	%rax, %r14
	movl	$.L.str.3, %esi
	movl	$1, %edx
	movq	%rax, %rdi
	callq	_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
.Ltmp89:
# %bb.63:                               # %_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc.exit85
                                        #   in Loop: Header=BB2_61 Depth=1
	movq	particles(%rip), %rax
	movq	(%rax), %rsi
	addq	%r15, %rsi
.Ltmp91:
	movq	%rbx, %rdi
	callq	_ZN8Particle21getFullRepresentationB5cxx11Ev
.Ltmp92:
# %bb.64:                               #   in Loop: Header=BB2_61 Depth=1
	movq	24(%rsp), %rsi
	movq	32(%rsp), %rdx
.Ltmp94:
	movq	%r14, %rdi
	callq	_ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
.Ltmp95:
# %bb.65:                               # %_ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE.exit86
                                        #   in Loop: Header=BB2_61 Depth=1
	movq	%rax, %r14
	movq	(%rax), %rax
	movq	-24(%rax), %rdi
	addq	%r14, %rdi
.Ltmp96:
	movl	$10, %esi
	callq	_ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc
.Ltmp97:
# %bb.66:                               # %.noexc102
                                        #   in Loop: Header=BB2_61 Depth=1
.Ltmp98:
	movsbl	%al, %esi
	movq	%r14, %rdi
	callq	_ZNSo3putEc
.Ltmp99:
# %bb.67:                               # %.noexc103
                                        #   in Loop: Header=BB2_61 Depth=1
.Ltmp100:
	movq	%rax, %rdi
	callq	_ZNSo5flushEv
.Ltmp101:
# %bb.68:                               # %_ZNSolsEPFRSoS_E.exit87
                                        #   in Loop: Header=BB2_61 Depth=1
	movq	24(%rsp), %rdi
	cmpq	%r13, %rdi
	je	.LBB2_70
# %bb.69:                               # %_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv.exit.i.i88
                                        #   in Loop: Header=BB2_61 Depth=1
	callq	_ZdlPv
.LBB2_70:                               # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev.exit90
                                        #   in Loop: Header=BB2_61 Depth=1
	incq	%r12
	movq	n(%rip), %rax
	movslq	(%rax), %rax
	addq	$48, %r15
	cmpq	%rax, %r12
	jl	.LBB2_61
.LBB2_71:                               # %._crit_edge151
	movq	120(%rsp), %rdi
	leaq	136(%rsp), %rax
	cmpq	%rax, %rdi
	je	.LBB2_73
# %bb.72:                               # %_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv.exit.i.i94
	callq	_ZdlPv
.LBB2_73:                               # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev.exit96
	xorl	%eax, %eax
	addq	$152, %rsp
	.cfi_def_cfa_offset 56
	popq	%rbx
	.cfi_def_cfa_offset 48
	popq	%r12
	.cfi_def_cfa_offset 40
	popq	%r13
	.cfi_def_cfa_offset 32
	popq	%r14
	.cfi_def_cfa_offset 24
	popq	%r15
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	retq
.LBB2_15:
	.cfi_def_cfa_offset 208
.Ltmp21:
	jmp	.LBB2_91
.LBB2_78:
.Ltmp41:
	jmp	.LBB2_91
.LBB2_90:
.Ltmp18:
	jmp	.LBB2_91
.LBB2_79:
.Ltmp65:
	jmp	.LBB2_91
.LBB2_16:
.Ltmp24:
	jmp	.LBB2_91
.LBB2_74:
.Ltmp27:
	jmp	.LBB2_91
.LBB2_75:
.Ltmp30:
	jmp	.LBB2_91
.LBB2_76:
.Ltmp33:
	jmp	.LBB2_91
.LBB2_77:
.Ltmp36:
	jmp	.LBB2_91
.LBB2_86:
.Ltmp85:
	jmp	.LBB2_91
.LBB2_88:
.Ltmp93:
	jmp	.LBB2_91
.LBB2_80:
.Ltmp46:
	jmp	.LBB2_91
.LBB2_87:
.Ltmp90:
	jmp	.LBB2_91
.LBB2_89:
.Ltmp102:
	jmp	.LBB2_84
.LBB2_82:
.Ltmp73:
	jmp	.LBB2_91
.LBB2_81:
.Ltmp70:
.LBB2_91:
	movq	%rax, %rbx
	jmp	.LBB2_92
.LBB2_83:
.Ltmp82:
.LBB2_84:
	movq	%rax, %rbx
	movq	24(%rsp), %rdi
	cmpq	%r13, %rdi
	je	.LBB2_92
# %bb.85:                               # %_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv.exit.i.i82
	callq	_ZdlPv
.LBB2_92:
	movq	120(%rsp), %rdi
	leaq	136(%rsp), %rax
	cmpq	%rax, %rdi
	je	.LBB2_94
# %bb.93:                               # %_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv.exit.i.i97
	callq	_ZdlPv
.LBB2_94:                               # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev.exit99
	movq	%rbx, %rdi
	callq	_Unwind_Resume@PLT
.Lfunc_end2:
	.size	main, .Lfunc_end2-main
	.cfi_endproc
	.section	.gcc_except_table,"a",@progbits
	.p2align	2, 0x0
GCC_except_table2:
.Lexception2:
	.byte	255                             # @LPStart Encoding = omit
	.byte	255                             # @TType Encoding = omit
	.byte	1                               # Call site Encoding = uleb128
	.uleb128 .Lcst_end2-.Lcst_begin2
.Lcst_begin2:
	.uleb128 .Ltmp6-.Lfunc_begin2           # >> Call Site 1 <<
	.uleb128 .Ltmp17-.Ltmp6                 #   Call between .Ltmp6 and .Ltmp17
	.uleb128 .Ltmp18-.Lfunc_begin2          #     jumps to .Ltmp18
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp19-.Lfunc_begin2          # >> Call Site 2 <<
	.uleb128 .Ltmp20-.Ltmp19                #   Call between .Ltmp19 and .Ltmp20
	.uleb128 .Ltmp21-.Lfunc_begin2          #     jumps to .Ltmp21
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp22-.Lfunc_begin2          # >> Call Site 3 <<
	.uleb128 .Ltmp23-.Ltmp22                #   Call between .Ltmp22 and .Ltmp23
	.uleb128 .Ltmp24-.Lfunc_begin2          #     jumps to .Ltmp24
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp25-.Lfunc_begin2          # >> Call Site 4 <<
	.uleb128 .Ltmp26-.Ltmp25                #   Call between .Ltmp25 and .Ltmp26
	.uleb128 .Ltmp27-.Lfunc_begin2          #     jumps to .Ltmp27
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp28-.Lfunc_begin2          # >> Call Site 5 <<
	.uleb128 .Ltmp29-.Ltmp28                #   Call between .Ltmp28 and .Ltmp29
	.uleb128 .Ltmp30-.Lfunc_begin2          #     jumps to .Ltmp30
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp31-.Lfunc_begin2          # >> Call Site 6 <<
	.uleb128 .Ltmp32-.Ltmp31                #   Call between .Ltmp31 and .Ltmp32
	.uleb128 .Ltmp33-.Lfunc_begin2          #     jumps to .Ltmp33
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp34-.Lfunc_begin2          # >> Call Site 7 <<
	.uleb128 .Ltmp35-.Ltmp34                #   Call between .Ltmp34 and .Ltmp35
	.uleb128 .Ltmp36-.Lfunc_begin2          #     jumps to .Ltmp36
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp37-.Lfunc_begin2          # >> Call Site 8 <<
	.uleb128 .Ltmp40-.Ltmp37                #   Call between .Ltmp37 and .Ltmp40
	.uleb128 .Ltmp41-.Lfunc_begin2          #     jumps to .Ltmp41
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp42-.Lfunc_begin2          # >> Call Site 9 <<
	.uleb128 .Ltmp43-.Ltmp42                #   Call between .Ltmp42 and .Ltmp43
	.uleb128 .Ltmp65-.Lfunc_begin2          #     jumps to .Ltmp65
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp44-.Lfunc_begin2          # >> Call Site 10 <<
	.uleb128 .Ltmp45-.Ltmp44                #   Call between .Ltmp44 and .Ltmp45
	.uleb128 .Ltmp46-.Lfunc_begin2          #     jumps to .Ltmp46
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp47-.Lfunc_begin2          # >> Call Site 11 <<
	.uleb128 .Ltmp64-.Ltmp47                #   Call between .Ltmp47 and .Ltmp64
	.uleb128 .Ltmp65-.Lfunc_begin2          #     jumps to .Ltmp65
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp66-.Lfunc_begin2          # >> Call Site 12 <<
	.uleb128 .Ltmp69-.Ltmp66                #   Call between .Ltmp66 and .Ltmp69
	.uleb128 .Ltmp70-.Lfunc_begin2          #     jumps to .Ltmp70
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp71-.Lfunc_begin2          # >> Call Site 13 <<
	.uleb128 .Ltmp72-.Ltmp71                #   Call between .Ltmp71 and .Ltmp72
	.uleb128 .Ltmp73-.Lfunc_begin2          #     jumps to .Ltmp73
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp74-.Lfunc_begin2          # >> Call Site 14 <<
	.uleb128 .Ltmp81-.Ltmp74                #   Call between .Ltmp74 and .Ltmp81
	.uleb128 .Ltmp82-.Lfunc_begin2          #     jumps to .Ltmp82
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp83-.Lfunc_begin2          # >> Call Site 15 <<
	.uleb128 .Ltmp84-.Ltmp83                #   Call between .Ltmp83 and .Ltmp84
	.uleb128 .Ltmp85-.Lfunc_begin2          #     jumps to .Ltmp85
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp86-.Lfunc_begin2          # >> Call Site 16 <<
	.uleb128 .Ltmp89-.Ltmp86                #   Call between .Ltmp86 and .Ltmp89
	.uleb128 .Ltmp90-.Lfunc_begin2          #     jumps to .Ltmp90
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp91-.Lfunc_begin2          # >> Call Site 17 <<
	.uleb128 .Ltmp92-.Ltmp91                #   Call between .Ltmp91 and .Ltmp92
	.uleb128 .Ltmp93-.Lfunc_begin2          #     jumps to .Ltmp93
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp94-.Lfunc_begin2          # >> Call Site 18 <<
	.uleb128 .Ltmp101-.Ltmp94               #   Call between .Ltmp94 and .Ltmp101
	.uleb128 .Ltmp102-.Lfunc_begin2         #     jumps to .Ltmp102
	.byte	0                               #   On action: cleanup
	.uleb128 .Ltmp101-.Lfunc_begin2         # >> Call Site 19 <<
	.uleb128 .Lfunc_end2-.Ltmp101           #   Call between .Ltmp101 and .Lfunc_end2
	.byte	0                               #     has no landing pad
	.byte	0                               #   On action: cleanup
.Lcst_end2:
	.p2align	2, 0x0
                                        # -- End function
	.section	.text._ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv,"axG",@progbits,_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv,comdat
	.weak	_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv # -- Begin function _ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
	.p2align	1, 0x90
	.type	_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv,@function
_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv: # @_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
	.cfi_startproc
# %bb.0:                                # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_.exit
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	subq	$200, %rsp
	.cfi_def_cfa_offset 224
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movq	%rdi, %rbx
	movl	(%rsi), %ecx
	movsd	8(%rsi), %xmm0                  # xmm0 = mem[0],zero
	movsd	16(%rsi), %xmm1                 # xmm1 = mem[0],zero
	movsd	24(%rsi), %xmm2                 # xmm2 = mem[0],zero
	movsd	32(%rsi), %xmm3                 # xmm3 = mem[0],zero
	movq	%rsp, %r14
	movl	$200, %esi
	movl	$.L.str.6, %edx
	movq	%r14, %rdi
	movb	$4, %al
	callq	snprintf
	leaq	16(%rbx), %rax
	movq	%rax, (%rbx)
	movq	%r14, %rdi
	callq	strlen
	leaq	(%rsp,%rax), %rdx
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag
	movq	%rbx, %rax
	addq	$200, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end3:
	.size	_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv, .Lfunc_end3-_ZNK8ParticlecvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
	.cfi_endproc
                                        # -- End function
	.text
	.globl	_Z13moveParticlesP8Particle     # -- Begin function _Z13moveParticlesP8Particle
	.type	_Z13moveParticlesP8Particle,@function
_Z13moveParticlesP8Particle:            # @_Z13moveParticlesP8Particle
	.cfi_startproc
# %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	pushq	%r15
	.cfi_def_cfa_offset 24
	pushq	%r14
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	pushq	%rax
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	n(%rip), %rax
	cmpl	$0, (%rax)
	jle	.LBB4_3
# %bb.1:                                # %.lr.ph.preheader
	xorl	%eax, %eax
.LBB4_2:                                # %.lr.ph
                                        # =>This Inner Loop Header: Depth=1
	movq	found(%rip), %rcx
	movq	(%rcx), %rcx
	movl	$-1, (%rcx,%rax,4)
	incq	%rax
	movq	n(%rip), %rcx
	movslq	(%rcx), %rcx
	cmpq	%rcx, %rax
	jl	.LBB4_2
.LBB4_3:                                # %._crit_edge
	movabsq	$4294967296, %r14               # imm = 0x100000000
	movq	particleCollisionsCount(%rip), %rax
	xorl	%ecx, %ecx
	movl	%ecx, (%rax)
	movq	wallCollisionsCount(%rip), %rax
	movl	%ecx, (%rax)
	movq	noCollisionsCount(%rip), %rax
	movl	%ecx, (%rax)
	movq	n(%rip), %rax
	movl	(%rax), %edi
	leal	-1(%rdi), %eax
	addl	$62, %edi
	testl	%eax, %eax
	cmovnsl	%eax, %edi
	sarl	$6, %edi
	incl	%edi
	movq	streams(%rip), %r9
	btsq	$32, %rdi
	leaq	64(%r14), %rdx
	movl	$1, %esi
	movl	$1, %ecx
	xorl	%r8d, %r8d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB4_5
# %bb.4:
	callq	_Z32__device_stub__timeWallCollisionv
.LBB4_5:
	movq	n(%rip), %rax
	movl	(%rax), %eax
	leal	-1(%rax), %ecx
	addl	$14, %eax
	testl	%ecx, %ecx
	cmovnsl	%ecx, %eax
	sarl	$4, %eax
	incl	%eax
	leaq	1(%r14), %rdi
	imulq	%rax, %rdi
	movq	streams+8(%rip), %r9
	movabsq	$68719476752, %rdx              # imm = 0x1000000010
	movl	$1, %esi
	movl	$1, %ecx
	xorl	%r8d, %r8d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB4_7
# %bb.6:
	callq	_Z36__device_stub__timeParticleCollisionv
.LBB4_7:
	callq	hipDeviceSynchronize
	movq	n(%rip), %rax
	movl	(%rax), %edi
	testl	%edi, %edi
	je	.LBB4_29
# %bb.8:                                # %.lr.ph101.preheader
	xorl	%r15d, %r15d
	leaq	64(%r14), %rbx
.LBB4_10:                               # %.lr.ph101
                                        # =>This Loop Header: Depth=1
                                        #     Child Loop BB4_14 Depth 2
	leal	-1(%rdi), %eax
	addl	$62, %edi
	testl	%eax, %eax
	cmovnsl	%eax, %edi
	sarl	$6, %edi
	incl	%edi
	orq	%r14, %rdi
	movl	$1, %esi
	movq	%rbx, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	xorl	%r9d, %r9d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB4_12
# %bb.11:                               #   in Loop: Header=BB4_10 Depth=1
	callq	_Z36__device_stub__findEarliestCollisionv
.LBB4_12:                               #   in Loop: Header=BB4_10 Depth=1
	callq	hipDeviceSynchronize
	movq	n(%rip), %rax
	movl	(%rax), %edi
	testl	%edi, %edi
	jle	.LBB4_9
# %bb.13:                               # %.lr.ph97.preheader
                                        #   in Loop: Header=BB4_10 Depth=1
	xorl	%eax, %eax
	xorl	%ecx, %ecx
	xorl	%edx, %edx
.LBB4_14:                               # %.lr.ph97
                                        #   Parent Loop BB4_10 Depth=1
                                        # =>  This Inner Loop Header: Depth=2
	movq	found(%rip), %rsi
	movq	(%rsi), %rdi
	cmpl	$-1, (%rdi,%rax)
	jne	.LBB4_28
# %bb.15:                               #   in Loop: Header=BB4_14 Depth=2
	addq	%rax, %rdi
	movq	temp(%rip), %rsi
	movq	(%rsi), %rsi
	movl	32(%rsi,%rcx), %r8d
	cmpl	$1, %r8d
	je	.LBB4_18
# %bb.16:                               #   in Loop: Header=BB4_14 Depth=2
	testl	%r8d, %r8d
	jne	.LBB4_25
# %bb.17:                               # %..sink.split_crit_edge
                                        #   in Loop: Header=BB4_14 Depth=2
	movl	$wallCollisions, %r9d
	movl	$wallCollisionsCount, %r10d
	jmp	.LBB4_26
.LBB4_18:                               #   in Loop: Header=BB4_14 Depth=2
	movq	16(%rsi,%rcx), %r8
	movslq	(%r8), %r8
	leaq	(%r8,%r8,4), %r10
	cmpl	$1, 32(%rsi,%r10,8)
	jne	.LBB4_28
# %bb.19:                               #   in Loop: Header=BB4_14 Depth=2
	movq	8(%rsi,%rcx), %r9
	movl	(%r9), %r9d
	movq	8(%rsi,%r10,8), %r11
	movq	16(%rsi,%r10,8), %r10
	movl	(%r11), %r11d
	movl	(%r10), %r10d
	cmpl	%r11d, %r8d
	jne	.LBB4_21
# %bb.20:                               #   in Loop: Header=BB4_14 Depth=2
	movb	$1, %bpl
	cmpl	%r10d, %r9d
	je	.LBB4_22
.LBB4_21:                               #   in Loop: Header=BB4_14 Depth=2
	xorl	%r11d, %r9d
	xorl	%r8d, %r10d
	orl	%r9d, %r10d
	sete	%bpl
.LBB4_22:                               # %_ZN14CollisionEventeqES_.exit
                                        #   in Loop: Header=BB4_14 Depth=2
	cmpq	%r8, %rdx
	jge	.LBB4_28
# %bb.23:                               # %_ZN14CollisionEventeqES_.exit
                                        #   in Loop: Header=BB4_14 Depth=2
	testb	%bpl, %bpl
	je	.LBB4_28
# %bb.24:                               #   in Loop: Header=BB4_14 Depth=2
	movl	$0, (%rdi)
	movq	found(%rip), %rdi
	shlq	$2, %r8
	addq	(%rdi), %r8
	movl	$particleCollisions, %r9d
	movl	$particleCollisionsCount, %r10d
	movl	$2, %r11d
	movq	%r8, %rdi
	jmp	.LBB4_27
.LBB4_25:                               #   in Loop: Header=BB4_14 Depth=2
	movl	$noCollisions, %r9d
	movl	$noCollisionsCount, %r10d
.LBB4_26:                               # %.sink.split
                                        #   in Loop: Header=BB4_14 Depth=2
	movl	$1, %r11d
.LBB4_27:                               # %.sink.split
                                        #   in Loop: Header=BB4_14 Depth=2
	addq	%rcx, %rsi
	movl	$0, (%rdi)
	addl	%r11d, %r15d
	movq	(%r9), %rdi
	movq	(%rdi), %rdi
	movq	(%r10), %r8
	movslq	(%r8), %r9
	leal	1(%r9), %r10d
	movl	%r10d, (%r8)
	movq	%rsi, (%rdi,%r9,8)
.LBB4_28:                               #   in Loop: Header=BB4_14 Depth=2
	incq	%rdx
	movq	n(%rip), %rsi
	movslq	(%rsi), %rdi
	addq	$40, %rcx
	addq	$4, %rax
	cmpq	%rdi, %rdx
	jl	.LBB4_14
.LBB4_9:                                # %.loopexit
                                        #   in Loop: Header=BB4_10 Depth=1
	cmpl	%edi, %r15d
	jne	.LBB4_10
.LBB4_29:                               # %._crit_edge102
	movq	particleCollisionsCount(%rip), %rax
	movl	(%rax), %edi
	leal	-1(%rdi), %eax
	addl	$62, %edi
	testl	%eax, %eax
	cmovnsl	%eax, %edi
	sarl	$6, %edi
	incl	%edi
	movq	streams(%rip), %r9
	orq	%r14, %rdi
	leaq	64(%r14), %rbx
	movl	$1, %esi
	movq	%rbx, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB4_31
# %bb.30:
	callq	_Z39__device_stub__executeParticleCollisionv
.LBB4_31:
	movq	wallCollisionsCount(%rip), %rax
	movl	(%rax), %edi
	leal	-1(%rdi), %eax
	addl	$62, %edi
	testl	%eax, %eax
	cmovnsl	%eax, %edi
	sarl	$6, %edi
	incl	%edi
	movq	streams+8(%rip), %r9
	orq	%r14, %rdi
	movl	$1, %esi
	movq	%rbx, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB4_33
# %bb.32:
	callq	_Z35__device_stub__executeWallCollisionv
.LBB4_33:
	movq	n(%rip), %rax
	movl	(%rax), %edi
	leal	-1(%rdi), %eax
	addl	$62, %edi
	testl	%eax, %eax
	cmovnsl	%eax, %edi
	sarl	$6, %edi
	incl	%edi
	movq	streams+8(%rip), %r9
	orq	%r14, %rdi
	movl	$1, %esi
	movq	%rbx, %rdx
	movl	$1, %ecx
	xorl	%r8d, %r8d
	callq	__hipPushCallConfiguration
	testl	%eax, %eax
	jne	.LBB4_35
# %bb.34:
	callq	_Z33__device_stub__executeNoCollisionv
.LBB4_35:
	addq	$8, %rsp
	.cfi_def_cfa_offset 40
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r14
	.cfi_def_cfa_offset 24
	popq	%r15
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	jmp	hipDeviceSynchronize            # TAILCALL
.Lfunc_end4:
	.size	_Z13moveParticlesP8Particle, .Lfunc_end4-_Z13moveParticlesP8Particle
	.cfi_endproc
                                        # -- End function
	.section	.text._ZN8Particle21getFullRepresentationB5cxx11Ev,"axG",@progbits,_ZN8Particle21getFullRepresentationB5cxx11Ev,comdat
	.weak	_ZN8Particle21getFullRepresentationB5cxx11Ev # -- Begin function _ZN8Particle21getFullRepresentationB5cxx11Ev
	.p2align	1, 0x90
	.type	_ZN8Particle21getFullRepresentationB5cxx11Ev,@function
_ZN8Particle21getFullRepresentationB5cxx11Ev: # @_ZN8Particle21getFullRepresentationB5cxx11Ev
	.cfi_startproc
# %bb.0:                                # %_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_.exit
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	subq	$200, %rsp
	.cfi_def_cfa_offset 224
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movq	%rdi, %rbx
	movl	(%rsi), %ecx
	movsd	8(%rsi), %xmm0                  # xmm0 = mem[0],zero
	movsd	16(%rsi), %xmm1                 # xmm1 = mem[0],zero
	movsd	24(%rsi), %xmm2                 # xmm2 = mem[0],zero
	movsd	32(%rsi), %xmm3                 # xmm3 = mem[0],zero
	movl	40(%rsi), %r8d
	movl	44(%rsi), %r9d
	movq	%rsp, %r14
	movl	$200, %esi
	movl	$.L.str.7, %edx
	movq	%r14, %rdi
	movb	$4, %al
	callq	snprintf
	leaq	16(%rbx), %rax
	movq	%rax, (%rbx)
	movq	%r14, %rdi
	callq	strlen
	leaq	(%rsp,%rax), %rdx
	movq	%rbx, %rdi
	movq	%r14, %rsi
	callq	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag
	movq	%rbx, %rax
	addq	$200, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end5:
	.size	_ZN8Particle21getFullRepresentationB5cxx11Ev, .Lfunc_end5-_ZN8Particle21getFullRepresentationB5cxx11Ev
	.cfi_endproc
                                        # -- End function
	.text
	.globl	_Z32__device_stub__timeWallCollisionv # -- Begin function _Z32__device_stub__timeWallCollisionv
	.type	_Z32__device_stub__timeWallCollisionv,@function
_Z32__device_stub__timeWallCollisionv:  # @_Z32__device_stub__timeWallCollisionv
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	subq	$56, %rsp
	.cfi_def_cfa_offset 96
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rbx
	leaq	24(%rsp), %r14
	leaq	16(%rsp), %r15
	leaq	8(%rsp), %r12
	movq	%rbx, %rdi
	movq	%r14, %rsi
	movq	%r15, %rdx
	movq	%r12, %rcx
	callq	__hipPopCallConfiguration
	movq	(%rbx), %rsi
	movl	8(%rbx), %edx
	movq	(%r14), %rcx
	movl	8(%r14), %r8d
	movq	%rsp, %r9
	movl	$_Z17timeWallCollisionv, %edi
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	pushq	(%r15)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$72, %rsp
	.cfi_adjust_cfa_offset -72
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end6:
	.size	_Z32__device_stub__timeWallCollisionv, .Lfunc_end6-_Z32__device_stub__timeWallCollisionv
	.cfi_endproc
                                        # -- End function
	.globl	_Z36__device_stub__timeParticleCollisionv # -- Begin function _Z36__device_stub__timeParticleCollisionv
	.type	_Z36__device_stub__timeParticleCollisionv,@function
_Z36__device_stub__timeParticleCollisionv: # @_Z36__device_stub__timeParticleCollisionv
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	subq	$56, %rsp
	.cfi_def_cfa_offset 96
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rbx
	leaq	24(%rsp), %r14
	leaq	16(%rsp), %r15
	leaq	8(%rsp), %r12
	movq	%rbx, %rdi
	movq	%r14, %rsi
	movq	%r15, %rdx
	movq	%r12, %rcx
	callq	__hipPopCallConfiguration
	movq	(%rbx), %rsi
	movl	8(%rbx), %edx
	movq	(%r14), %rcx
	movl	8(%r14), %r8d
	movq	%rsp, %r9
	movl	$_Z21timeParticleCollisionv, %edi
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	pushq	(%r15)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$72, %rsp
	.cfi_adjust_cfa_offset -72
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end7:
	.size	_Z36__device_stub__timeParticleCollisionv, .Lfunc_end7-_Z36__device_stub__timeParticleCollisionv
	.cfi_endproc
                                        # -- End function
	.globl	_Z36__device_stub__findEarliestCollisionv # -- Begin function _Z36__device_stub__findEarliestCollisionv
	.type	_Z36__device_stub__findEarliestCollisionv,@function
_Z36__device_stub__findEarliestCollisionv: # @_Z36__device_stub__findEarliestCollisionv
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	subq	$56, %rsp
	.cfi_def_cfa_offset 96
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rbx
	leaq	24(%rsp), %r14
	leaq	16(%rsp), %r15
	leaq	8(%rsp), %r12
	movq	%rbx, %rdi
	movq	%r14, %rsi
	movq	%r15, %rdx
	movq	%r12, %rcx
	callq	__hipPopCallConfiguration
	movq	(%rbx), %rsi
	movl	8(%rbx), %edx
	movq	(%r14), %rcx
	movl	8(%r14), %r8d
	movq	%rsp, %r9
	movl	$_Z21findEarliestCollisionv, %edi
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	pushq	(%r15)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$72, %rsp
	.cfi_adjust_cfa_offset -72
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end8:
	.size	_Z36__device_stub__findEarliestCollisionv, .Lfunc_end8-_Z36__device_stub__findEarliestCollisionv
	.cfi_endproc
                                        # -- End function
	.globl	_Z39__device_stub__executeParticleCollisionv # -- Begin function _Z39__device_stub__executeParticleCollisionv
	.type	_Z39__device_stub__executeParticleCollisionv,@function
_Z39__device_stub__executeParticleCollisionv: # @_Z39__device_stub__executeParticleCollisionv
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	subq	$56, %rsp
	.cfi_def_cfa_offset 96
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rbx
	leaq	24(%rsp), %r14
	leaq	16(%rsp), %r15
	leaq	8(%rsp), %r12
	movq	%rbx, %rdi
	movq	%r14, %rsi
	movq	%r15, %rdx
	movq	%r12, %rcx
	callq	__hipPopCallConfiguration
	movq	(%rbx), %rsi
	movl	8(%rbx), %edx
	movq	(%r14), %rcx
	movl	8(%r14), %r8d
	movq	%rsp, %r9
	movl	$_Z24executeParticleCollisionv, %edi
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	pushq	(%r15)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$72, %rsp
	.cfi_adjust_cfa_offset -72
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end9:
	.size	_Z39__device_stub__executeParticleCollisionv, .Lfunc_end9-_Z39__device_stub__executeParticleCollisionv
	.cfi_endproc
                                        # -- End function
	.globl	_Z35__device_stub__executeWallCollisionv # -- Begin function _Z35__device_stub__executeWallCollisionv
	.type	_Z35__device_stub__executeWallCollisionv,@function
_Z35__device_stub__executeWallCollisionv: # @_Z35__device_stub__executeWallCollisionv
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	subq	$56, %rsp
	.cfi_def_cfa_offset 96
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rbx
	leaq	24(%rsp), %r14
	leaq	16(%rsp), %r15
	leaq	8(%rsp), %r12
	movq	%rbx, %rdi
	movq	%r14, %rsi
	movq	%r15, %rdx
	movq	%r12, %rcx
	callq	__hipPopCallConfiguration
	movq	(%rbx), %rsi
	movl	8(%rbx), %edx
	movq	(%r14), %rcx
	movl	8(%r14), %r8d
	movq	%rsp, %r9
	movl	$_Z20executeWallCollisionv, %edi
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	pushq	(%r15)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$72, %rsp
	.cfi_adjust_cfa_offset -72
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end10:
	.size	_Z35__device_stub__executeWallCollisionv, .Lfunc_end10-_Z35__device_stub__executeWallCollisionv
	.cfi_endproc
                                        # -- End function
	.globl	_Z33__device_stub__executeNoCollisionv # -- Begin function _Z33__device_stub__executeNoCollisionv
	.type	_Z33__device_stub__executeNoCollisionv,@function
_Z33__device_stub__executeNoCollisionv: # @_Z33__device_stub__executeNoCollisionv
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	subq	$56, %rsp
	.cfi_def_cfa_offset 96
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	leaq	40(%rsp), %rbx
	leaq	24(%rsp), %r14
	leaq	16(%rsp), %r15
	leaq	8(%rsp), %r12
	movq	%rbx, %rdi
	movq	%r14, %rsi
	movq	%r15, %rdx
	movq	%r12, %rcx
	callq	__hipPopCallConfiguration
	movq	(%rbx), %rsi
	movl	8(%rbx), %edx
	movq	(%r14), %rcx
	movl	8(%r14), %r8d
	movq	%rsp, %r9
	movl	$_Z18executeNoCollisionv, %edi
	pushq	(%r12)
	.cfi_adjust_cfa_offset 8
	pushq	(%r15)
	.cfi_adjust_cfa_offset 8
	callq	hipLaunchKernel
	addq	$72, %rsp
	.cfi_adjust_cfa_offset -72
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end11:
	.size	_Z33__device_stub__executeNoCollisionv, .Lfunc_end11-_Z33__device_stub__executeNoCollisionv
	.cfi_endproc
                                        # -- End function
	.section	.text._ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag,"axG",@progbits,_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag,comdat
	.weak	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag # -- Begin function _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag
	.p2align	1, 0x90
	.type	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag,@function
_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag: # @_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag
	.cfi_startproc
# %bb.0:
	pushq	%r15
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%r12
	.cfi_def_cfa_offset 32
	pushq	%rbx
	.cfi_def_cfa_offset 40
	pushq	%rax
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -40
	.cfi_offset %r12, -32
	.cfi_offset %r14, -24
	.cfi_offset %r15, -16
	movq	%rdx, %r14
	movq	%rsi, %r15
	movq	%rdi, %rbx
	subq	%rsi, %r14
	movq	%r14, (%rsp)
	cmpq	$15, %r14
	jbe	.LBB12_1
# %bb.2:
	movq	%rsp, %r12
	movq	%rbx, %rdi
	movq	%r12, %rsi
	xorl	%edx, %edx
	callq	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm
	movq	%rax, (%rbx)
	movq	(%r12), %rcx
	movq	%rcx, 16(%rbx)
	jmp	.LBB12_3
.LBB12_1:                               # %._crit_edge
	movq	(%rbx), %rax
.LBB12_3:
	testq	%r14, %r14
	je	.LBB12_7
# %bb.4:
	cmpq	$1, %r14
	jne	.LBB12_6
# %bb.5:
	movb	(%r15), %cl
	movb	%cl, (%rax)
	jmp	.LBB12_7
.LBB12_6:
	movq	%rax, %rdi
	movq	%r15, %rsi
	movq	%r14, %rdx
	callq	memcpy@PLT
.LBB12_7:                               # %_ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tagEN6_GuardD2Ev.exit
	movq	(%rsp), %rax
	movq	%rax, 8(%rbx)
	movq	(%rbx), %rcx
	movb	$0, (%rcx,%rax)
	addq	$8, %rsp
	.cfi_def_cfa_offset 40
	popq	%rbx
	.cfi_def_cfa_offset 32
	popq	%r12
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%r15
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end12:
	.size	_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag, .Lfunc_end12-_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag
	.cfi_endproc
                                        # -- End function
	.section	.text.__clang_call_terminate,"axG",@progbits,__clang_call_terminate,comdat
	.hidden	__clang_call_terminate          # -- Begin function __clang_call_terminate
	.weak	__clang_call_terminate
	.type	__clang_call_terminate,@function
__clang_call_terminate:                 # @__clang_call_terminate
	.cfi_startproc
# %bb.0:
	pushq	%rax
	.cfi_def_cfa_offset 16
	callq	__cxa_begin_catch
	callq	_ZSt9terminatev
.Lfunc_end13:
	.size	__clang_call_terminate, .Lfunc_end13-__clang_call_terminate
	.cfi_endproc
                                        # -- End function
	.section	.rodata.cst4,"aM",@progbits,4
	.p2align	2, 0x0                          # -- Begin function _ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
.LCPI14_0:
	.long	0x4f800000                      # float 4.2949673E+9
.LCPI14_1:
	.long	0x40000000                      # float 2
.LCPI14_2:
	.long	0x5f000000                      # float 9.22337203E+18
	.section	.rodata.cst8,"aM",@progbits,8
	.p2align	3, 0x0
.LCPI14_3:
	.quad	0x3ff0000000000000              # double 1
	.section	.rodata.cst16,"aM",@progbits,16
	.p2align	4, 0x0
.LCPI14_4:
	.long	1127219200                      # 0x43300000
	.long	1160773632                      # 0x45300000
	.long	0                               # 0x0
	.long	0                               # 0x0
.LCPI14_5:
	.quad	0x4330000000000000              # double 4503599627370496
	.quad	0x4530000000000000              # double 1.9342813113834067E+25
	.section	.text._ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_,"axG",@progbits,_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_,comdat
	.weak	_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
	.type	_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_,@function
_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_: # @_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
	.cfi_startproc
# %bb.0:
	pushq	%r14
	.cfi_def_cfa_offset 16
	pushq	%rbx
	.cfi_def_cfa_offset 24
	subq	$72, %rsp
	.cfi_def_cfa_offset 96
	.cfi_offset %rbx, -24
	.cfi_offset %r14, -16
	movq	%rdi, %rbx
	flds	.LCPI14_0(%rip)
	fstpt	(%rsp)
	callq	logl
	fstpt	24(%rsp)                        # 10-byte Folded Spill
	flds	.LCPI14_1(%rip)
	fstpt	(%rsp)
	callq	logl
	fldt	24(%rsp)                        # 10-byte Folded Reload
	fdivp	%st, %st(1)
	flds	.LCPI14_2(%rip)
	xorl	%ecx, %ecx
	fxch	%st(1)
	fucomi	%st(1), %st
	fldz
	fcmovnb	%st(2), %st
	fstp	%st(2)
	fsubp	%st, %st(1)
	setae	%cl
	fnstcw	20(%rsp)
	movzwl	20(%rsp), %eax
	orl	$3072, %eax                     # imm = 0xC00
	movw	%ax, 22(%rsp)
	fldcw	22(%rsp)
	fistpll	64(%rsp)
	fldcw	20(%rsp)
	shlq	$63, %rcx
	xorq	64(%rsp), %rcx
	leaq	52(%rcx), %rax
	xorl	%edx, %edx
	divq	%rcx
	movq	%rax, %r14
	cmpq	$1, %rax
	adcq	$0, %r14
	xorpd	%xmm0, %xmm0
	movsd	.LCPI14_3(%rip), %xmm1          # xmm1 = mem[0],zero
.LBB14_1:                               # %select.unfold
                                        # =>This Inner Loop Header: Depth=1
	movsd	%xmm1, 40(%rsp)                 # 8-byte Spill
	movsd	%xmm0, 24(%rsp)                 # 8-byte Spill
	movq	%rbx, %rdi
	callq	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv
	movq	%rax, %xmm0
	punpckldq	.LCPI14_4(%rip), %xmm0  # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
	subpd	.LCPI14_5(%rip), %xmm0
	movapd	%xmm0, %xmm1
	unpckhpd	%xmm0, %xmm1                    # xmm1 = xmm1[1],xmm0[1]
	addsd	%xmm0, %xmm1
	movsd	24(%rsp), %xmm0                 # 8-byte Reload
                                        # xmm0 = mem[0],zero
	movsd	40(%rsp), %xmm2                 # 8-byte Reload
                                        # xmm2 = mem[0],zero
	mulsd	%xmm2, %xmm1
	movsd	%xmm2, 56(%rsp)
	fldl	56(%rsp)
	fmuls	.LCPI14_0(%rip)
	addsd	%xmm1, %xmm0
	fstpl	48(%rsp)
	movsd	48(%rsp), %xmm1                 # xmm1 = mem[0],zero
	decq	%r14
	jne	.LBB14_1
# %bb.2:
	divsd	%xmm1, %xmm0
	ucomisd	.LCPI14_3(%rip), %xmm0
	jae	.LBB14_4
# %bb.3:
	addq	$72, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	retq
.LBB14_4:
	.cfi_def_cfa_offset 96
	movsd	.LCPI14_3(%rip), %xmm0          # xmm0 = mem[0],zero
	xorpd	%xmm1, %xmm1
	addq	$72, %rsp
	.cfi_def_cfa_offset 24
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%r14
	.cfi_def_cfa_offset 8
	jmp	nextafter                       # TAILCALL
.Lfunc_end14:
	.size	_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_, .Lfunc_end14-_ZSt18generate_canonicalIdLm53ESt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEET_RT1_
	.cfi_endproc
                                        # -- End function
	.section	.text._ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv,"axG",@progbits,_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv,comdat
	.weak	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv # -- Begin function _ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv
	.p2align	1, 0x90
	.type	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv,@function
_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv: # @_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv
	.cfi_startproc
# %bb.0:
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset %rbx, -16
	movq	%rdi, %rbx
	movq	4992(%rdi), %rax
	cmpq	$624, %rax                      # imm = 0x270
	jb	.LBB15_2
# %bb.1:
	movq	%rbx, %rdi
	callq	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv
	movq	4992(%rbx), %rax
.LBB15_2:
	leaq	1(%rax), %rcx
	movq	%rcx, 4992(%rbx)
	movq	(%rbx,%rax,8), %rax
	movq	%rax, %rcx
	shrq	$11, %rcx
	movl	%ecx, %ecx
	xorq	%rax, %rcx
	movl	%ecx, %eax
	shll	$7, %eax
	andl	$-1658038656, %eax              # imm = 0x9D2C5680
	xorq	%rcx, %rax
	movl	%eax, %ecx
	shll	$15, %ecx
	andl	$-272236544, %ecx               # imm = 0xEFC60000
	xorq	%rax, %rcx
	movq	%rcx, %rax
	shrq	$18, %rax
	xorq	%rcx, %rax
	popq	%rbx
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end15:
	.size	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv, .Lfunc_end15-_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv
	.cfi_endproc
                                        # -- End function
	.section	.text._ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv,"axG",@progbits,_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv,comdat
	.weak	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv # -- Begin function _ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv
	.p2align	1, 0x90
	.type	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv,@function
_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv: # @_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv
	.cfi_startproc
# %bb.0:
	movl	$2567483615, %eax               # imm = 0x9908B0DF
	movq	(%rdi), %rdx
	xorl	%ecx, %ecx
.LBB16_1:                               # =>This Inner Loop Header: Depth=1
	andq	$-2147483648, %rdx              # imm = 0x80000000
	movq	8(%rdi,%rcx,8), %rsi
	movl	%esi, %r8d
	andl	$2147483646, %r8d               # imm = 0x7FFFFFFE
	orq	%rdx, %r8
	shrq	%r8
	xorq	3176(%rdi,%rcx,8), %r8
	movq	%rsi, %rdx
                                        # kill: def $esi killed $esi killed $rsi def $rsi
	andl	$1, %esi
	negl	%esi
	andl	%eax, %esi
	xorq	%r8, %rsi
	movq	%rsi, (%rdi,%rcx,8)
	leaq	1(%rcx), %rsi
	movq	%rsi, %rcx
	cmpq	$227, %rsi
	jne	.LBB16_1
# %bb.2:                                # %.preheader.preheader
	movq	1816(%rdi), %rdx
	movl	$228, %ecx
.LBB16_3:                               # %.preheader
                                        # =>This Inner Loop Header: Depth=1
	andq	$-2147483648, %rdx              # imm = 0x80000000
	movq	(%rdi,%rcx,8), %rsi
	movl	%esi, %r8d
	andl	$2147483646, %r8d               # imm = 0x7FFFFFFE
	orq	%rdx, %r8
	shrq	%r8
	xorq	-1824(%rdi,%rcx,8), %r8
	movq	%rsi, %rdx
                                        # kill: def $esi killed $esi killed $rsi def $rsi
	andl	$1, %esi
	negl	%esi
	andl	%eax, %esi
	xorq	%r8, %rsi
	movq	%rsi, -8(%rdi,%rcx,8)
	incq	%rcx
	cmpq	$624, %rcx                      # imm = 0x270
	jne	.LBB16_3
# %bb.4:
	movq	$-2147483648, %rcx              # imm = 0x80000000
	andq	4984(%rdi), %rcx
	movq	(%rdi), %rdx
	movl	%edx, %esi
	andl	$2147483646, %esi               # imm = 0x7FFFFFFE
	orq	%rcx, %rsi
	shrq	%rsi
	xorq	3168(%rdi), %rsi
	andl	$1, %edx
	negl	%edx
	andl	%eax, %edx
	xorq	%rsi, %rdx
	movq	%rdx, 4984(%rdi)
	movq	$0, 4992(%rdi)
	retq
.Lfunc_end16:
	.size	_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv, .Lfunc_end16-_ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv
	.cfi_endproc
                                        # -- End function
	.section	.text.startup,"ax",@progbits
	.type	_GLOBAL__sub_I_cuda_simulator.hip,@function # -- Begin function _GLOBAL__sub_I_cuda_simulator.hip
_GLOBAL__sub_I_cuda_simulator.hip:      # @_GLOBAL__sub_I_cuda_simulator.hip
	.cfi_startproc
# %bb.0:
	movq	$5489, rng(%rip)                # imm = 0x1571
	movl	$1, %eax
	movl	$5489, %ecx                     # imm = 0x1571
.LBB17_1:                               # =>This Inner Loop Header: Depth=1
	movq	%rcx, %rdx
	shrq	$30, %rdx
	xorl	%ecx, %edx
	imull	$1812433253, %edx, %ecx         # imm = 0x6C078965
	addl	%eax, %ecx
	movq	%rcx, rng(,%rax,8)
	incq	%rax
	cmpq	$624, %rax                      # imm = 0x270
	jne	.LBB17_1
# %bb.2:                                # %__cxx_global_var_init.exit
	pushq	%rax
	.cfi_def_cfa_offset 16
	movq	$624, rng+4992(%rip)            # imm = 0x270
	movl	$rd, %edi
	callq	_ZNSt13random_deviceC2Ev
	movl	$_ZNSt13random_deviceD2Ev, %edi
	movl	$rd, %esi
	movl	$__dso_handle, %edx
	popq	%rax
	.cfi_def_cfa_offset 8
	jmp	__cxa_atexit                    # TAILCALL
.Lfunc_end17:
	.size	_GLOBAL__sub_I_cuda_simulator.hip, .Lfunc_end17-_GLOBAL__sub_I_cuda_simulator.hip
	.cfi_endproc
                                        # -- End function
	.text
	.p2align	4, 0x90                         # -- Begin function __hip_module_ctor
	.type	__hip_module_ctor,@function
__hip_module_ctor:                      # @__hip_module_ctor
	.cfi_startproc
# %bb.0:
	pushq	%rbx
	.cfi_def_cfa_offset 16
	subq	$32, %rsp
	.cfi_def_cfa_offset 48
	.cfi_offset %rbx, -16
	movq	__hip_gpubin_handle(%rip), %rbx
	testq	%rbx, %rbx
	jne	.LBB18_2
# %bb.1:
	movl	$__hip_fatbin_wrapper, %edi
	callq	__hipRegisterFatBinary
	movq	%rax, %rbx
	movq	%rax, __hip_gpubin_handle(%rip)
.LBB18_2:
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z21findEarliestCollisionv, %esi
	movl	$.L__unnamed_1, %edx
	movl	$.L__unnamed_1, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z21timeParticleCollisionv, %esi
	movl	$.L__unnamed_2, %edx
	movl	$.L__unnamed_2, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z17timeWallCollisionv, %esi
	movl	$.L__unnamed_3, %edx
	movl	$.L__unnamed_3, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z24executeParticleCollisionv, %esi
	movl	$.L__unnamed_4, %edx
	movl	$.L__unnamed_4, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z20executeWallCollisionv, %esi
	movl	$.L__unnamed_5, %edx
	movl	$.L__unnamed_5, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	xorps	%xmm0, %xmm0
	movups	%xmm0, 16(%rsp)
	movups	%xmm0, (%rsp)
	movl	$_Z18executeNoCollisionv, %esi
	movl	$.L__unnamed_6, %edx
	movl	$.L__unnamed_6, %ecx
	movq	%rbx, %rdi
	movl	$-1, %r8d
	xorl	%r9d, %r9d
	callq	__hipRegisterFunction
	movl	$n, %esi
	movl	$n.managed, %edx
	movl	$.L__unnamed_7, %ecx
	movl	$4, %r8d
	movq	%rbx, %rdi
	movl	$4, %r9d
	callq	__hipRegisterManagedVar
	movl	$l, %esi
	movl	$l.managed, %edx
	movl	$.L__unnamed_8, %ecx
	movl	$4, %r8d
	movq	%rbx, %rdi
	movl	$4, %r9d
	callq	__hipRegisterManagedVar
	movl	$r, %esi
	movl	$r.managed, %edx
	movl	$.L__unnamed_9, %ecx
	movl	$4, %r8d
	movq	%rbx, %rdi
	movl	$4, %r9d
	callq	__hipRegisterManagedVar
	movl	$s, %esi
	movl	$s.managed, %edx
	movl	$.L__unnamed_10, %ecx
	movl	$4, %r8d
	movq	%rbx, %rdi
	movl	$4, %r9d
	callq	__hipRegisterManagedVar
	movl	$particles, %esi
	movl	$particles.managed, %edx
	movl	$.L__unnamed_11, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$particleCollisionTimes, %esi
	movl	$particleCollisionTimes.managed, %edx
	movl	$.L__unnamed_12, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$wallCollisionTimes, %esi
	movl	$wallCollisionTimes.managed, %edx
	movl	$.L__unnamed_13, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$temp, %esi
	movl	$temp.managed, %edx
	movl	$.L__unnamed_14, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$found, %esi
	movl	$found.managed, %edx
	movl	$.L__unnamed_15, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$particleCollisions, %esi
	movl	$particleCollisions.managed, %edx
	movl	$.L__unnamed_16, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$particleCollisionsCount, %esi
	movl	$particleCollisionsCount.managed, %edx
	movl	$.L__unnamed_17, %ecx
	movl	$4, %r8d
	movq	%rbx, %rdi
	movl	$4, %r9d
	callq	__hipRegisterManagedVar
	movl	$wallCollisions, %esi
	movl	$wallCollisions.managed, %edx
	movl	$.L__unnamed_18, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$wallCollisionsCount, %esi
	movl	$wallCollisionsCount.managed, %edx
	movl	$.L__unnamed_19, %ecx
	movl	$4, %r8d
	movq	%rbx, %rdi
	movl	$4, %r9d
	callq	__hipRegisterManagedVar
	movl	$noCollisions, %esi
	movl	$noCollisions.managed, %edx
	movl	$.L__unnamed_20, %ecx
	movl	$8, %r8d
	movq	%rbx, %rdi
	movl	$8, %r9d
	callq	__hipRegisterManagedVar
	movl	$noCollisionsCount, %esi
	movl	$noCollisionsCount.managed, %edx
	movl	$.L__unnamed_21, %ecx
	movl	$4, %r8d
	movq	%rbx, %rdi
	movl	$4, %r9d
	callq	__hipRegisterManagedVar
	movl	$__hip_module_dtor, %edi
	addq	$32, %rsp
	.cfi_def_cfa_offset 16
	popq	%rbx
	.cfi_def_cfa_offset 8
	jmp	atexit                          # TAILCALL
.Lfunc_end18:
	.size	__hip_module_ctor, .Lfunc_end18-__hip_module_ctor
	.cfi_endproc
                                        # -- End function
	.p2align	4, 0x90                         # -- Begin function __hip_module_dtor
	.type	__hip_module_dtor,@function
__hip_module_dtor:                      # @__hip_module_dtor
	.cfi_startproc
# %bb.0:
	movq	__hip_gpubin_handle(%rip), %rdi
	testq	%rdi, %rdi
	je	.LBB19_2
# %bb.1:
	pushq	%rax
	.cfi_def_cfa_offset 16
	callq	__hipUnregisterFatBinary
	movq	$0, __hip_gpubin_handle(%rip)
	addq	$8, %rsp
	.cfi_def_cfa_offset 8
.LBB19_2:
	retq
.Lfunc_end19:
	.size	__hip_module_dtor, .Lfunc_end19-__hip_module_dtor
	.cfi_endproc
                                        # -- End function
	.type	rng,@object                     # @rng
	.bss
	.globl	rng
	.p2align	3, 0x0
rng:
	.zero	5000
	.size	rng, 5000

	.type	rd,@object                      # @rd
	.globl	rd
	.p2align	3, 0x0
rd:
	.zero	5000
	.size	rd, 5000

	.hidden	__dso_handle
	.type	n.managed,@object               # @n.managed
	.local	n.managed
	.comm	n.managed,4,4
	.type	l.managed,@object               # @l.managed
	.local	l.managed
	.comm	l.managed,4,4
	.type	r.managed,@object               # @r.managed
	.local	r.managed
	.comm	r.managed,4,4
	.type	s.managed,@object               # @s.managed
	.local	s.managed
	.comm	s.managed,4,4
	.type	streams,@object                 # @streams
	.globl	streams
	.p2align	4, 0x0
streams:
	.zero	16
	.size	streams, 16

	.type	particles.managed,@object       # @particles.managed
	.local	particles.managed
	.comm	particles.managed,8,8
	.type	particleCollisionTimes.managed,@object # @particleCollisionTimes.managed
	.local	particleCollisionTimes.managed
	.comm	particleCollisionTimes.managed,8,8
	.type	wallCollisionTimes.managed,@object # @wallCollisionTimes.managed
	.local	wallCollisionTimes.managed
	.comm	wallCollisionTimes.managed,8,8
	.type	temp.managed,@object            # @temp.managed
	.local	temp.managed
	.comm	temp.managed,8,8
	.type	found.managed,@object           # @found.managed
	.local	found.managed
	.comm	found.managed,8,8
	.type	particleCollisions.managed,@object # @particleCollisions.managed
	.local	particleCollisions.managed
	.comm	particleCollisions.managed,8,8
	.type	particleCollisionsCount.managed,@object # @particleCollisionsCount.managed
	.local	particleCollisionsCount.managed
	.comm	particleCollisionsCount.managed,4,4
	.type	wallCollisions.managed,@object  # @wallCollisions.managed
	.local	wallCollisions.managed
	.comm	wallCollisions.managed,8,8
	.type	wallCollisionsCount.managed,@object # @wallCollisionsCount.managed
	.local	wallCollisionsCount.managed
	.comm	wallCollisionsCount.managed,4,4
	.type	noCollisions.managed,@object    # @noCollisions.managed
	.local	noCollisions.managed
	.comm	noCollisions.managed,8,8
	.type	noCollisionsCount.managed,@object # @noCollisionsCount.managed
	.local	noCollisionsCount.managed
	.comm	noCollisionsCount.managed,4,4
	.type	.L.str,@object                  # @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"%d %lf %lf %lf %lf"
	.size	.L.str, 19

	.type	.L.str.2,@object                # @.str.2
.L.str.2:
	.asciz	"print"
	.size	.L.str.2, 6

	.type	.L.str.3,@object                # @.str.3
.L.str.3:
	.asciz	" "
	.size	.L.str.3, 2

	.type	_Z17timeWallCollisionv,@object  # @_Z17timeWallCollisionv
	.section	.rodata,"a",@progbits
	.globl	_Z17timeWallCollisionv
	.p2align	3, 0x0
_Z17timeWallCollisionv:
	.quad	_Z32__device_stub__timeWallCollisionv
	.size	_Z17timeWallCollisionv, 8

	.type	_Z21timeParticleCollisionv,@object # @_Z21timeParticleCollisionv
	.globl	_Z21timeParticleCollisionv
	.p2align	3, 0x0
_Z21timeParticleCollisionv:
	.quad	_Z36__device_stub__timeParticleCollisionv
	.size	_Z21timeParticleCollisionv, 8

	.type	_Z21findEarliestCollisionv,@object # @_Z21findEarliestCollisionv
	.globl	_Z21findEarliestCollisionv
	.p2align	3, 0x0
_Z21findEarliestCollisionv:
	.quad	_Z36__device_stub__findEarliestCollisionv
	.size	_Z21findEarliestCollisionv, 8

	.type	_Z24executeParticleCollisionv,@object # @_Z24executeParticleCollisionv
	.globl	_Z24executeParticleCollisionv
	.p2align	3, 0x0
_Z24executeParticleCollisionv:
	.quad	_Z39__device_stub__executeParticleCollisionv
	.size	_Z24executeParticleCollisionv, 8

	.type	_Z20executeWallCollisionv,@object # @_Z20executeWallCollisionv
	.globl	_Z20executeWallCollisionv
	.p2align	3, 0x0
_Z20executeWallCollisionv:
	.quad	_Z35__device_stub__executeWallCollisionv
	.size	_Z20executeWallCollisionv, 8

	.type	_Z18executeNoCollisionv,@object # @_Z18executeNoCollisionv
	.globl	_Z18executeNoCollisionv
	.p2align	3, 0x0
_Z18executeNoCollisionv:
	.quad	_Z33__device_stub__executeNoCollisionv
	.size	_Z18executeNoCollisionv, 8

	.type	.L.str.4,@object                # @.str.4
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.4:
	.asciz	"default"
	.size	.L.str.4, 8

	.type	.L.str.6,@object                # @.str.6
.L.str.6:
	.asciz	"%d %.8lf %.8lf %.8lf %.8lf"
	.size	.L.str.6, 27

	.type	.L.str.7,@object                # @.str.7
.L.str.7:
	.asciz	"%d %.8lf %.8lf %.8lf %.8lf %d %d"
	.size	.L.str.7, 33

	.type	.L__unnamed_1,@object           # @0
.L__unnamed_1:
	.asciz	"_Z21findEarliestCollisionv"
	.size	.L__unnamed_1, 27

	.type	.L__unnamed_2,@object           # @1
.L__unnamed_2:
	.asciz	"_Z21timeParticleCollisionv"
	.size	.L__unnamed_2, 27

	.type	.L__unnamed_3,@object           # @2
.L__unnamed_3:
	.asciz	"_Z17timeWallCollisionv"
	.size	.L__unnamed_3, 23

	.type	.L__unnamed_4,@object           # @3
.L__unnamed_4:
	.asciz	"_Z24executeParticleCollisionv"
	.size	.L__unnamed_4, 30

	.type	.L__unnamed_5,@object           # @4
.L__unnamed_5:
	.asciz	"_Z20executeWallCollisionv"
	.size	.L__unnamed_5, 26

	.type	.L__unnamed_6,@object           # @5
.L__unnamed_6:
	.asciz	"_Z18executeNoCollisionv"
	.size	.L__unnamed_6, 24

	.type	.L__unnamed_7,@object           # @6
.L__unnamed_7:
	.asciz	"n"
	.size	.L__unnamed_7, 2

	.type	n,@object                       # @n
	.local	n
	.comm	n,8,8
	.type	.L__unnamed_8,@object           # @7
.L__unnamed_8:
	.asciz	"l"
	.size	.L__unnamed_8, 2

	.type	l,@object                       # @l
	.local	l
	.comm	l,8,8
	.type	.L__unnamed_9,@object           # @8
.L__unnamed_9:
	.asciz	"r"
	.size	.L__unnamed_9, 2

	.type	r,@object                       # @r
	.local	r
	.comm	r,8,8
	.type	.L__unnamed_10,@object          # @9
.L__unnamed_10:
	.asciz	"s"
	.size	.L__unnamed_10, 2

	.type	s,@object                       # @s
	.local	s
	.comm	s,8,8
	.type	.L__unnamed_11,@object          # @10
.L__unnamed_11:
	.asciz	"particles"
	.size	.L__unnamed_11, 10

	.type	particles,@object               # @particles
	.local	particles
	.comm	particles,8,8
	.type	.L__unnamed_12,@object          # @11
.L__unnamed_12:
	.asciz	"particleCollisionTimes"
	.size	.L__unnamed_12, 23

	.type	particleCollisionTimes,@object  # @particleCollisionTimes
	.local	particleCollisionTimes
	.comm	particleCollisionTimes,8,8
	.type	.L__unnamed_13,@object          # @12
.L__unnamed_13:
	.asciz	"wallCollisionTimes"
	.size	.L__unnamed_13, 19

	.type	wallCollisionTimes,@object      # @wallCollisionTimes
	.local	wallCollisionTimes
	.comm	wallCollisionTimes,8,8
	.type	.L__unnamed_14,@object          # @13
.L__unnamed_14:
	.asciz	"temp"
	.size	.L__unnamed_14, 5

	.type	temp,@object                    # @temp
	.local	temp
	.comm	temp,8,8
	.type	.L__unnamed_15,@object          # @14
.L__unnamed_15:
	.asciz	"found"
	.size	.L__unnamed_15, 6

	.type	found,@object                   # @found
	.local	found
	.comm	found,8,8
	.type	.L__unnamed_16,@object          # @15
.L__unnamed_16:
	.asciz	"particleCollisions"
	.size	.L__unnamed_16, 19

	.type	particleCollisions,@object      # @particleCollisions
	.local	particleCollisions
	.comm	particleCollisions,8,8
	.type	.L__unnamed_17,@object          # @16
.L__unnamed_17:
	.asciz	"particleCollisionsCount"
	.size	.L__unnamed_17, 24

	.type	particleCollisionsCount,@object # @particleCollisionsCount
	.local	particleCollisionsCount
	.comm	particleCollisionsCount,8,8
	.type	.L__unnamed_18,@object          # @17
.L__unnamed_18:
	.asciz	"wallCollisions"
	.size	.L__unnamed_18, 15

	.type	wallCollisions,@object          # @wallCollisions
	.local	wallCollisions
	.comm	wallCollisions,8,8
	.type	.L__unnamed_19,@object          # @18
.L__unnamed_19:
	.asciz	"wallCollisionsCount"
	.size	.L__unnamed_19, 20

	.type	wallCollisionsCount,@object     # @wallCollisionsCount
	.local	wallCollisionsCount
	.comm	wallCollisionsCount,8,8
	.type	.L__unnamed_20,@object          # @19
.L__unnamed_20:
	.asciz	"noCollisions"
	.size	.L__unnamed_20, 13

	.type	noCollisions,@object            # @noCollisions
	.local	noCollisions
	.comm	noCollisions,8,8
	.type	.L__unnamed_21,@object          # @20
.L__unnamed_21:
	.asciz	"noCollisionsCount"
	.size	.L__unnamed_21, 18

	.type	noCollisionsCount,@object       # @noCollisionsCount
	.local	noCollisionsCount
	.comm	noCollisionsCount,8,8
	.type	__hip_fatbin_wrapper,@object    # @__hip_fatbin_wrapper
	.section	.hipFatBinSegment,"a",@progbits
	.p2align	3, 0x0
__hip_fatbin_wrapper:
	.long	1212764230                      # 0x48495046
	.long	1                               # 0x1
	.quad	__hip_fatbin
	.quad	0
	.size	__hip_fatbin_wrapper, 24

	.type	__hip_gpubin_handle,@object     # @__hip_gpubin_handle
	.local	__hip_gpubin_handle
	.comm	__hip_gpubin_handle,8,8
	.section	.init_array,"aw",@init_array
	.p2align	3, 0x0
	.quad	_GLOBAL__sub_I_cuda_simulator.hip
	.quad	__hip_module_ctor
	.type	__hip_cuid_,@object             # @__hip_cuid_
	.bss
	.globl	__hip_cuid_
__hip_cuid_:
	.byte	0                               # 0x0
	.size	__hip_cuid_, 1

	.ident	"AMD clang version 18.0.0git (https://github.com/RadeonOpenCompute/llvm-project roc-6.3.2 25012 e5bf7e55c91490b07c49d8960fa7983d864936c4)"
	.section	".note.GNU-stack","",@progbits
	.addrsig
	.addrsig_sym __gxx_personality_v0
	.addrsig_sym _Z32__device_stub__timeWallCollisionv
	.addrsig_sym _Z36__device_stub__timeParticleCollisionv
	.addrsig_sym _Z36__device_stub__findEarliestCollisionv
	.addrsig_sym _Z39__device_stub__executeParticleCollisionv
	.addrsig_sym _Z35__device_stub__executeWallCollisionv
	.addrsig_sym _Z33__device_stub__executeNoCollisionv
	.addrsig_sym _GLOBAL__sub_I_cuda_simulator.hip
	.addrsig_sym __hip_module_ctor
	.addrsig_sym __hip_module_dtor
	.addrsig_sym _Unwind_Resume
	.addrsig_sym rng
	.addrsig_sym rd
	.addrsig_sym __dso_handle
	.addrsig_sym n.managed
	.addrsig_sym l.managed
	.addrsig_sym r.managed
	.addrsig_sym s.managed
	.addrsig_sym streams
	.addrsig_sym particles.managed
	.addrsig_sym particleCollisionTimes.managed
	.addrsig_sym wallCollisionTimes.managed
	.addrsig_sym temp.managed
	.addrsig_sym found.managed
	.addrsig_sym particleCollisions.managed
	.addrsig_sym particleCollisionsCount.managed
	.addrsig_sym wallCollisions.managed
	.addrsig_sym wallCollisionsCount.managed
	.addrsig_sym noCollisions.managed
	.addrsig_sym noCollisionsCount.managed
	.addrsig_sym _ZSt3cin
	.addrsig_sym _ZSt4cout
	.addrsig_sym _Z17timeWallCollisionv
	.addrsig_sym _Z21timeParticleCollisionv
	.addrsig_sym _Z21findEarliestCollisionv
	.addrsig_sym _Z24executeParticleCollisionv
	.addrsig_sym _Z20executeWallCollisionv
	.addrsig_sym _Z18executeNoCollisionv
	.addrsig_sym n
	.addrsig_sym l
	.addrsig_sym r
	.addrsig_sym s
	.addrsig_sym particles
	.addrsig_sym particleCollisionTimes
	.addrsig_sym wallCollisionTimes
	.addrsig_sym temp
	.addrsig_sym found
	.addrsig_sym particleCollisions
	.addrsig_sym particleCollisionsCount
	.addrsig_sym wallCollisions
	.addrsig_sym wallCollisionsCount
	.addrsig_sym noCollisions
	.addrsig_sym noCollisionsCount
	.addrsig_sym __hip_fatbin
	.addrsig_sym __hip_fatbin_wrapper
	.addrsig_sym __hip_cuid_

	.text
	.amdgcn_target "amdgcn-amd-amdhsa--gfx1100"
	.protected	_Z21findEarliestCollisionv ; -- Begin function _Z21findEarliestCollisionv
	.globl	_Z21findEarliestCollisionv
	.p2align	8
	.type	_Z21findEarliestCollisionv,@function
_Z21findEarliestCollisionv:             ; @_Z21findEarliestCollisionv
; %bb.0:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, n@rel32@lo+4
	s_addc_u32 s3, s3, n@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_load_b32 s0, s[0:1], 0xc
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_and_b32 s0, s0, 0xffff
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[7:8], null, s15, s0, v[0:1]
	s_mov_b32 s0, exec_lo
	s_waitcnt lgkmcnt(0)
	v_cmpx_gt_i32_e64 s1, v7
	s_cbranch_execz .LBB0_15
; %bb.1:
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, found@rel32@lo+4
	s_addc_u32 s1, s1, found@rel32@hi+12
	v_ashrrev_i32_e32 v8, 31, v7
	s_load_b64 s[0:1], s[0:1], 0x0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_3) | instid1(VALU_DEP_1)
	v_lshlrev_b64 v[0:1], 2, v[7:8]
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	v_add_co_u32 v0, vcc_lo, s0, v0
	s_delay_alu instid0(VALU_DEP_2)
	v_add_co_ci_u32_e32 v1, vcc_lo, s1, v1, vcc_lo
	flat_load_b32 v0, v[0:1]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmp_eq_u32_e32 vcc_lo, -1, v0
	s_and_b32 exec_lo, exec_lo, vcc_lo
	s_cbranch_execz .LBB0_15
; %bb.2:
	v_mov_b32_e32 v2, 0
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, temp@rel32@lo+4
	s_addc_u32 s1, s1, temp@rel32@hi+12
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, wallCollisionTimes@rel32@lo+4
	s_addc_u32 s3, s3, wallCollisionTimes@rel32@hi+12
	s_clause 0x1
	global_load_b64 v[9:10], v2, s[0:1]
	global_load_b64 v[11:12], v2, s[2:3]
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, particles@rel32@lo+4
	s_addc_u32 s3, s3, particles@rel32@hi+12
	s_load_b64 s[4:5], s[2:3], 0x0
	s_load_b64 s[0:1], s[0:1], 0x0
	v_mov_b32_e32 v3, v2
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[4:5], s[4:5], 0x0
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	v_mad_i64_i32 v[0:1], null, v7, 48, s[4:5]
	v_mad_i64_i32 v[13:14], null, v7, 40, s[0:1]
	flat_store_b128 v[13:14], v[0:3] offset:8
	v_mov_b32_e32 v3, 0x3ff00000
	s_delay_alu instid0(VALU_DEP_1)
	v_dual_mov_b32 v5, 2 :: v_dual_mov_b32 v4, v3
	v_mov_b32_e32 v3, v2
	flat_store_b96 v[13:14], v[3:5] offset:24
	s_waitcnt vmcnt(1)
	global_load_b64 v[0:1], v[9:10], off
	s_waitcnt vmcnt(1)
	global_load_b64 v[3:4], v[11:12], off
	v_lshlrev_b64 v[8:9], 3, v[7:8]
	s_waitcnt vmcnt(1)
	v_mad_i64_i32 v[10:11], null, v7, 40, v[0:1]
	s_waitcnt vmcnt(0)
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_co_u32 v0, vcc_lo, v3, v8
	v_add_co_ci_u32_e32 v1, vcc_lo, v4, v9, vcc_lo
	flat_load_b64 v[4:5], v[0:1]
	flat_load_b64 v[0:1], v[10:11] offset:24
	s_waitcnt vmcnt(1) lgkmcnt(1)
	v_cmp_gt_f64_e64 s0, 1.0, v[4:5]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmp_lt_f64_e32 vcc_lo, v[4:5], v[0:1]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(SALU_CYCLE_1)
	s_and_b32 s1, s0, vcc_lo
	s_and_saveexec_b32 s0, s1
	s_cbranch_execz .LBB0_4
; %bb.3:
	global_load_b64 v[0:1], v2, s[2:3]
	v_mov_b32_e32 v3, v2
	v_mov_b32_e32 v6, v2
	s_waitcnt vmcnt(0)
	global_load_b64 v[12:13], v[0:1], off
	s_waitcnt vmcnt(0)
	v_mad_i64_i32 v[0:1], null, v7, 48, v[12:13]
	s_clause 0x1
	flat_store_b128 v[10:11], v[0:3] offset:8
	flat_store_b96 v[10:11], v[4:6] offset:24
.LBB0_4:
	s_or_b32 exec_lo, exec_lo, s0
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, n@rel32@lo+4
	s_addc_u32 s1, s1, n@rel32@hi+12
	global_load_b64 v[0:1], v2, s[0:1]
	s_waitcnt vmcnt(0)
	global_load_b32 v6, v[0:1], off
	s_waitcnt vmcnt(0)
	v_cmp_gt_i32_e32 vcc_lo, 1, v6
	s_cbranch_vccnz .LBB0_15
; %bb.5:                                ; %.lr.ph.preheader
	v_dual_mov_b32 v5, 0 :: v_dual_mov_b32 v2, 1
	s_mov_b64 s[2:3], 0
	s_mov_b32 s1, 0
	s_mov_b64 s[4:5], 0
	s_mov_b64 s[6:7], 0
	s_mov_b32 s8, 0
.LBB0_6:                                ; %.lr.ph
                                        ; =>This Inner Loop Header: Depth=1
	s_mov_b32 s9, exec_lo
	v_cmpx_ne_u32_e64 s8, v7
	s_cbranch_execz .LBB0_14
; %bb.7:                                ;   in Loop: Header=BB0_6 Depth=1
	s_getpc_b64 s[10:11]
	s_add_u32 s10, s10, found@rel32@lo+4
	s_addc_u32 s11, s11, found@rel32@hi+12
	global_load_b64 v[0:1], v5, s[10:11]
	s_mov_b32 s10, exec_lo
	s_waitcnt vmcnt(0)
	global_load_b64 v[0:1], v[0:1], off
	s_waitcnt vmcnt(0)
	v_add_co_u32 v0, vcc_lo, v0, s6
	v_add_co_ci_u32_e32 v1, vcc_lo, s7, v1, vcc_lo
	flat_load_b32 v0, v[0:1]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_eq_u32_e32 -1, v0
	s_cbranch_execz .LBB0_13
; %bb.8:                                ;   in Loop: Header=BB0_6 Depth=1
	s_getpc_b64 s[12:13]
	s_add_u32 s12, s12, particleCollisionTimes@rel32@lo+4
	s_addc_u32 s13, s13, particleCollisionTimes@rel32@hi+12
	s_mov_b32 s11, exec_lo
	global_load_b64 v[0:1], v5, s[12:13]
	s_waitcnt vmcnt(0)
	global_load_b64 v[0:1], v[0:1], off
	s_waitcnt vmcnt(0)
	v_add_co_u32 v0, vcc_lo, v0, v8
	v_add_co_ci_u32_e32 v1, vcc_lo, v1, v9, vcc_lo
	flat_load_b64 v[0:1], v[0:1]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_co_u32 v0, vcc_lo, v0, s4
	v_add_co_ci_u32_e32 v1, vcc_lo, s5, v1, vcc_lo
	flat_load_b64 v[0:1], v[0:1]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_lt_f64_e32 -1.0, v[0:1]
	s_cbranch_execz .LBB0_12
; %bb.9:                                ;   in Loop: Header=BB0_6 Depth=1
	s_getpc_b64 s[12:13]
	s_add_u32 s12, s12, temp@rel32@lo+4
	s_addc_u32 s13, s13, temp@rel32@hi+12
	v_cmp_gt_f64_e64 s0, 1.0, v[0:1]
	global_load_b64 v[3:4], v5, s[12:13]
	s_waitcnt vmcnt(0)
	global_load_b64 v[10:11], v[3:4], off
	s_waitcnt vmcnt(0)
	v_mad_i64_i32 v[3:4], null, v7, 40, v[10:11]
	flat_load_b64 v[10:11], v[3:4] offset:24
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmp_lt_f64_e32 vcc_lo, v[0:1], v[10:11]
	s_and_b32 s12, s0, vcc_lo
	s_delay_alu instid0(SALU_CYCLE_1)
	s_and_saveexec_b32 s0, s12
	s_cbranch_execz .LBB0_11
; %bb.10:                               ;   in Loop: Header=BB0_6 Depth=1
	s_getpc_b64 s[12:13]
	s_add_u32 s12, s12, particles@rel32@lo+4
	s_addc_u32 s13, s13, particles@rel32@hi+12
	global_load_b64 v[10:11], v5, s[12:13]
	s_getpc_b64 s[12:13]
	s_add_u32 s12, s12, n@rel32@lo+4
	s_addc_u32 s13, s13, n@rel32@hi+12
	global_load_b64 v[14:15], v5, s[12:13]
	s_waitcnt vmcnt(1)
	global_load_b64 v[12:13], v[10:11], off
	s_waitcnt vmcnt(0)
	v_mad_i64_i32 v[10:11], null, v7, 48, v[12:13]
	v_add_co_u32 v12, vcc_lo, v12, s2
	v_add_co_ci_u32_e32 v13, vcc_lo, s3, v13, vcc_lo
	s_clause 0x1
	flat_store_b128 v[3:4], v[10:13] offset:8
	flat_store_b96 v[3:4], v[0:2] offset:24
	global_load_b32 v6, v[14:15], off
.LBB0_11:                               ; %Flow
                                        ;   in Loop: Header=BB0_6 Depth=1
	s_or_b32 exec_lo, exec_lo, s0
.LBB0_12:                               ; %Flow50
                                        ;   in Loop: Header=BB0_6 Depth=1
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s11
.LBB0_13:                               ; %Flow51
                                        ;   in Loop: Header=BB0_6 Depth=1
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s10
.LBB0_14:                               ;   in Loop: Header=BB0_6 Depth=1
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s9
	s_add_i32 s8, s8, 1
	s_add_u32 s6, s6, 4
	s_addc_u32 s7, s7, 0
	s_waitcnt vmcnt(0)
	v_cmp_ge_i32_e32 vcc_lo, s8, v6
	s_add_u32 s4, s4, 8
	s_addc_u32 s5, s5, 0
	s_add_u32 s2, s2, 48
	s_addc_u32 s3, s3, 0
	s_or_b32 s1, vcc_lo, s1
	s_delay_alu instid0(SALU_CYCLE_1)
	s_and_not1_b32 exec_lo, exec_lo, s1
	s_cbranch_execnz .LBB0_6
.LBB0_15:                               ; %.loopexit
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z21findEarliestCollisionv
		.amdhsa_group_segment_fixed_size 0
		.amdhsa_private_segment_fixed_size 0
		.amdhsa_kernarg_size 256
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 0
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 16
		.amdhsa_next_free_sgpr 16
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end0:
	.size	_Z21findEarliestCollisionv, .Lfunc_end0-_Z21findEarliestCollisionv
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 1128
; NumSgprs: 18
; NumVgprs: 16
; ScratchSize: 0
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 0 bytes/workgroup (compile time only)
; SGPRBlocks: 2
; VGPRBlocks: 1
; NumSGPRsForWavesPerEU: 18
; NumVGPRsForWavesPerEU: 16
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 0
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.protected	_Z21timeParticleCollisionv ; -- Begin function _Z21timeParticleCollisionv
	.globl	_Z21timeParticleCollisionv
	.p2align	8
	.type	_Z21timeParticleCollisionv,@function
_Z21timeParticleCollisionv:             ; @_Z21timeParticleCollisionv
; %bb.0:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, n@rel32@lo+4
	s_addc_u32 s3, s3, n@rel32@hi+12
	v_and_b32_e32 v1, 0x3ff, v0
	s_load_b64 s[2:3], s[2:3], 0x0
	s_load_b32 s0, s[0:1], 0xc
	v_bfe_u32 v4, v0, 10, 10
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_lshr_b32 s2, s0, 16
	s_and_b32 s0, s0, 0xffff
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[2:3], null, s14, s0, v[1:2]
	v_mad_u64_u32 v[0:1], null, s15, s2, v[4:5]
	v_max_i32_e32 v1, v2, v0
	v_cmp_lt_i32_e64 s0, v2, v0
	s_waitcnt lgkmcnt(0)
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_cmp_gt_i32_e32 vcc_lo, s1, v1
	s_and_b32 s0, s0, vcc_lo
	s_delay_alu instid0(SALU_CYCLE_1)
	s_and_saveexec_b32 s1, s0
	s_cbranch_execz .LBB1_6
; %bb.1:
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, particles@rel32@lo+4
	s_addc_u32 s1, s1, particles@rel32@hi+12
	s_mov_b32 s4, 0x55555555
	s_load_b64 s[0:1], s[0:1], 0x0
	s_mov_b32 s5, 0x3fe55555
	s_mov_b32 s6, 0x968915a9
	s_mov_b32 s8, 0x4222de17
	s_mov_b32 s7, 0x3fba6564
	s_mov_b32 s9, 0x3fbdee67
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	v_mad_i64_i32 v[10:11], null, v2, 48, s[0:1]
	v_mad_i64_i32 v[20:21], null, v0, 48, s[0:1]
	s_clause 0x3
	flat_load_b128 v[12:15], v[10:11] offset:8
	flat_load_b128 v[16:19], v[20:21] offset:8
	flat_load_b128 v[0:3], v[20:21] offset:24
	flat_load_b128 v[4:7], v[10:11] offset:24
	s_waitcnt vmcnt(2) lgkmcnt(2)
	v_add_f64 v[8:9], v[12:13], -v[16:17]
	v_add_f64 v[13:14], v[14:15], -v[18:19]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_f64 v[0:1], v[4:5], -v[0:1]
	v_add_f64 v[2:3], v[6:7], -v[2:3]
	flat_load_b32 v12, v[20:21]
	v_frexp_mant_f64_e64 v[4:5], |v[8:9]|
	v_frexp_mant_f64_e64 v[6:7], |v[13:14]|
	v_frexp_mant_f64_e64 v[15:16], |v[0:1]|
	v_frexp_mant_f64_e64 v[17:18], |v[2:3]|
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_cmp_gt_f64_e32 vcc_lo, s[4:5], v[4:5]
	v_cmp_gt_f64_e64 s0, s[4:5], v[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_cmp_gt_f64_e64 s1, s[4:5], v[15:16]
	v_cmp_gt_f64_e64 s2, s[4:5], v[17:18]
	v_cndmask_b32_e64 v19, 0, 1, vcc_lo
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e64 v20, 0, 1, s0
	v_cndmask_b32_e64 v21, 0, 1, s2
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_1) | instid1(VALU_DEP_4)
	v_ldexp_f64 v[4:5], v[4:5], v19
	v_cndmask_b32_e64 v19, 0, 1, s1
	v_ldexp_f64 v[6:7], v[6:7], v20
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_ldexp_f64 v[17:18], v[17:18], v21
	v_ldexp_f64 v[15:16], v[15:16], v19
	v_add_f64 v[19:20], v[4:5], 1.0
	v_add_f64 v[43:44], v[4:5], -1.0
	v_add_f64 v[21:22], v[6:7], 1.0
	v_add_f64 v[25:26], v[17:18], 1.0
	v_add_f64 v[23:24], v[15:16], 1.0
	v_rcp_f64_e32 v[27:28], v[19:20]
	v_add_f64 v[51:52], v[19:20], -1.0
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_rcp_f64_e32 v[29:30], v[21:22]
	v_rcp_f64_e32 v[33:34], v[25:26]
	v_add_f64 v[55:56], v[21:22], -1.0
	v_add_f64 v[63:64], v[25:26], -1.0
	s_delay_alu instid0(VALU_DEP_4) | instskip(SKIP_1) | instid1(VALU_DEP_4)
	v_rcp_f64_e32 v[31:32], v[23:24]
	v_add_f64 v[59:60], v[23:24], -1.0
	v_add_f64 v[4:5], v[4:5], -v[51:52]
	v_fma_f64 v[35:36], -v[19:20], v[27:28], 1.0
	s_delay_alu instid0(TRANS32_DEP_3) | instskip(NEXT) | instid1(TRANS32_DEP_2)
	v_fma_f64 v[37:38], -v[21:22], v[29:30], 1.0
	v_fma_f64 v[41:42], -v[25:26], v[33:34], 1.0
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[39:40], -v[23:24], v[31:32], 1.0
	v_fma_f64 v[27:28], v[35:36], v[27:28], v[27:28]
	v_fma_f64 v[29:30], v[37:38], v[29:30], v[29:30]
	v_fma_f64 v[33:34], v[41:42], v[33:34], v[33:34]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[31:32], v[39:40], v[31:32], v[31:32]
	v_fma_f64 v[35:36], -v[19:20], v[27:28], 1.0
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[37:38], -v[21:22], v[29:30], 1.0
	v_fma_f64 v[41:42], -v[25:26], v[33:34], 1.0
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[39:40], -v[23:24], v[31:32], 1.0
	v_fma_f64 v[27:28], v[35:36], v[27:28], v[27:28]
	v_add_f64 v[35:36], v[6:7], -1.0
	v_fma_f64 v[29:30], v[37:38], v[29:30], v[29:30]
	v_add_f64 v[37:38], v[15:16], -1.0
	v_fma_f64 v[33:34], v[41:42], v[33:34], v[33:34]
	v_add_f64 v[6:7], v[6:7], -v[55:56]
	v_fma_f64 v[31:32], v[39:40], v[31:32], v[31:32]
	v_add_f64 v[39:40], v[17:18], -1.0
	v_add_f64 v[15:16], v[15:16], -v[59:60]
	v_add_f64 v[17:18], v[17:18], -v[63:64]
	v_mul_f64 v[41:42], v[43:44], v[27:28]
	v_mul_f64 v[45:46], v[35:36], v[29:30]
	v_mul_f64 v[47:48], v[37:38], v[31:32]
	v_mul_f64 v[49:50], v[39:40], v[33:34]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_mul_f64 v[53:54], v[19:20], v[41:42]
	v_mul_f64 v[57:58], v[21:22], v[45:46]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_mul_f64 v[61:62], v[23:24], v[47:48]
	v_mul_f64 v[65:66], v[25:26], v[49:50]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[19:20], v[41:42], v[19:20], -v[53:54]
	v_fma_f64 v[21:22], v[45:46], v[21:22], -v[57:58]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[23:24], v[47:48], v[23:24], -v[61:62]
	v_fma_f64 v[25:26], v[49:50], v[25:26], -v[65:66]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[4:5], v[41:42], v[4:5], v[19:20]
	v_fma_f64 v[6:7], v[45:46], v[6:7], v[21:22]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[15:16], v[47:48], v[15:16], v[23:24]
	v_fma_f64 v[17:18], v[49:50], v[17:18], v[25:26]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[19:20], v[53:54], v[4:5]
	v_add_f64 v[21:22], v[57:58], v[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[23:24], v[61:62], v[15:16]
	v_add_f64 v[25:26], v[65:66], v[17:18]
	s_delay_alu instid0(VALU_DEP_4)
	v_add_f64 v[51:52], v[43:44], -v[19:20]
	v_add_f64 v[53:54], v[19:20], -v[53:54]
	v_add_f64 v[55:56], v[35:36], -v[21:22]
	v_add_f64 v[57:58], v[21:22], -v[57:58]
	v_add_f64 v[59:60], v[37:38], -v[23:24]
	v_add_f64 v[63:64], v[39:40], -v[25:26]
	v_add_f64 v[61:62], v[23:24], -v[61:62]
	v_add_f64 v[65:66], v[25:26], -v[65:66]
	v_add_f64 v[43:44], v[43:44], -v[51:52]
	v_add_f64 v[4:5], v[53:54], -v[4:5]
	v_add_f64 v[35:36], v[35:36], -v[55:56]
	v_add_f64 v[6:7], v[57:58], -v[6:7]
	v_add_f64 v[37:38], v[37:38], -v[59:60]
	v_add_f64 v[39:40], v[39:40], -v[63:64]
	v_add_f64 v[15:16], v[61:62], -v[15:16]
	v_add_f64 v[17:18], v[65:66], -v[17:18]
	v_add_f64 v[19:20], v[43:44], -v[19:20]
	v_add_f64 v[21:22], v[35:36], -v[21:22]
	v_add_f64 v[23:24], v[37:38], -v[23:24]
	v_add_f64 v[25:26], v[39:40], -v[25:26]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[4:5], v[4:5], v[19:20]
	v_add_f64 v[6:7], v[6:7], v[21:22]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[15:16], v[15:16], v[23:24]
	v_add_f64 v[17:18], v[17:18], v[25:26]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[4:5], v[51:52], v[4:5]
	v_add_f64 v[6:7], v[55:56], v[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[15:16], v[59:60], v[15:16]
	v_add_f64 v[17:18], v[63:64], v[17:18]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_mul_f64 v[4:5], v[27:28], v[4:5]
	v_mul_f64 v[6:7], v[29:30], v[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_mul_f64 v[15:16], v[31:32], v[15:16]
	v_mul_f64 v[17:18], v[33:34], v[17:18]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[19:20], v[41:42], v[4:5]
	v_add_f64 v[21:22], v[45:46], v[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[23:24], v[47:48], v[15:16]
	v_add_f64 v[25:26], v[49:50], v[17:18]
	s_delay_alu instid0(VALU_DEP_4)
	v_add_f64 v[27:28], v[19:20], -v[41:42]
	v_mul_f64 v[35:36], v[19:20], v[19:20]
	v_add_f64 v[29:30], v[21:22], -v[45:46]
	v_add_f64 v[31:32], v[23:24], -v[47:48]
	v_add_f64 v[33:34], v[25:26], -v[49:50]
	v_add_f64 v[4:5], v[4:5], -v[27:28]
	v_mul_f64 v[27:28], v[21:22], v[21:22]
	v_add_f64 v[6:7], v[6:7], -v[29:30]
	v_mul_f64 v[29:30], v[23:24], v[23:24]
	v_add_f64 v[15:16], v[15:16], -v[31:32]
	v_mul_f64 v[31:32], v[25:26], v[25:26]
	v_add_f64 v[17:18], v[17:18], -v[33:34]
	v_fma_f64 v[33:34], v[19:20], v[19:20], -v[35:36]
	v_add_f64 v[37:38], v[4:5], v[4:5]
	v_fma_f64 v[39:40], v[21:22], v[21:22], -v[27:28]
	v_add_f64 v[41:42], v[6:7], v[6:7]
	v_fma_f64 v[43:44], v[23:24], v[23:24], -v[29:30]
	v_add_f64 v[45:46], v[15:16], v[15:16]
	v_fma_f64 v[47:48], v[25:26], v[25:26], -v[31:32]
	v_add_f64 v[49:50], v[17:18], v[17:18]
	v_fma_f64 v[33:34], v[19:20], v[37:38], v[33:34]
	v_fma_f64 v[37:38], v[21:22], v[41:42], v[39:40]
	v_fma_f64 v[39:40], v[23:24], v[45:46], v[43:44]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[41:42], v[25:26], v[49:50], v[47:48]
	v_add_f64 v[43:44], v[35:36], v[33:34]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[45:46], v[27:28], v[37:38]
	v_add_f64 v[47:48], v[29:30], v[39:40]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[49:50], v[31:32], v[41:42]
	v_fma_f64 v[51:52], v[43:44], s[8:9], s[6:7]
	v_add_f64 v[35:36], v[43:44], -v[35:36]
	v_fma_f64 v[53:54], v[45:46], s[8:9], s[6:7]
	v_add_f64 v[27:28], v[45:46], -v[27:28]
	v_mul_f64 v[69:70], v[19:20], v[43:44]
	v_mul_f64 v[71:72], v[21:22], v[45:46]
	v_fma_f64 v[55:56], v[47:48], s[8:9], s[6:7]
	v_add_f64 v[29:30], v[47:48], -v[29:30]
	v_fma_f64 v[57:58], v[49:50], s[8:9], s[6:7]
	s_mov_b32 s6, 0x3abe935a
	s_mov_b32 s7, 0x3fbe25e4
	v_add_f64 v[31:32], v[49:50], -v[31:32]
	v_mul_f64 v[77:78], v[23:24], v[47:48]
	v_mul_f64 v[81:82], v[25:26], v[49:50]
	s_mov_b32 s8, 0x652b82fe
	s_mov_b32 s9, 0x3ff71547
	v_fma_f64 v[51:52], v[43:44], v[51:52], s[6:7]
	v_add_f64 v[33:34], v[33:34], -v[35:36]
	v_fma_f64 v[53:54], v[45:46], v[53:54], s[6:7]
	v_add_f64 v[27:28], v[37:38], -v[27:28]
	v_fma_f64 v[85:86], v[45:46], v[21:22], -v[71:72]
	v_fma_f64 v[55:56], v[47:48], v[55:56], s[6:7]
	v_add_f64 v[29:30], v[39:40], -v[29:30]
	v_fma_f64 v[57:58], v[49:50], v[57:58], s[6:7]
	s_mov_b32 s6, 0x47e6c9c2
	s_mov_b32 s7, 0x3fc110ef
	v_add_f64 v[31:32], v[41:42], -v[31:32]
	v_fma_f64 v[51:52], v[43:44], v[51:52], s[6:7]
	v_fma_f64 v[53:54], v[45:46], v[53:54], s[6:7]
	v_fma_f64 v[55:56], v[47:48], v[55:56], s[6:7]
	v_fma_f64 v[57:58], v[49:50], v[57:58], s[6:7]
	s_mov_b32 s6, 0xcfa74449
	s_mov_b32 s7, 0x3fc3b13b
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[51:52], v[43:44], v[51:52], s[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[53:54], v[45:46], v[53:54], s[6:7]
	v_fma_f64 v[55:56], v[47:48], v[55:56], s[6:7]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[57:58], v[49:50], v[57:58], s[6:7]
	s_mov_b32 s6, 0x71bf3c30
	s_mov_b32 s7, 0x3fc745d1
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[51:52], v[43:44], v[51:52], s[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[53:54], v[45:46], v[53:54], s[6:7]
	v_fma_f64 v[55:56], v[47:48], v[55:56], s[6:7]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[57:58], v[49:50], v[57:58], s[6:7]
	s_mov_b32 s6, 0x1c7792ce
	s_mov_b32 s7, 0x3fcc71c7
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[51:52], v[43:44], v[51:52], s[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[53:54], v[45:46], v[53:54], s[6:7]
	v_fma_f64 v[55:56], v[47:48], v[55:56], s[6:7]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[57:58], v[49:50], v[57:58], s[6:7]
	s_mov_b32 s6, 0x924920da
	s_mov_b32 s7, 0x3fd24924
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[51:52], v[43:44], v[51:52], s[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[53:54], v[45:46], v[53:54], s[6:7]
	v_fma_f64 v[55:56], v[47:48], v[55:56], s[6:7]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[57:58], v[49:50], v[57:58], s[6:7]
	s_mov_b32 s6, 0x9999999c
	s_mov_b32 s7, 0x3fd99999
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[51:52], v[43:44], v[51:52], s[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[53:54], v[45:46], v[53:54], s[6:7]
	v_fma_f64 v[55:56], v[47:48], v[55:56], s[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(SKIP_2) | instid1(VALU_DEP_4)
	v_fma_f64 v[57:58], v[49:50], v[57:58], s[6:7]
	s_mov_b32 s6, 0x3b39803f
	s_mov_b32 s7, 0x3c7abc9e
	v_mul_f64 v[59:60], v[43:44], v[51:52]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_mul_f64 v[61:62], v[45:46], v[53:54]
	v_mul_f64 v[63:64], v[47:48], v[55:56]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_mul_f64 v[65:66], v[49:50], v[57:58]
	v_fma_f64 v[35:36], v[43:44], v[51:52], -v[59:60]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[37:38], v[45:46], v[53:54], -v[61:62]
	v_fma_f64 v[45:46], v[45:46], v[6:7], v[85:86]
	v_ldexp_f64 v[6:7], v[6:7], 1
	v_fma_f64 v[39:40], v[47:48], v[55:56], -v[63:64]
	v_fma_f64 v[41:42], v[49:50], v[57:58], -v[65:66]
	v_fma_f64 v[35:36], v[33:34], v[51:52], v[35:36]
	v_fma_f64 v[37:38], v[27:28], v[53:54], v[37:38]
	v_fma_f64 v[27:28], v[27:28], v[21:22], v[45:46]
	v_ldexp_f64 v[21:22], v[21:22], 1
	v_fma_f64 v[39:40], v[29:30], v[55:56], v[39:40]
	v_fma_f64 v[41:42], v[31:32], v[57:58], v[41:42]
	v_add_f64 v[51:52], v[59:60], v[35:36]
	v_add_f64 v[53:54], v[61:62], v[37:38]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[55:56], v[63:64], v[39:40]
	v_add_f64 v[57:58], v[65:66], v[41:42]
	s_delay_alu instid0(VALU_DEP_4)
	v_add_f64 v[67:68], v[51:52], s[4:5]
	v_add_f64 v[59:60], v[51:52], -v[59:60]
	v_add_f64 v[73:74], v[53:54], s[4:5]
	v_add_f64 v[61:62], v[53:54], -v[61:62]
	v_add_f64 v[75:76], v[55:56], s[4:5]
	v_add_f64 v[63:64], v[55:56], -v[63:64]
	v_add_f64 v[79:80], v[57:58], s[4:5]
	v_add_f64 v[65:66], v[57:58], -v[65:66]
	s_mov_b32 s5, 0xbfe55555
	s_delay_alu instid0(SALU_CYCLE_1)
	v_add_f64 v[83:84], v[67:68], s[4:5]
	v_add_f64 v[35:36], v[35:36], -v[59:60]
	v_fma_f64 v[59:60], v[43:44], v[19:20], -v[69:70]
	v_add_f64 v[87:88], v[73:74], s[4:5]
	v_add_f64 v[37:38], v[37:38], -v[61:62]
	v_add_f64 v[61:62], v[75:76], s[4:5]
	v_add_f64 v[39:40], v[39:40], -v[63:64]
	v_fma_f64 v[63:64], v[47:48], v[23:24], -v[77:78]
	v_add_f64 v[89:90], v[79:80], s[4:5]
	v_add_f64 v[41:42], v[41:42], -v[65:66]
	v_fma_f64 v[65:66], v[49:50], v[25:26], -v[81:82]
	s_mov_b32 s4, 0xd5df274d
	s_mov_b32 s5, 0x3c8543b0
	v_add_f64 v[51:52], v[51:52], -v[83:84]
	v_add_f64 v[35:36], v[35:36], s[4:5]
	v_fma_f64 v[43:44], v[43:44], v[4:5], v[59:60]
	v_add_f64 v[53:54], v[53:54], -v[87:88]
	v_add_f64 v[37:38], v[37:38], s[4:5]
	v_ldexp_f64 v[4:5], v[4:5], 1
	v_add_f64 v[55:56], v[55:56], -v[61:62]
	v_add_f64 v[39:40], v[39:40], s[4:5]
	v_fma_f64 v[47:48], v[47:48], v[15:16], v[63:64]
	v_add_f64 v[57:58], v[57:58], -v[89:90]
	v_add_f64 v[41:42], v[41:42], s[4:5]
	v_fma_f64 v[49:50], v[49:50], v[17:18], v[65:66]
	s_mov_b32 s4, 0xfefa39ef
	s_mov_b32 s5, 0x3fe62e42
	v_ldexp_f64 v[15:16], v[15:16], 1
	v_ldexp_f64 v[17:18], v[17:18], 1
	v_add_f64 v[35:36], v[35:36], v[51:52]
	v_fma_f64 v[33:34], v[33:34], v[19:20], v[43:44]
	v_ldexp_f64 v[19:20], v[19:20], 1
	v_add_f64 v[37:38], v[37:38], v[53:54]
	v_add_f64 v[39:40], v[39:40], v[55:56]
	v_fma_f64 v[29:30], v[29:30], v[23:24], v[47:48]
	v_ldexp_f64 v[23:24], v[23:24], 1
	v_add_f64 v[41:42], v[41:42], v[57:58]
	v_fma_f64 v[31:32], v[31:32], v[25:26], v[49:50]
	v_add_f64 v[49:50], v[71:72], v[27:28]
	v_ldexp_f64 v[25:26], v[25:26], 1
	v_add_f64 v[43:44], v[67:68], v[35:36]
	v_add_f64 v[45:46], v[69:70], v[33:34]
	v_add_f64 v[47:48], v[73:74], v[37:38]
	v_add_f64 v[51:52], v[75:76], v[39:40]
	v_add_f64 v[53:54], v[77:78], v[29:30]
	v_add_f64 v[55:56], v[79:80], v[41:42]
	v_add_f64 v[57:58], v[81:82], v[31:32]
	v_add_f64 v[71:72], v[49:50], -v[71:72]
	v_add_f64 v[59:60], v[67:68], -v[43:44]
	v_mul_f64 v[61:62], v[45:46], v[43:44]
	v_add_f64 v[69:70], v[45:46], -v[69:70]
	v_add_f64 v[63:64], v[73:74], -v[47:48]
	v_mul_f64 v[65:66], v[49:50], v[47:48]
	v_add_f64 v[67:68], v[75:76], -v[51:52]
	v_mul_f64 v[73:74], v[53:54], v[51:52]
	v_add_f64 v[77:78], v[53:54], -v[77:78]
	v_add_f64 v[75:76], v[79:80], -v[55:56]
	v_mul_f64 v[79:80], v[57:58], v[55:56]
	v_add_f64 v[81:82], v[57:58], -v[81:82]
	v_add_f64 v[27:28], v[27:28], -v[71:72]
	v_add_f64 v[35:36], v[35:36], v[59:60]
	v_fma_f64 v[59:60], v[45:46], v[43:44], -v[61:62]
	v_add_f64 v[33:34], v[33:34], -v[69:70]
	v_add_f64 v[37:38], v[37:38], v[63:64]
	v_fma_f64 v[63:64], v[49:50], v[47:48], -v[65:66]
	v_add_f64 v[39:40], v[39:40], v[67:68]
	v_fma_f64 v[67:68], v[53:54], v[51:52], -v[73:74]
	v_add_f64 v[29:30], v[29:30], -v[77:78]
	v_add_f64 v[41:42], v[41:42], v[75:76]
	v_fma_f64 v[75:76], v[57:58], v[55:56], -v[79:80]
	v_add_f64 v[31:32], v[31:32], -v[81:82]
	v_fma_f64 v[35:36], v[45:46], v[35:36], v[59:60]
	v_frexp_exp_i32_f64_e32 v45, v[0:1]
	v_frexp_exp_i32_f64_e32 v46, v[2:3]
	v_fma_f64 v[37:38], v[49:50], v[37:38], v[63:64]
	v_fma_f64 v[39:40], v[53:54], v[39:40], v[67:68]
	v_fma_f64 v[41:42], v[57:58], v[41:42], v[75:76]
	v_fma_f64 v[33:34], v[33:34], v[43:44], v[35:36]
	v_frexp_exp_i32_f64_e32 v43, v[8:9]
	v_frexp_exp_i32_f64_e32 v44, v[13:14]
	v_fma_f64 v[27:28], v[27:28], v[47:48], v[37:38]
	v_fma_f64 v[29:30], v[29:30], v[51:52], v[39:40]
	v_fma_f64 v[31:32], v[31:32], v[55:56], v[41:42]
	v_add_f64 v[35:36], v[61:62], v[33:34]
	v_subrev_co_ci_u32_e32 v43, vcc_lo, 0, v43, vcc_lo
	v_add_f64 v[37:38], v[65:66], v[27:28]
	v_subrev_co_ci_u32_e64 v47, vcc_lo, 0, v44, s0
	v_add_f64 v[39:40], v[73:74], v[29:30]
	v_subrev_co_ci_u32_e64 v48, vcc_lo, 0, v45, s1
	v_add_f64 v[41:42], v[79:80], v[31:32]
	v_subrev_co_ci_u32_e64 v49, vcc_lo, 0, v46, s2
	v_cvt_f64_i32_e32 v[43:44], v43
	v_cvt_f64_i32_e32 v[45:46], v47
	v_cvt_f64_i32_e32 v[47:48], v48
	s_delay_alu instid0(VALU_DEP_4)
	v_cvt_f64_i32_e32 v[49:50], v49
	v_add_f64 v[51:52], v[19:20], v[35:36]
	v_add_f64 v[53:54], v[35:36], -v[61:62]
	v_add_f64 v[55:56], v[21:22], v[37:38]
	v_add_f64 v[57:58], v[37:38], -v[65:66]
	v_add_f64 v[59:60], v[23:24], v[39:40]
	v_add_f64 v[61:62], v[39:40], -v[73:74]
	v_add_f64 v[63:64], v[25:26], v[41:42]
	v_add_f64 v[65:66], v[41:42], -v[79:80]
	v_mul_f64 v[67:68], v[43:44], s[4:5]
	v_mul_f64 v[69:70], v[45:46], s[4:5]
	v_mul_f64 v[71:72], v[47:48], s[4:5]
	v_mul_f64 v[73:74], v[49:50], s[4:5]
	v_add_f64 v[19:20], v[51:52], -v[19:20]
	v_add_f64 v[33:34], v[33:34], -v[53:54]
	v_add_f64 v[21:22], v[55:56], -v[21:22]
	v_add_f64 v[27:28], v[27:28], -v[57:58]
	v_add_f64 v[23:24], v[59:60], -v[23:24]
	v_add_f64 v[29:30], v[29:30], -v[61:62]
	v_add_f64 v[25:26], v[63:64], -v[25:26]
	v_add_f64 v[31:32], v[31:32], -v[65:66]
	v_fma_f64 v[53:54], v[43:44], s[4:5], -v[67:68]
	v_add_f64 v[19:20], v[35:36], -v[19:20]
	v_add_f64 v[4:5], v[4:5], v[33:34]
	v_fma_f64 v[33:34], v[45:46], s[4:5], -v[69:70]
	v_add_f64 v[21:22], v[37:38], -v[21:22]
	v_add_f64 v[6:7], v[6:7], v[27:28]
	v_fma_f64 v[35:36], v[47:48], s[4:5], -v[71:72]
	v_add_f64 v[23:24], v[39:40], -v[23:24]
	v_add_f64 v[15:16], v[15:16], v[29:30]
	v_fma_f64 v[27:28], v[49:50], s[4:5], -v[73:74]
	v_add_f64 v[25:26], v[41:42], -v[25:26]
	v_add_f64 v[17:18], v[17:18], v[31:32]
	s_mov_b32 s5, 0xbfe62e42
	v_fma_f64 v[29:30], v[43:44], s[6:7], v[53:54]
	v_add_f64 v[4:5], v[4:5], v[19:20]
	v_fma_f64 v[19:20], v[45:46], s[6:7], v[33:34]
	v_add_f64 v[6:7], v[6:7], v[21:22]
	v_fma_f64 v[21:22], v[47:48], s[6:7], v[35:36]
	v_add_f64 v[15:16], v[15:16], v[23:24]
	v_fma_f64 v[23:24], v[49:50], s[6:7], v[27:28]
	s_mov_b32 s7, 0xbc7abc9e
	v_add_f64 v[17:18], v[17:18], v[25:26]
	v_add_f64 v[25:26], v[67:68], v[29:30]
	v_add_f64 v[27:28], v[51:52], v[4:5]
	v_add_f64 v[31:32], v[69:70], v[19:20]
	v_add_f64 v[33:34], v[55:56], v[6:7]
	v_add_f64 v[35:36], v[71:72], v[21:22]
	v_add_f64 v[37:38], v[59:60], v[15:16]
	v_add_f64 v[39:40], v[73:74], v[23:24]
	v_add_f64 v[41:42], v[63:64], v[17:18]
	v_add_f64 v[67:68], v[25:26], -v[67:68]
	v_add_f64 v[43:44], v[25:26], v[27:28]
	v_add_f64 v[69:70], v[31:32], -v[69:70]
	v_add_f64 v[51:52], v[27:28], -v[51:52]
	v_add_f64 v[45:46], v[31:32], v[33:34]
	v_add_f64 v[55:56], v[33:34], -v[55:56]
	v_add_f64 v[71:72], v[35:36], -v[71:72]
	v_add_f64 v[47:48], v[35:36], v[37:38]
	v_add_f64 v[59:60], v[37:38], -v[59:60]
	v_add_f64 v[73:74], v[39:40], -v[73:74]
	v_add_f64 v[49:50], v[39:40], v[41:42]
	v_add_f64 v[63:64], v[41:42], -v[63:64]
	v_add_f64 v[29:30], v[29:30], -v[67:68]
	v_add_f64 v[53:54], v[43:44], -v[25:26]
	v_add_f64 v[19:20], v[19:20], -v[69:70]
	v_add_f64 v[4:5], v[4:5], -v[51:52]
	v_add_f64 v[57:58], v[45:46], -v[31:32]
	v_add_f64 v[6:7], v[6:7], -v[55:56]
	v_add_f64 v[21:22], v[21:22], -v[71:72]
	v_add_f64 v[61:62], v[47:48], -v[35:36]
	v_add_f64 v[15:16], v[15:16], -v[59:60]
	v_add_f64 v[23:24], v[23:24], -v[73:74]
	v_add_f64 v[65:66], v[49:50], -v[39:40]
	v_add_f64 v[17:18], v[17:18], -v[63:64]
	v_add_f64 v[75:76], v[43:44], -v[53:54]
	v_add_f64 v[27:28], v[27:28], -v[53:54]
	v_add_f64 v[51:52], v[29:30], v[4:5]
	v_add_f64 v[77:78], v[45:46], -v[57:58]
	v_add_f64 v[33:34], v[33:34], -v[57:58]
	v_add_f64 v[79:80], v[47:48], -v[61:62]
	v_add_f64 v[37:38], v[37:38], -v[61:62]
	v_add_f64 v[81:82], v[49:50], -v[65:66]
	v_add_f64 v[41:42], v[41:42], -v[65:66]
	v_add_f64 v[25:26], v[25:26], -v[75:76]
	v_add_f64 v[31:32], v[31:32], -v[77:78]
	v_add_f64 v[35:36], v[35:36], -v[79:80]
	v_add_f64 v[39:40], v[39:40], -v[81:82]
	s_delay_alu instid0(VALU_DEP_4)
	v_add_f64 v[25:26], v[27:28], v[25:26]
	v_add_f64 v[27:28], v[19:20], v[6:7]
	v_add_f64 v[31:32], v[33:34], v[31:32]
	v_add_f64 v[33:34], v[21:22], v[15:16]
	v_add_f64 v[35:36], v[37:38], v[35:36]
	v_add_f64 v[37:38], v[23:24], v[17:18]
	v_add_f64 v[39:40], v[41:42], v[39:40]
	v_add_f64 v[41:42], v[51:52], -v[29:30]
	v_add_f64 v[25:26], v[51:52], v[25:26]
	v_add_f64 v[53:54], v[27:28], -v[19:20]
	v_add_f64 v[31:32], v[27:28], v[31:32]
	v_add_f64 v[55:56], v[33:34], -v[21:22]
	v_add_f64 v[35:36], v[33:34], v[35:36]
	v_add_f64 v[57:58], v[37:38], -v[23:24]
	v_add_f64 v[39:40], v[37:38], v[39:40]
	v_add_f64 v[51:52], v[51:52], -v[41:42]
	v_add_f64 v[4:5], v[4:5], -v[41:42]
	v_add_f64 v[59:60], v[43:44], v[25:26]
	v_add_f64 v[27:28], v[27:28], -v[53:54]
	v_add_f64 v[6:7], v[6:7], -v[53:54]
	v_add_f64 v[61:62], v[45:46], v[31:32]
	v_add_f64 v[33:34], v[33:34], -v[55:56]
	v_add_f64 v[15:16], v[15:16], -v[55:56]
	v_add_f64 v[63:64], v[47:48], v[35:36]
	v_add_f64 v[37:38], v[37:38], -v[57:58]
	v_add_f64 v[17:18], v[17:18], -v[57:58]
	v_add_f64 v[65:66], v[49:50], v[39:40]
	v_add_f64 v[29:30], v[29:30], -v[51:52]
	v_add_f64 v[41:42], v[59:60], -v[43:44]
	v_add_f64 v[19:20], v[19:20], -v[27:28]
	v_add_f64 v[27:28], v[61:62], -v[45:46]
	v_add_f64 v[21:22], v[21:22], -v[33:34]
	v_add_f64 v[33:34], v[63:64], -v[47:48]
	v_add_f64 v[23:24], v[23:24], -v[37:38]
	v_add_f64 v[37:38], v[65:66], -v[49:50]
	v_add_f64 v[4:5], v[4:5], v[29:30]
	v_add_f64 v[25:26], v[25:26], -v[41:42]
	v_add_f64 v[6:7], v[6:7], v[19:20]
	v_add_f64 v[19:20], v[31:32], -v[27:28]
	v_add_f64 v[15:16], v[15:16], v[21:22]
	v_add_f64 v[21:22], v[35:36], -v[33:34]
	v_add_f64 v[17:18], v[17:18], v[23:24]
	v_add_f64 v[23:24], v[39:40], -v[37:38]
	v_add_f64 v[4:5], v[4:5], v[25:26]
	v_add_f64 v[6:7], v[6:7], v[19:20]
	v_add_f64 v[15:16], v[15:16], v[21:22]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[17:18], v[17:18], v[23:24]
	v_add_f64 v[19:20], v[59:60], v[4:5]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[21:22], v[61:62], v[6:7]
	v_add_f64 v[23:24], v[63:64], v[15:16]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[25:26], v[65:66], v[17:18]
	v_add_f64 v[27:28], v[19:20], -v[59:60]
	v_add_f64 v[29:30], v[19:20], v[19:20]
	v_add_f64 v[31:32], v[21:22], -v[61:62]
	v_add_f64 v[33:34], v[21:22], v[21:22]
	v_add_f64 v[35:36], v[23:24], -v[63:64]
	v_add_f64 v[37:38], v[23:24], v[23:24]
	v_add_f64 v[39:40], v[25:26], -v[65:66]
	v_add_f64 v[41:42], v[25:26], v[25:26]
	v_add_f64 v[4:5], v[4:5], -v[27:28]
	v_fma_f64 v[19:20], v[19:20], 2.0, -v[29:30]
	v_cmp_class_f64_e64 vcc_lo, v[29:30], 0x204
	v_add_f64 v[6:7], v[6:7], -v[31:32]
	v_fma_f64 v[21:22], v[21:22], 2.0, -v[33:34]
	v_cmp_class_f64_e64 s0, v[33:34], 0x204
	v_add_f64 v[15:16], v[15:16], -v[35:36]
	v_fma_f64 v[23:24], v[23:24], 2.0, -v[37:38]
	v_cmp_class_f64_e64 s1, v[37:38], 0x204
	v_add_f64 v[17:18], v[17:18], -v[39:40]
	v_fma_f64 v[25:26], v[25:26], 2.0, -v[41:42]
	v_cmp_class_f64_e64 s2, v[41:42], 0x204
	v_fma_f64 v[4:5], v[4:5], 2.0, v[19:20]
	v_fma_f64 v[6:7], v[6:7], 2.0, v[21:22]
	v_fma_f64 v[15:16], v[15:16], 2.0, v[23:24]
	v_fma_f64 v[17:18], v[17:18], 2.0, v[25:26]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[19:20], v[29:30], v[4:5]
	v_add_f64 v[21:22], v[33:34], v[6:7]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[23:24], v[37:38], v[15:16]
	v_add_f64 v[25:26], v[41:42], v[17:18]
	s_delay_alu instid0(VALU_DEP_4)
	v_dual_cndmask_b32 v28, v20, v30 :: v_dual_cndmask_b32 v27, v19, v29
	v_add_f64 v[19:20], v[19:20], -v[29:30]
	v_cndmask_b32_e64 v32, v22, v34, s0
	v_cndmask_b32_e64 v31, v21, v33, s0
	v_add_f64 v[21:22], v[21:22], -v[33:34]
	v_cndmask_b32_e64 v36, v24, v38, s1
	v_cndmask_b32_e64 v35, v23, v37, s1
	v_mul_f64 v[39:40], v[27:28], s[8:9]
	v_mul_f64 v[45:46], v[31:32], s[8:9]
	v_cndmask_b32_e64 v44, v26, v42, s2
	v_cndmask_b32_e64 v43, v25, v41, s2
	v_mul_f64 v[47:48], v[35:36], s[8:9]
	s_mov_b32 s0, 0xfca7ab0c
	s_mov_b32 s2, 0x6a5dcb37
	s_mov_b32 s1, 0x3e928af3
	v_mul_f64 v[49:50], v[43:44], s[8:9]
	s_mov_b32 s3, 0x3e5ade15
	v_add_f64 v[23:24], v[23:24], -v[37:38]
	v_cmp_neq_f64_e64 vcc_lo, 0x7ff00000, |v[27:28]|
	v_cmp_ngt_f64_e64 s8, 0xc090cc00, v[35:36]
	v_cmp_nlt_f64_e64 s9, 0x40900000, v[43:44]
	v_cmp_ngt_f64_e64 s10, 0xc090cc00, v[43:44]
	v_add_f64 v[25:26], v[25:26], -v[41:42]
	v_add_f64 v[19:20], v[4:5], -v[19:20]
	flat_load_b32 v4, v[10:11]
	v_add_f64 v[5:6], v[6:7], -v[21:22]
	v_rndne_f64_e32 v[39:40], v[39:40]
	v_rndne_f64_e32 v[45:46], v[45:46]
	v_rndne_f64_e32 v[47:48], v[47:48]
	v_rndne_f64_e32 v[49:50], v[49:50]
	v_add_f64 v[15:16], v[15:16], -v[23:24]
	v_add_f64 v[17:18], v[17:18], -v[25:26]
	v_dual_cndmask_b32 v11, 0, v20 :: v_dual_cndmask_b32 v10, 0, v19
	v_fma_f64 v[51:52], v[39:40], s[4:5], v[27:28]
	v_fma_f64 v[53:54], v[45:46], s[4:5], v[31:32]
	v_cvt_i32_f64_e32 v67, v[39:40]
	v_fma_f64 v[55:56], v[47:48], s[4:5], v[35:36]
	v_fma_f64 v[57:58], v[49:50], s[4:5], v[43:44]
	v_cmp_nlt_f64_e64 s5, 0x40900000, v[31:32]
	v_cmp_ngt_f64_e64 s4, 0xc090cc00, v[27:28]
	v_fma_f64 v[51:52], v[39:40], s[6:7], v[51:52]
	v_fma_f64 v[53:54], v[45:46], s[6:7], v[53:54]
	v_fma_f64 v[55:56], v[47:48], s[6:7], v[55:56]
	v_fma_f64 v[57:58], v[49:50], s[6:7], v[57:58]
	v_cmp_nlt_f64_e64 s7, 0x40900000, v[35:36]
	v_cmp_ngt_f64_e64 s6, 0xc090cc00, v[31:32]
	v_fma_f64 v[59:60], v[51:52], s[2:3], s[0:1]
	v_fma_f64 v[61:62], v[53:54], s[2:3], s[0:1]
	v_fma_f64 v[63:64], v[55:56], s[2:3], s[0:1]
	v_fma_f64 v[65:66], v[57:58], s[2:3], s[0:1]
	s_mov_b32 s0, 0x623fde64
	s_mov_b32 s1, 0x3ec71dee
	v_cmp_nlt_f64_e64 s3, 0x40900000, v[27:28]
	v_cmp_neq_f64_e64 s2, 0x7ff00000, |v[43:44]|
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	s_mov_b32 s0, 0x7c89e6b0
	s_mov_b32 s1, 0x3efa0199
	s_and_b32 vcc_lo, s4, s3
	v_cndmask_b32_e64 v18, 0, v18, s2
	v_cndmask_b32_e64 v17, 0, v17, s2
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	s_mov_b32 s0, 0x14761f6e
	s_mov_b32 s1, 0x3f2a01a0
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	s_mov_b32 s0, 0x1852b7b0
	s_mov_b32 s1, 0x3f56c16c
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	s_mov_b32 s0, 0x11122322
	s_mov_b32 s1, 0x3f811111
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	s_mov_b32 s0, 0x555502a1
	s_mov_b32 s1, 0x3fa55555
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	s_mov_b32 s0, 0x55555511
	s_mov_b32 s1, 0x3fc55555
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	s_mov_b32 s0, 11
	s_mov_b32 s1, 0x3fe00000
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[59:60], v[51:52], v[59:60], s[0:1]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[61:62], v[53:54], v[61:62], s[0:1]
	v_fma_f64 v[63:64], v[55:56], v[63:64], s[0:1]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[65:66], v[57:58], v[65:66], s[0:1]
	v_cmp_neq_f64_e64 s0, 0x7ff00000, |v[31:32]|
	v_cmp_neq_f64_e64 s1, 0x7ff00000, |v[35:36]|
	v_fma_f64 v[59:60], v[51:52], v[59:60], 1.0
	v_fma_f64 v[61:62], v[53:54], v[61:62], 1.0
	v_fma_f64 v[63:64], v[55:56], v[63:64], 1.0
	v_fma_f64 v[65:66], v[57:58], v[65:66], 1.0
	v_cndmask_b32_e64 v6, 0, v6, s0
	v_cndmask_b32_e64 v5, 0, v5, s0
	v_cndmask_b32_e64 v16, 0, v16, s1
	v_cndmask_b32_e64 v15, 0, v15, s1
	v_fma_f64 v[39:40], v[51:52], v[59:60], 1.0
	v_cvt_i32_f64_e32 v51, v[45:46]
	v_fma_f64 v[45:46], v[53:54], v[61:62], 1.0
	v_cvt_i32_f64_e32 v52, v[47:48]
	v_fma_f64 v[47:48], v[55:56], v[63:64], 1.0
	v_cvt_i32_f64_e32 v53, v[49:50]
	v_fma_f64 v[49:50], v[57:58], v[65:66], 1.0
	v_ldexp_f64 v[29:30], v[39:40], v67
	v_ldexp_f64 v[33:34], v[45:46], v51
	v_ldexp_f64 v[37:38], v[47:48], v52
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_ldexp_f64 v[39:40], v[49:50], v53
	v_cndmask_b32_e32 v19, 0, v29, vcc_lo
	s_and_b32 vcc_lo, s6, s5
	s_delay_alu instid0(VALU_DEP_4)
	v_cndmask_b32_e64 v21, 0x7ff00000, v34, s5
	v_cndmask_b32_e64 v7, 0x7ff00000, v30, s3
	v_cndmask_b32_e64 v23, 0x7ff00000, v38, s7
	v_cmp_neq_f64_e64 s3, 0x7ff00000, |v[8:9]|
	v_cmp_neq_f64_e64 s5, 0x7ff00000, |v[13:14]|
	v_cndmask_b32_e64 v22, 0, v21, s6
	v_cndmask_b32_e32 v21, 0, v33, vcc_lo
	s_and_b32 vcc_lo, s8, s7
	v_cndmask_b32_e64 v24, 0, v23, s8
	v_cndmask_b32_e32 v23, 0, v37, vcc_lo
	s_and_b32 vcc_lo, s10, s9
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, r@rel32@lo+4
	s_addc_u32 s1, s1, r@rel32@hi+12
	v_fma_f64 v[5:6], v[21:22], v[5:6], v[21:22]
	s_load_b64 s[12:13], s[0:1], 0x0
	v_cmp_class_f64_e64 s0, v[21:22], 0x204
	v_cndmask_b32_e64 v25, 0x7ff00000, v40, s9
	v_cndmask_b32_e64 v20, 0, v7, s4
	v_cmp_neq_f64_e64 s4, 0, v[8:9]
	v_cmp_neq_f64_e64 s6, 0, v[13:14]
	v_cmp_neq_f64_e64 s7, 0x7ff00000, |v[0:1]|
	v_cndmask_b32_e64 v26, 0, v25, s10
	v_cndmask_b32_e32 v25, 0, v39, vcc_lo
	v_cmp_neq_f64_e64 s9, 0x7ff00000, |v[2:3]|
	v_cmp_neq_f64_e64 s8, 0, v[0:1]
	v_cmp_neq_f64_e64 s10, 0, v[2:3]
	v_mul_f64 v[2:3], v[13:14], v[2:3]
	v_fma_f64 v[17:18], v[25:26], v[17:18], v[25:26]
	v_cmp_class_f64_e64 s2, v[25:26], 0x204
	s_waitcnt lgkmcnt(0)
	s_load_b32 s11, s[12:13], 0x0
	v_cndmask_b32_e64 v6, v6, v22, s0
	s_waitcnt lgkmcnt(0)
	s_mul_i32 s11, s11, s11
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_4) | instid1(VALU_DEP_4)
	v_and_b32_e32 v6, 0x7fffffff, v6
	v_fma_f64 v[10:11], v[19:20], v[10:11], v[19:20]
	v_cmp_class_f64_e64 vcc_lo, v[19:20], 0x204
	v_fma_f64 v[0:1], v[8:9], v[0:1], v[2:3]
	v_cndmask_b32_e64 v17, v17, v25, s2
	v_cndmask_b32_e32 v10, v10, v19, vcc_lo
	v_fma_f64 v[15:16], v[23:24], v[15:16], v[23:24]
	v_cmp_class_f64_e64 s1, v[23:24], 0x204
	v_cndmask_b32_e32 v7, v11, v20, vcc_lo
	s_and_b32 vcc_lo, s4, s3
	v_add_f64 v[2:3], v[0:1], v[0:1]
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_3) | instid1(VALU_DEP_4)
	v_cndmask_b32_e64 v11, v16, v24, s1
	v_cndmask_b32_e64 v16, v18, v26, s2
	v_cndmask_b32_e64 v15, v15, v23, s1
	v_cndmask_b32_e64 v18, 0x7ff00000, v6, s5
	v_and_b32_e32 v11, 0x7fffffff, v11
	s_delay_alu instid0(VALU_DEP_4)
	v_and_b32_e32 v16, 0x7fffffff, v16
	v_cndmask_b32_e64 v19, v5, v21, s0
	v_cndmask_b32_e32 v5, 0, v10, vcc_lo
	s_and_b32 vcc_lo, s6, s5
	v_cndmask_b32_e64 v20, 0x7ff00000, v11, s7
	v_cndmask_b32_e64 v22, 0x7ff00000, v16, s9
	v_cndmask_b32_e32 v10, 0, v19, vcc_lo
	v_and_b32_e32 v7, 0x7fffffff, v7
	s_and_b32 vcc_lo, s8, s7
	v_cndmask_b32_e64 v11, 0, v18, s6
	v_cndmask_b32_e32 v15, 0, v15, vcc_lo
	s_and_b32 vcc_lo, s10, s9
	v_cndmask_b32_e64 v7, 0x7ff00000, v7, s3
	v_cndmask_b32_e64 v16, 0, v20, s8
	v_cndmask_b32_e64 v18, 0, v22, s10
	v_cndmask_b32_e32 v17, 0, v17, vcc_lo
	s_lshl_b32 s0, s11, 2
	v_cndmask_b32_e64 v6, 0, v7, s4
	v_cvt_f64_i32_e32 v[19:20], s0
	s_mov_b32 s0, exec_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_add_f64 v[10:11], v[5:6], v[10:11]
	v_add_f64 v[5:6], v[15:16], v[17:18]
	v_add_f64 v[7:8], v[10:11], -v[19:20]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mul_f64 v[9:10], v[5:6], -4.0
	v_mul_f64 v[0:1], v[7:8], v[9:10]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_3)
	v_fma_f64 v[7:8], v[2:3], v[2:3], v[0:1]
	v_mov_b32_e32 v0, 0
	v_mov_b32_e32 v1, 0x40f86a00
	v_cmpx_ngt_f64_e32 0, v[7:8]
	s_cbranch_execz .LBB1_5
; %bb.2:
	v_cmp_gt_f64_e32 vcc_lo, 0x10000000, v[7:8]
	v_add_f64 v[5:6], v[5:6], v[5:6]
	s_mov_b32 s1, exec_lo
	v_cndmask_b32_e64 v0, 0, 1, vcc_lo
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_lshlrev_b32_e32 v0, 8, v0
	v_ldexp_f64 v[0:1], v[7:8], v0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_3) | instid1(VALU_DEP_1)
	v_rsq_f64_e32 v[7:8], v[0:1]
	s_waitcnt_depctr 0xfff
	v_mul_f64 v[9:10], v[0:1], v[7:8]
	v_mul_f64 v[7:8], v[7:8], 0.5
	v_fma_f64 v[13:14], -v[7:8], v[9:10], 0.5
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_fma_f64 v[9:10], v[9:10], v[13:14], v[9:10]
	v_fma_f64 v[7:8], v[7:8], v[13:14], v[7:8]
	v_fma_f64 v[13:14], -v[9:10], v[9:10], v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[9:10], v[13:14], v[7:8], v[9:10]
	v_fma_f64 v[13:14], -v[9:10], v[9:10], v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_2)
	v_fma_f64 v[7:8], v[13:14], v[7:8], v[9:10]
	v_cndmask_b32_e64 v9, 0, 0xffffff80, vcc_lo
	v_cmp_class_f64_e64 vcc_lo, v[0:1], 0x260
	v_ldexp_f64 v[7:8], v[7:8], v9
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_dual_cndmask_b32 v8, v8, v1 :: v_dual_cndmask_b32 v7, v7, v0
	v_add_f64 v[0:1], -v[7:8], -v[2:3]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[9:10], null, v[5:6], v[5:6], v[0:1]
	v_rcp_f64_e32 v[13:14], v[9:10]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[15:16], -v[9:10], v[13:14], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[13:14], v[13:14], v[15:16], v[13:14]
	v_fma_f64 v[15:16], -v[9:10], v[13:14], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[13:14], v[13:14], v[15:16], v[13:14]
	v_div_scale_f64 v[15:16], vcc_lo, v[0:1], v[5:6], v[0:1]
	v_mul_f64 v[17:18], v[15:16], v[13:14]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[9:10], -v[9:10], v[17:18], v[15:16]
	v_div_fmas_f64 v[9:10], v[9:10], v[13:14], v[17:18]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_fixup_f64 v[0:1], v[9:10], v[5:6], v[0:1]
	v_cmpx_gt_f64_e32 0, v[0:1]
	s_cbranch_execz .LBB1_4
; %bb.3:
	v_add_f64 v[0:1], v[7:8], -v[2:3]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_div_scale_f64 v[2:3], null, v[5:6], v[5:6], v[0:1]
	v_div_scale_f64 v[13:14], vcc_lo, v[0:1], v[5:6], v[0:1]
	v_rcp_f64_e32 v[7:8], v[2:3]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[9:10], -v[2:3], v[7:8], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[7:8], v[7:8], v[9:10], v[7:8]
	v_fma_f64 v[9:10], -v[2:3], v[7:8], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[7:8], v[7:8], v[9:10], v[7:8]
	v_mul_f64 v[9:10], v[13:14], v[7:8]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[2:3], -v[2:3], v[9:10], v[13:14]
	v_div_fmas_f64 v[2:3], v[2:3], v[7:8], v[9:10]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_div_fixup_f64 v[1:2], v[2:3], v[5:6], v[0:1]
	v_mov_b32_e32 v0, 0
	v_cmp_lt_f64_e32 vcc_lo, 0, v[1:2]
	v_cndmask_b32_e64 v1, 0x40f86a00, 0, vcc_lo
.LBB1_4:                                ; %Flow
	s_or_b32 exec_lo, exec_lo, s1
.LBB1_5:
	s_delay_alu instid0(SALU_CYCLE_1)
	s_or_b32 exec_lo, exec_lo, s0
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, particleCollisionTimes@rel32@lo+4
	s_addc_u32 s1, s1, particleCollisionTimes@rel32@hi+12
	s_waitcnt vmcnt(0)
	v_ashrrev_i32_e32 v5, 31, v4
	s_load_b64 s[2:3], s[0:1], 0x0
	v_ashrrev_i32_e32 v13, 31, v12
	v_mov_b32_e32 v8, 0
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_lshlrev_b64 v[2:3], 3, v[4:5]
	v_lshlrev_b64 v[6:7], 3, v[12:13]
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_delay_alu instid0(VALU_DEP_2)
	v_add_co_u32 v4, vcc_lo, s2, v2
	v_add_co_ci_u32_e32 v5, vcc_lo, s3, v3, vcc_lo
	flat_load_b64 v[4:5], v[4:5]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_co_u32 v4, vcc_lo, v4, v6
	v_add_co_ci_u32_e32 v5, vcc_lo, v5, v7, vcc_lo
	flat_store_b64 v[4:5], v[0:1]
	global_load_b64 v[4:5], v8, s[0:1]
	s_waitcnt vmcnt(0)
	v_readfirstlane_b32 s0, v4
	v_readfirstlane_b32 s1, v5
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_co_u32 v4, vcc_lo, s0, v6
	v_add_co_ci_u32_e32 v5, vcc_lo, s1, v7, vcc_lo
	flat_load_b64 v[4:5], v[4:5]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_co_u32 v2, vcc_lo, v4, v2
	v_add_co_ci_u32_e32 v3, vcc_lo, v5, v3, vcc_lo
	flat_store_b64 v[2:3], v[0:1]
.LBB1_6:
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z21timeParticleCollisionv
		.amdhsa_group_segment_fixed_size 0
		.amdhsa_private_segment_fixed_size 0
		.amdhsa_kernarg_size 256
		.amdhsa_user_sgpr_count 14
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 0
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 1
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 1
		.amdhsa_next_free_vgpr 91
		.amdhsa_next_free_sgpr 16
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end1:
	.size	_Z21timeParticleCollisionv, .Lfunc_end1-_Z21timeParticleCollisionv
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 6840
; NumSgprs: 18
; NumVgprs: 91
; ScratchSize: 0
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 0 bytes/workgroup (compile time only)
; SGPRBlocks: 2
; VGPRBlocks: 11
; NumSGPRsForWavesPerEU: 18
; NumVGPRsForWavesPerEU: 91
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 0
; COMPUTE_PGM_RSRC2:USER_SGPR: 14
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 1
	.text
	.protected	_Z17timeWallCollisionv  ; -- Begin function _Z17timeWallCollisionv
	.globl	_Z17timeWallCollisionv
	.p2align	8
	.type	_Z17timeWallCollisionv,@function
_Z17timeWallCollisionv:                 ; @_Z17timeWallCollisionv
; %bb.0:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, n@rel32@lo+4
	s_addc_u32 s3, s3, n@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_load_b32 s0, s[0:1], 0xc
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_and_b32 s0, s0, 0xffff
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[1:2], null, s15, s0, v[0:1]
	s_mov_b32 s0, exec_lo
	s_waitcnt lgkmcnt(0)
	v_cmpx_gt_i32_e64 s1, v1
	s_cbranch_execz .LBB2_10
; %bb.1:
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, particles@rel32@lo+4
	s_addc_u32 s1, s1, particles@rel32@hi+12
                                        ; implicit-def: $vgpr9_vgpr10
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	v_mad_i64_i32 v[4:5], null, v1, 48, s[0:1]
	s_mov_b32 s0, exec_lo
                                        ; implicit-def: $sgpr1
	s_clause 0x2
	flat_load_b128 v[0:3], v[4:5] offset:24
	flat_load_b32 v8, v[4:5]
	flat_load_b128 v[4:7], v[4:5] offset:8
	s_waitcnt vmcnt(2) lgkmcnt(2)
	v_cmpx_ngt_f64_e32 0, v[0:1]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB2_3
; %bb.2:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, r@rel32@lo+4
	s_addc_u32 s3, s3, r@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[9:10], s1
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[11:12], s1
	s_waitcnt vmcnt(0)
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[4:5], v[9:10], -v[4:5]
	v_add_f64 v[4:5], v[4:5], -v[11:12]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[9:10], null, v[0:1], v[0:1], v[4:5]
	v_rcp_f64_e32 v[11:12], v[9:10]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[13:14], -v[9:10], v[11:12], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[11:12], v[11:12], v[13:14], v[11:12]
	v_fma_f64 v[13:14], -v[9:10], v[11:12], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[11:12], v[11:12], v[13:14], v[11:12]
	v_div_scale_f64 v[13:14], vcc_lo, v[4:5], v[0:1], v[4:5]
	v_mul_f64 v[15:16], v[13:14], v[11:12]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[9:10], -v[9:10], v[15:16], v[13:14]
	v_div_fmas_f64 v[9:10], v[9:10], v[11:12], v[15:16]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[9:10], v[9:10], v[0:1], v[4:5]
.LBB2_3:                                ; %Flow14
	s_or_saveexec_b32 s0, s0
	v_mov_b32_e32 v11, s1
	s_xor_b32 exec_lo, exec_lo, s0
	s_cbranch_execz .LBB2_5
; %bb.4:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, r@rel32@lo+4
	s_addc_u32 s3, s3, r@rel32@hi+12
	v_add_f64 v[0:1], -v[0:1], 0
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[9:10], s1
	s_waitcnt vmcnt(0)
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[4:5], v[4:5], -v[9:10]
	v_div_scale_f64 v[9:10], null, v[0:1], v[0:1], v[4:5]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_rcp_f64_e32 v[11:12], v[9:10]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[13:14], -v[9:10], v[11:12], 1.0
	v_fma_f64 v[11:12], v[11:12], v[13:14], v[11:12]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[13:14], -v[9:10], v[11:12], 1.0
	v_fma_f64 v[11:12], v[11:12], v[13:14], v[11:12]
	v_div_scale_f64 v[13:14], vcc_lo, v[4:5], v[0:1], v[4:5]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mul_f64 v[15:16], v[13:14], v[11:12]
	v_fma_f64 v[9:10], -v[9:10], v[15:16], v[13:14]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_div_fmas_f64 v[9:10], v[9:10], v[11:12], v[15:16]
	v_mov_b32_e32 v11, s1
	v_div_fixup_f64 v[9:10], v[9:10], v[0:1], v[4:5]
.LBB2_5:
	s_or_b32 exec_lo, exec_lo, s0
	s_waitcnt vmcnt(0) lgkmcnt(0)
	s_delay_alu instid0(VALU_DEP_1)
	v_cvt_f64_i32_e32 v[4:5], v11
	s_mov_b32 s0, exec_lo
                                        ; implicit-def: $vgpr0_vgpr1
	v_cmpx_ngt_f64_e32 0, v[2:3]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB2_7
; %bb.6:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[0:1], s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[0:1], v[0:1], -v[6:7]
	v_add_f64 v[0:1], v[0:1], -v[4:5]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[4:5], null, v[2:3], v[2:3], v[0:1]
	v_rcp_f64_e32 v[6:7], v[4:5]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[11:12], -v[4:5], v[6:7], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[6:7], v[6:7], v[11:12], v[6:7]
	v_fma_f64 v[11:12], -v[4:5], v[6:7], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[6:7], v[6:7], v[11:12], v[6:7]
	v_div_scale_f64 v[11:12], vcc_lo, v[0:1], v[2:3], v[0:1]
	v_mul_f64 v[13:14], v[11:12], v[6:7]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[4:5], -v[4:5], v[13:14], v[11:12]
	v_div_fmas_f64 v[4:5], v[4:5], v[6:7], v[13:14]
                                        ; implicit-def: $vgpr6_vgpr7
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[0:1], v[4:5], v[2:3], v[0:1]
                                        ; implicit-def: $vgpr4_vgpr5
                                        ; implicit-def: $vgpr2_vgpr3
.LBB2_7:                                ; %Flow
	s_and_not1_saveexec_b32 s0, s0
	s_cbranch_execz .LBB2_9
; %bb.8:
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_add_f64 v[0:1], v[6:7], -v[4:5]
	v_add_f64 v[2:3], -v[2:3], 0
	v_div_scale_f64 v[4:5], null, v[2:3], v[2:3], v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_rcp_f64_e32 v[6:7], v[4:5]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[11:12], -v[4:5], v[6:7], 1.0
	v_fma_f64 v[6:7], v[6:7], v[11:12], v[6:7]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[11:12], -v[4:5], v[6:7], 1.0
	v_fma_f64 v[6:7], v[6:7], v[11:12], v[6:7]
	v_div_scale_f64 v[11:12], vcc_lo, v[0:1], v[2:3], v[0:1]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mul_f64 v[13:14], v[11:12], v[6:7]
	v_fma_f64 v[4:5], -v[4:5], v[13:14], v[11:12]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_fmas_f64 v[4:5], v[4:5], v[6:7], v[13:14]
	v_div_fixup_f64 v[0:1], v[4:5], v[2:3], v[0:1]
.LBB2_9:
	s_or_b32 exec_lo, exec_lo, s0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_max_f64 v[0:1], v[0:1], v[0:1]
	v_max_f64 v[2:3], v[9:10], v[9:10]
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, wallCollisionTimes@rel32@lo+4
	s_addc_u32 s1, s1, wallCollisionTimes@rel32@hi+12
	v_ashrrev_i32_e32 v9, 31, v8
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[0:1], s[0:1], 0x0
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_min_f64 v[0:1], v[2:3], v[0:1]
	v_lshlrev_b64 v[2:3], 3, v[8:9]
	s_waitcnt lgkmcnt(0)
	v_add_co_u32 v2, vcc_lo, s0, v2
	s_delay_alu instid0(VALU_DEP_2)
	v_add_co_ci_u32_e32 v3, vcc_lo, s1, v3, vcc_lo
	flat_store_b64 v[2:3], v[0:1]
.LBB2_10:
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z17timeWallCollisionv
		.amdhsa_group_segment_fixed_size 0
		.amdhsa_private_segment_fixed_size 0
		.amdhsa_kernarg_size 256
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 0
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 17
		.amdhsa_next_free_sgpr 16
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end2:
	.size	_Z17timeWallCollisionv, .Lfunc_end2-_Z17timeWallCollisionv
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 1068
; NumSgprs: 18
; NumVgprs: 17
; ScratchSize: 0
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 0 bytes/workgroup (compile time only)
; SGPRBlocks: 2
; VGPRBlocks: 2
; NumSGPRsForWavesPerEU: 18
; NumVGPRsForWavesPerEU: 17
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 0
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.protected	_Z24executeParticleCollisionv ; -- Begin function _Z24executeParticleCollisionv
	.globl	_Z24executeParticleCollisionv
	.p2align	8
	.type	_Z24executeParticleCollisionv,@function
_Z24executeParticleCollisionv:          ; @_Z24executeParticleCollisionv
; %bb.0:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, particleCollisionsCount@rel32@lo+4
	s_addc_u32 s3, s3, particleCollisionsCount@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_load_b32 s0, s[0:1], 0xc
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_and_b32 s0, s0, 0xffff
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[1:2], null, s15, s0, v[0:1]
	s_mov_b32 s0, exec_lo
	s_waitcnt lgkmcnt(0)
	v_cmpx_gt_i32_e64 s1, v1
	s_cbranch_execz .LBB3_27
; %bb.1:
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, particleCollisions@rel32@lo+4
	s_addc_u32 s1, s1, particleCollisions@rel32@hi+12
	v_ashrrev_i32_e32 v2, 31, v1
	s_load_b64 s[0:1], s[0:1], 0x0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_3) | instid1(VALU_DEP_1)
	v_lshlrev_b64 v[0:1], 3, v[1:2]
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	v_add_co_u32 v0, vcc_lo, s0, v0
	s_delay_alu instid0(VALU_DEP_2)
	v_add_co_ci_u32_e32 v1, vcc_lo, s1, v1, vcc_lo
	flat_load_b64 v[4:5], v[0:1]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	flat_load_b128 v[0:3], v[4:5] offset:8
	s_waitcnt vmcnt(0) lgkmcnt(0)
	flat_load_b32 v6, v[0:1]
	flat_load_b32 v7, v[2:3]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmp_lt_i32_e32 vcc_lo, v6, v7
	s_and_b32 exec_lo, exec_lo, vcc_lo
	s_cbranch_execz .LBB3_27
; %bb.2:
	flat_load_b64 v[16:17], v[4:5] offset:24
	s_clause 0x1
	flat_load_b128 v[8:11], v[0:1] offset:24
	flat_load_b128 v[4:7], v[0:1] offset:8
	s_mov_b32 s2, 0x55555555
	s_mov_b32 s3, 0x3fe55555
	s_mov_b32 s4, 0x968915a9
	s_mov_b32 s6, 0x4222de17
	s_mov_b32 s5, 0x3fba6564
	s_mov_b32 s7, 0x3fbdee67
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_fma_f64 v[4:5], v[16:17], v[8:9], v[4:5]
	v_fma_f64 v[6:7], v[16:17], v[10:11], v[6:7]
	flat_store_b128 v[0:1], v[4:7] offset:8
	s_clause 0x1
	flat_load_b128 v[12:15], v[2:3] offset:24
	flat_load_b128 v[4:7], v[2:3] offset:8
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_fma_f64 v[18:19], v[16:17], v[12:13], v[4:5]
	v_fma_f64 v[20:21], v[16:17], v[14:15], v[6:7]
	flat_store_b128 v[2:3], v[18:21] offset:8
	flat_load_b128 v[4:7], v[0:1] offset:8
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_f64 v[18:19], v[4:5], -v[18:19]
	v_add_f64 v[20:21], v[6:7], -v[20:21]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_frexp_mant_f64_e64 v[22:23], |v[18:19]|
	v_frexp_mant_f64_e64 v[24:25], |v[20:21]|
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_cmp_gt_f64_e32 vcc_lo, s[2:3], v[22:23]
	v_cmp_gt_f64_e64 s0, s[2:3], v[24:25]
	v_cndmask_b32_e64 v26, 0, 1, vcc_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_cndmask_b32_e64 v27, 0, 1, s0
	v_ldexp_f64 v[22:23], v[22:23], v26
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_ldexp_f64 v[24:25], v[24:25], v27
	v_add_f64 v[26:27], v[22:23], 1.0
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_add_f64 v[28:29], v[24:25], 1.0
	v_add_f64 v[38:39], v[22:23], -1.0
	v_rcp_f64_e32 v[30:31], v[26:27]
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_2) | instid1(VALU_DEP_2)
	v_rcp_f64_e32 v[32:33], v[28:29]
	v_add_f64 v[42:43], v[26:27], -1.0
	v_add_f64 v[46:47], v[28:29], -1.0
	v_add_f64 v[22:23], v[22:23], -v[42:43]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[34:35], -v[26:27], v[30:31], 1.0
	v_fma_f64 v[36:37], -v[28:29], v[32:33], 1.0
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[30:31], v[34:35], v[30:31], v[30:31]
	v_fma_f64 v[32:33], v[36:37], v[32:33], v[32:33]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[34:35], -v[26:27], v[30:31], 1.0
	v_fma_f64 v[36:37], -v[28:29], v[32:33], 1.0
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_fma_f64 v[30:31], v[34:35], v[30:31], v[30:31]
	v_add_f64 v[34:35], v[24:25], -1.0
	v_fma_f64 v[32:33], v[36:37], v[32:33], v[32:33]
	v_add_f64 v[24:25], v[24:25], -v[46:47]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_mul_f64 v[36:37], v[38:39], v[30:31]
	v_mul_f64 v[40:41], v[34:35], v[32:33]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_mul_f64 v[44:45], v[26:27], v[36:37]
	v_mul_f64 v[48:49], v[28:29], v[40:41]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[26:27], v[36:37], v[26:27], -v[44:45]
	v_fma_f64 v[28:29], v[40:41], v[28:29], -v[48:49]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[22:23], v[36:37], v[22:23], v[26:27]
	v_fma_f64 v[24:25], v[40:41], v[24:25], v[28:29]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[26:27], v[44:45], v[22:23]
	v_add_f64 v[28:29], v[48:49], v[24:25]
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_add_f64 v[42:43], v[38:39], -v[26:27]
	v_add_f64 v[44:45], v[26:27], -v[44:45]
	v_add_f64 v[46:47], v[34:35], -v[28:29]
	v_add_f64 v[48:49], v[28:29], -v[48:49]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[38:39], v[38:39], -v[42:43]
	v_add_f64 v[22:23], v[44:45], -v[22:23]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[34:35], v[34:35], -v[46:47]
	v_add_f64 v[24:25], v[48:49], -v[24:25]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_f64 v[26:27], v[38:39], -v[26:27]
	v_add_f64 v[28:29], v[34:35], -v[28:29]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[22:23], v[22:23], v[26:27]
	v_add_f64 v[24:25], v[24:25], v[28:29]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[22:23], v[42:43], v[22:23]
	v_add_f64 v[24:25], v[46:47], v[24:25]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_mul_f64 v[22:23], v[30:31], v[22:23]
	v_mul_f64 v[24:25], v[32:33], v[24:25]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[26:27], v[36:37], v[22:23]
	v_add_f64 v[28:29], v[40:41], v[24:25]
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_add_f64 v[30:31], v[26:27], -v[36:37]
	v_mul_f64 v[34:35], v[26:27], v[26:27]
	v_add_f64 v[32:33], v[28:29], -v[40:41]
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_add_f64 v[22:23], v[22:23], -v[30:31]
	v_mul_f64 v[30:31], v[28:29], v[28:29]
	v_add_f64 v[24:25], v[24:25], -v[32:33]
	v_fma_f64 v[32:33], v[26:27], v[26:27], -v[34:35]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[36:37], v[22:23], v[22:23]
	v_fma_f64 v[38:39], v[28:29], v[28:29], -v[30:31]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_f64 v[40:41], v[24:25], v[24:25]
	v_fma_f64 v[32:33], v[26:27], v[36:37], v[32:33]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[36:37], v[28:29], v[40:41], v[38:39]
	v_add_f64 v[38:39], v[34:35], v[32:33]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[40:41], v[30:31], v[36:37]
	v_fma_f64 v[42:43], v[38:39], s[6:7], s[4:5]
	v_add_f64 v[34:35], v[38:39], -v[34:35]
	s_delay_alu instid0(VALU_DEP_3)
	v_fma_f64 v[44:45], v[40:41], s[6:7], s[4:5]
	s_mov_b32 s4, 0x3abe935a
	s_mov_b32 s5, 0x3fbe25e4
	v_add_f64 v[30:31], v[40:41], -v[30:31]
	v_mul_f64 v[52:53], v[26:27], v[38:39]
	v_mul_f64 v[56:57], v[28:29], v[40:41]
	s_mov_b32 s6, 0x652b82fe
	s_mov_b32 s7, 0x3ff71547
	v_fma_f64 v[42:43], v[38:39], v[42:43], s[4:5]
	v_add_f64 v[32:33], v[32:33], -v[34:35]
	v_fma_f64 v[44:45], v[40:41], v[44:45], s[4:5]
	s_mov_b32 s4, 0x47e6c9c2
	s_mov_b32 s5, 0x3fc110ef
	v_add_f64 v[30:31], v[36:37], -v[30:31]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_fma_f64 v[42:43], v[38:39], v[42:43], s[4:5]
	v_fma_f64 v[44:45], v[40:41], v[44:45], s[4:5]
	s_mov_b32 s4, 0xcfa74449
	s_mov_b32 s5, 0x3fc3b13b
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[42:43], v[38:39], v[42:43], s[4:5]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[44:45], v[40:41], v[44:45], s[4:5]
	s_mov_b32 s4, 0x71bf3c30
	s_mov_b32 s5, 0x3fc745d1
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[42:43], v[38:39], v[42:43], s[4:5]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[44:45], v[40:41], v[44:45], s[4:5]
	s_mov_b32 s4, 0x1c7792ce
	s_mov_b32 s5, 0x3fcc71c7
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[42:43], v[38:39], v[42:43], s[4:5]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[44:45], v[40:41], v[44:45], s[4:5]
	s_mov_b32 s4, 0x924920da
	s_mov_b32 s5, 0x3fd24924
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[42:43], v[38:39], v[42:43], s[4:5]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[44:45], v[40:41], v[44:45], s[4:5]
	s_mov_b32 s4, 0x9999999c
	s_mov_b32 s5, 0x3fd99999
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[42:43], v[38:39], v[42:43], s[4:5]
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_2) | instid1(VALU_DEP_2)
	v_fma_f64 v[44:45], v[40:41], v[44:45], s[4:5]
	s_mov_b32 s4, 0x3b39803f
	s_mov_b32 s5, 0x3c7abc9e
	v_mul_f64 v[46:47], v[38:39], v[42:43]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_mul_f64 v[48:49], v[40:41], v[44:45]
	v_fma_f64 v[34:35], v[38:39], v[42:43], -v[46:47]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[36:37], v[40:41], v[44:45], -v[48:49]
	v_fma_f64 v[34:35], v[32:33], v[42:43], v[34:35]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[36:37], v[30:31], v[44:45], v[36:37]
	v_add_f64 v[42:43], v[46:47], v[34:35]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[44:45], v[48:49], v[36:37]
	v_add_f64 v[50:51], v[42:43], s[2:3]
	v_add_f64 v[46:47], v[42:43], -v[46:47]
	s_delay_alu instid0(VALU_DEP_3)
	v_add_f64 v[54:55], v[44:45], s[2:3]
	v_add_f64 v[48:49], v[44:45], -v[48:49]
	s_mov_b32 s3, 0xbfe55555
	s_delay_alu instid0(VALU_DEP_4) | instid1(SALU_CYCLE_1)
	v_add_f64 v[58:59], v[50:51], s[2:3]
	s_delay_alu instid0(VALU_DEP_4)
	v_add_f64 v[34:35], v[34:35], -v[46:47]
	v_fma_f64 v[46:47], v[38:39], v[26:27], -v[52:53]
	v_add_f64 v[60:61], v[54:55], s[2:3]
	v_add_f64 v[36:37], v[36:37], -v[48:49]
	v_fma_f64 v[48:49], v[40:41], v[28:29], -v[56:57]
	s_mov_b32 s2, 0xd5df274d
	s_mov_b32 s3, 0x3c8543b0
	v_add_f64 v[42:43], v[42:43], -v[58:59]
	v_add_f64 v[34:35], v[34:35], s[2:3]
	v_fma_f64 v[38:39], v[38:39], v[22:23], v[46:47]
	v_add_f64 v[44:45], v[44:45], -v[60:61]
	v_add_f64 v[36:37], v[36:37], s[2:3]
	v_fma_f64 v[40:41], v[40:41], v[24:25], v[48:49]
	s_mov_b32 s2, 0xfefa39ef
	s_mov_b32 s3, 0x3fe62e42
	v_ldexp_f64 v[22:23], v[22:23], 1
	v_ldexp_f64 v[24:25], v[24:25], 1
	v_add_f64 v[34:35], v[34:35], v[42:43]
	v_fma_f64 v[32:33], v[32:33], v[26:27], v[38:39]
	v_ldexp_f64 v[26:27], v[26:27], 1
	v_add_f64 v[36:37], v[36:37], v[44:45]
	v_fma_f64 v[30:31], v[30:31], v[28:29], v[40:41]
	v_ldexp_f64 v[28:29], v[28:29], 1
	v_add_f64 v[38:39], v[50:51], v[34:35]
	v_add_f64 v[40:41], v[52:53], v[32:33]
	v_add_f64 v[42:43], v[54:55], v[36:37]
	v_add_f64 v[44:45], v[56:57], v[30:31]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[46:47], v[50:51], -v[38:39]
	v_mul_f64 v[48:49], v[40:41], v[38:39]
	v_add_f64 v[52:53], v[40:41], -v[52:53]
	v_add_f64 v[50:51], v[54:55], -v[42:43]
	v_mul_f64 v[54:55], v[44:45], v[42:43]
	v_add_f64 v[56:57], v[44:45], -v[56:57]
	v_add_f64 v[34:35], v[34:35], v[46:47]
	v_fma_f64 v[46:47], v[40:41], v[38:39], -v[48:49]
	v_add_f64 v[32:33], v[32:33], -v[52:53]
	v_add_f64 v[36:37], v[36:37], v[50:51]
	v_fma_f64 v[50:51], v[44:45], v[42:43], -v[54:55]
	v_add_f64 v[30:31], v[30:31], -v[56:57]
	v_fma_f64 v[34:35], v[40:41], v[34:35], v[46:47]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[36:37], v[44:45], v[36:37], v[50:51]
	v_fma_f64 v[32:33], v[32:33], v[38:39], v[34:35]
	v_frexp_exp_i32_f64_e32 v38, v[18:19]
	v_frexp_exp_i32_f64_e32 v39, v[20:21]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[30:31], v[30:31], v[42:43], v[36:37]
	v_add_f64 v[34:35], v[48:49], v[32:33]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_subrev_co_ci_u32_e32 v38, vcc_lo, 0, v38, vcc_lo
	v_add_f64 v[36:37], v[54:55], v[30:31]
	v_subrev_co_ci_u32_e64 v44, vcc_lo, 0, v39, s0
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_cvt_f64_i32_e32 v[38:39], v38
	v_cvt_f64_i32_e32 v[44:45], v44
	v_add_f64 v[40:41], v[26:27], v[34:35]
	v_add_f64 v[42:43], v[34:35], -v[48:49]
	v_add_f64 v[46:47], v[28:29], v[36:37]
	v_add_f64 v[48:49], v[36:37], -v[54:55]
	v_mul_f64 v[50:51], v[38:39], s[2:3]
	v_add_f64 v[26:27], v[40:41], -v[26:27]
	v_add_f64 v[32:33], v[32:33], -v[42:43]
	v_mul_f64 v[42:43], v[44:45], s[2:3]
	v_add_f64 v[28:29], v[46:47], -v[28:29]
	v_add_f64 v[30:31], v[30:31], -v[48:49]
	v_fma_f64 v[48:49], v[38:39], s[2:3], -v[50:51]
	v_add_f64 v[26:27], v[34:35], -v[26:27]
	v_add_f64 v[22:23], v[22:23], v[32:33]
	v_fma_f64 v[32:33], v[44:45], s[2:3], -v[42:43]
	v_add_f64 v[28:29], v[36:37], -v[28:29]
	v_add_f64 v[24:25], v[24:25], v[30:31]
	s_mov_b32 s3, 0xbfe62e42
	v_fma_f64 v[30:31], v[38:39], s[4:5], v[48:49]
	v_add_f64 v[22:23], v[22:23], v[26:27]
	v_fma_f64 v[26:27], v[44:45], s[4:5], v[32:33]
	s_mov_b32 s5, 0xbc7abc9e
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[24:25], v[24:25], v[28:29]
	v_add_f64 v[28:29], v[50:51], v[30:31]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[32:33], v[40:41], v[22:23]
	v_add_f64 v[34:35], v[42:43], v[26:27]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[36:37], v[46:47], v[24:25]
	v_add_f64 v[50:51], v[28:29], -v[50:51]
	s_delay_alu instid0(VALU_DEP_4)
	v_add_f64 v[38:39], v[28:29], v[32:33]
	v_add_f64 v[40:41], v[32:33], -v[40:41]
	v_add_f64 v[42:43], v[34:35], -v[42:43]
	v_add_f64 v[44:45], v[34:35], v[36:37]
	v_add_f64 v[46:47], v[36:37], -v[46:47]
	v_add_f64 v[30:31], v[30:31], -v[50:51]
	v_add_f64 v[48:49], v[38:39], -v[28:29]
	v_add_f64 v[22:23], v[22:23], -v[40:41]
	v_add_f64 v[26:27], v[26:27], -v[42:43]
	v_add_f64 v[52:53], v[44:45], -v[34:35]
	v_add_f64 v[24:25], v[24:25], -v[46:47]
	v_add_f64 v[54:55], v[38:39], -v[48:49]
	v_add_f64 v[32:33], v[32:33], -v[48:49]
	v_add_f64 v[40:41], v[30:31], v[22:23]
	v_add_f64 v[56:57], v[44:45], -v[52:53]
	v_add_f64 v[36:37], v[36:37], -v[52:53]
	v_add_f64 v[28:29], v[28:29], -v[54:55]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[34:35], v[34:35], -v[56:57]
	v_add_f64 v[28:29], v[32:33], v[28:29]
	v_add_f64 v[32:33], v[26:27], v[24:25]
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_1) | instid1(VALU_DEP_4)
	v_add_f64 v[34:35], v[36:37], v[34:35]
	v_add_f64 v[36:37], v[40:41], -v[30:31]
	v_add_f64 v[28:29], v[40:41], v[28:29]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[42:43], v[32:33], -v[26:27]
	v_add_f64 v[34:35], v[32:33], v[34:35]
	s_delay_alu instid0(VALU_DEP_4)
	v_add_f64 v[40:41], v[40:41], -v[36:37]
	v_add_f64 v[22:23], v[22:23], -v[36:37]
	v_add_f64 v[46:47], v[38:39], v[28:29]
	v_add_f64 v[32:33], v[32:33], -v[42:43]
	v_add_f64 v[24:25], v[24:25], -v[42:43]
	v_add_f64 v[48:49], v[44:45], v[34:35]
	v_add_f64 v[30:31], v[30:31], -v[40:41]
	v_add_f64 v[36:37], v[46:47], -v[38:39]
	v_add_f64 v[26:27], v[26:27], -v[32:33]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[32:33], v[48:49], -v[44:45]
	v_add_f64 v[22:23], v[22:23], v[30:31]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_add_f64 v[28:29], v[28:29], -v[36:37]
	v_add_f64 v[24:25], v[24:25], v[26:27]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_add_f64 v[26:27], v[34:35], -v[32:33]
	v_add_f64 v[22:23], v[22:23], v[28:29]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[24:25], v[24:25], v[26:27]
	v_add_f64 v[26:27], v[46:47], v[22:23]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[28:29], v[48:49], v[24:25]
	v_add_f64 v[30:31], v[26:27], -v[46:47]
	v_add_f64 v[32:33], v[26:27], v[26:27]
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_1) | instid1(VALU_DEP_4)
	v_add_f64 v[34:35], v[28:29], -v[48:49]
	v_add_f64 v[36:37], v[28:29], v[28:29]
	v_add_f64 v[22:23], v[22:23], -v[30:31]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[26:27], v[26:27], 2.0, -v[32:33]
	v_cmp_class_f64_e64 vcc_lo, v[32:33], 0x204
	v_add_f64 v[24:25], v[24:25], -v[34:35]
	v_fma_f64 v[28:29], v[28:29], 2.0, -v[36:37]
	v_cmp_class_f64_e64 s0, v[36:37], 0x204
	v_fma_f64 v[22:23], v[22:23], 2.0, v[26:27]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[24:25], v[24:25], 2.0, v[28:29]
	v_add_f64 v[26:27], v[32:33], v[22:23]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_add_f64 v[28:29], v[36:37], v[24:25]
	v_dual_cndmask_b32 v31, v27, v33 :: v_dual_cndmask_b32 v30, v26, v32
	v_add_f64 v[26:27], v[26:27], -v[32:33]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_cndmask_b32_e64 v35, v29, v37, s0
	v_cndmask_b32_e64 v34, v28, v36, s0
	s_mov_b32 s0, 0xfca7ab0c
	v_mul_f64 v[38:39], v[30:31], s[6:7]
	s_mov_b32 s1, 0x3e928af3
	v_cmp_neq_f64_e64 vcc_lo, 0x7ff00000, |v[30:31]|
	v_mul_f64 v[40:41], v[34:35], s[6:7]
	v_add_f64 v[28:29], v[28:29], -v[36:37]
	v_add_f64 v[22:23], v[22:23], -v[26:27]
	v_rndne_f64_e32 v[38:39], v[38:39]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_rndne_f64_e32 v[40:41], v[40:41]
	v_add_f64 v[24:25], v[24:25], -v[28:29]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_dual_cndmask_b32 v23, 0, v23 :: v_dual_cndmask_b32 v22, 0, v22
	v_fma_f64 v[42:43], v[38:39], s[2:3], v[30:31]
	v_cvt_i32_f64_e32 v50, v[38:39]
	v_fma_f64 v[44:45], v[40:41], s[2:3], v[34:35]
	s_mov_b32 s2, 0x6a5dcb37
	s_mov_b32 s3, 0x3e5ade15
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[42:43], v[38:39], s[4:5], v[42:43]
	v_fma_f64 v[44:45], v[40:41], s[4:5], v[44:45]
	v_cmp_ngt_f64_e64 s4, 0xc090cc00, v[34:35]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_fma_f64 v[46:47], v[42:43], s[2:3], s[0:1]
	v_fma_f64 v[48:49], v[44:45], s[2:3], s[0:1]
	s_mov_b32 s0, 0x623fde64
	s_mov_b32 s1, 0x3ec71dee
	v_cmp_ngt_f64_e64 s2, 0xc090cc00, v[30:31]
	v_cmp_nlt_f64_e64 s3, 0x40900000, v[34:35]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	s_mov_b32 s0, 0x7c89e6b0
	s_mov_b32 s1, 0x3efa0199
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	s_mov_b32 s0, 0x14761f6e
	s_mov_b32 s1, 0x3f2a01a0
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	s_mov_b32 s0, 0x1852b7b0
	s_mov_b32 s1, 0x3f56c16c
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	s_mov_b32 s0, 0x11122322
	s_mov_b32 s1, 0x3f811111
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	s_mov_b32 s0, 0x555502a1
	s_mov_b32 s1, 0x3fa55555
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	s_mov_b32 s0, 0x55555511
	s_mov_b32 s1, 0x3fc55555
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	s_mov_b32 s0, 11
	s_mov_b32 s1, 0x3fe00000
	s_delay_alu instid0(VALU_DEP_2) | instid1(SALU_CYCLE_1)
	v_fma_f64 v[46:47], v[42:43], v[46:47], s[0:1]
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_2) | instid1(VALU_DEP_4)
	v_fma_f64 v[48:49], v[44:45], v[48:49], s[0:1]
	v_cmp_nlt_f64_e64 s1, 0x40900000, v[30:31]
	v_cmp_neq_f64_e64 s0, 0x7ff00000, |v[34:35]|
	v_fma_f64 v[46:47], v[42:43], v[46:47], 1.0
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[48:49], v[44:45], v[48:49], 1.0
	s_and_b32 vcc_lo, s2, s1
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_1) | instid1(VALU_DEP_4)
	v_cndmask_b32_e64 v25, 0, v25, s0
	v_cndmask_b32_e64 v24, 0, v24, s0
	v_fma_f64 v[38:39], v[42:43], v[46:47], 1.0
	v_cvt_i32_f64_e32 v42, v[40:41]
	v_fma_f64 v[40:41], v[44:45], v[48:49], 1.0
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_ldexp_f64 v[32:33], v[38:39], v50
	v_ldexp_f64 v[36:37], v[40:41], v42
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_cndmask_b32_e64 v26, 0x7ff00000, v33, s1
	v_cmp_neq_f64_e64 s1, 0x7ff00000, |v[18:19]|
	v_cndmask_b32_e64 v28, 0x7ff00000, v37, s3
	s_delay_alu instid0(VALU_DEP_3) | instskip(SKIP_2) | instid1(VALU_DEP_3)
	v_cndmask_b32_e64 v27, 0, v26, s2
	v_cndmask_b32_e32 v26, 0, v32, vcc_lo
	s_and_b32 vcc_lo, s4, s3
	v_cndmask_b32_e64 v29, 0, v28, s4
	v_cndmask_b32_e32 v28, 0, v36, vcc_lo
	v_cmp_neq_f64_e64 s3, 0x7ff00000, |v[20:21]|
	v_fma_f64 v[22:23], v[26:27], v[22:23], v[26:27]
	v_cmp_class_f64_e64 vcc_lo, v[26:27], 0x204
	v_cmp_neq_f64_e64 s2, 0, v[18:19]
	v_cmp_neq_f64_e64 s4, 0, v[20:21]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_dual_cndmask_b32 v23, v23, v27 :: v_dual_cndmask_b32 v22, v22, v26
	s_and_b32 vcc_lo, s2, s1
	s_delay_alu instid0(VALU_DEP_1)
	v_and_b32_e32 v23, 0x7fffffff, v23
	v_fma_f64 v[24:25], v[28:29], v[24:25], v[28:29]
	v_cmp_class_f64_e64 s0, v[28:29], 0x204
	v_cndmask_b32_e32 v22, 0, v22, vcc_lo
	s_and_b32 vcc_lo, s4, s3
	v_cndmask_b32_e64 v23, 0x7ff00000, v23, s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_cndmask_b32_e64 v23, 0, v23, s2
	v_cndmask_b32_e64 v25, v25, v29, s0
	v_cndmask_b32_e64 v24, v24, v28, s0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_dual_cndmask_b32 v24, 0, v24 :: v_dual_and_b32 v25, 0x7fffffff, v25
	v_cndmask_b32_e64 v25, 0x7ff00000, v25, s3
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_cndmask_b32_e64 v25, 0, v25, s4
	v_add_f64 v[22:23], v[22:23], v[24:25]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_cmp_gt_f64_e32 vcc_lo, 0x10000000, v[22:23]
	v_cndmask_b32_e64 v24, 0, 1, vcc_lo
	v_lshlrev_b32_e32 v24, 8, v24
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_ldexp_f64 v[22:23], v[22:23], v24
	v_rsq_f64_e32 v[24:25], v[22:23]
	s_waitcnt_depctr 0xfff
	v_mul_f64 v[26:27], v[22:23], v[24:25]
	v_mul_f64 v[24:25], v[24:25], 0.5
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[28:29], -v[24:25], v[26:27], 0.5
	v_fma_f64 v[26:27], v[26:27], v[28:29], v[26:27]
	v_fma_f64 v[24:25], v[24:25], v[28:29], v[24:25]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[28:29], -v[26:27], v[26:27], v[22:23]
	v_fma_f64 v[26:27], v[28:29], v[24:25], v[26:27]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[28:29], -v[26:27], v[26:27], v[22:23]
	v_fma_f64 v[24:25], v[28:29], v[24:25], v[26:27]
	v_cndmask_b32_e64 v26, 0, 0xffffff80, vcc_lo
	v_cmp_class_f64_e64 vcc_lo, v[22:23], 0x260
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_ldexp_f64 v[24:25], v[24:25], v26
	v_dual_cndmask_b32 v23, v25, v23 :: v_dual_cndmask_b32 v22, v24, v22
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_3)
	v_div_scale_f64 v[24:25], null, v[22:23], v[22:23], v[18:19]
	v_div_scale_f64 v[26:27], null, v[22:23], v[22:23], v[20:21]
	v_div_scale_f64 v[36:37], vcc_lo, v[18:19], v[22:23], v[18:19]
	v_rcp_f64_e32 v[28:29], v[24:25]
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_3) | instid1(VALU_DEP_2)
	v_rcp_f64_e32 v[30:31], v[26:27]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[32:33], -v[24:25], v[28:29], 1.0
	v_fma_f64 v[34:35], -v[26:27], v[30:31], 1.0
	v_fma_f64 v[28:29], v[28:29], v[32:33], v[28:29]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[30:31], v[30:31], v[34:35], v[30:31]
	v_fma_f64 v[32:33], -v[24:25], v[28:29], 1.0
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[34:35], -v[26:27], v[30:31], 1.0
	v_fma_f64 v[28:29], v[28:29], v[32:33], v[28:29]
	v_div_scale_f64 v[32:33], s0, v[20:21], v[22:23], v[20:21]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_fma_f64 v[30:31], v[30:31], v[34:35], v[30:31]
	v_mul_f64 v[34:35], v[36:37], v[28:29]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_mul_f64 v[38:39], v[32:33], v[30:31]
	v_fma_f64 v[24:25], -v[24:25], v[34:35], v[36:37]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_fma_f64 v[26:27], -v[26:27], v[38:39], v[32:33]
	v_div_fmas_f64 v[24:25], v[24:25], v[28:29], v[34:35]
	s_mov_b32 vcc_lo, s0
	s_mov_b32 s0, exec_lo
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_div_fmas_f64 v[26:27], v[26:27], v[30:31], v[38:39]
	v_div_fixup_f64 v[18:19], v[24:25], v[22:23], v[18:19]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_fixup_f64 v[20:21], v[26:27], v[22:23], v[20:21]
	v_mul_f64 v[22:23], v[8:9], v[20:21]
	v_mul_f64 v[24:25], v[12:13], v[20:21]
	v_mul_f64 v[26:27], v[10:11], v[20:21]
	v_mul_f64 v[28:29], v[14:15], v[20:21]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[10:11], v[10:11], v[18:19], -v[22:23]
	v_fma_f64 v[14:15], v[14:15], v[18:19], -v[24:25]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[22:23], v[8:9], v[18:19], v[26:27]
	v_fma_f64 v[12:13], v[12:13], v[18:19], v[28:29]
	s_delay_alu instid0(VALU_DEP_4) | instskip(SKIP_3) | instid1(VALU_DEP_4)
	v_mul_f64 v[8:9], v[20:21], v[10:11]
	v_mul_f64 v[10:11], v[18:19], v[10:11]
	v_mul_f64 v[24:25], v[20:21], v[14:15]
	v_mul_f64 v[14:15], v[18:19], v[14:15]
	v_fma_f64 v[8:9], v[18:19], v[12:13], -v[8:9]
	s_delay_alu instid0(VALU_DEP_4) | instskip(NEXT) | instid1(VALU_DEP_4)
	v_fma_f64 v[10:11], v[20:21], v[12:13], v[10:11]
	v_fma_f64 v[12:13], v[18:19], v[22:23], -v[24:25]
	s_delay_alu instid0(VALU_DEP_4)
	v_fma_f64 v[14:15], v[20:21], v[22:23], v[14:15]
	flat_store_b128 v[0:1], v[8:11] offset:24
	flat_store_b128 v[2:3], v[12:15] offset:24
	flat_load_b64 v[8:9], v[0:1] offset:24
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_eq_f64_e32 0, v[8:9]
	s_cbranch_execz .LBB3_4
; %bb.3:
	v_mov_b32_e32 v8, 0
	s_delay_alu instid0(VALU_DEP_1)
	v_mov_b32_e32 v9, v8
	flat_store_b64 v[0:1], v[8:9] offset:24
.LBB3_4:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b64 v[8:9], v[0:1] offset:32
	s_mov_b32 s0, exec_lo
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_eq_f64_e32 0, v[8:9]
	s_cbranch_execz .LBB3_6
; %bb.5:
	v_mov_b32_e32 v8, 0
	s_delay_alu instid0(VALU_DEP_1)
	v_mov_b32_e32 v9, v8
	flat_store_b64 v[0:1], v[8:9] offset:32
.LBB3_6:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b64 v[8:9], v[2:3] offset:24
	s_mov_b32 s0, exec_lo
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_eq_f64_e32 0, v[8:9]
	s_cbranch_execz .LBB3_8
; %bb.7:
	v_mov_b32_e32 v10, 0
	v_mov_b32_e32 v8, 0
	v_mov_b32_e32 v9, 0
	s_delay_alu instid0(VALU_DEP_3)
	v_mov_b32_e32 v11, v10
	flat_store_b64 v[2:3], v[10:11] offset:24
.LBB3_8:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b64 v[10:11], v[2:3] offset:32
	s_mov_b32 s0, exec_lo
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_eq_f64_e32 0, v[10:11]
	s_cbranch_execz .LBB3_10
; %bb.9:
	v_mov_b32_e32 v12, 0
	v_mov_b32_e32 v10, 0
	v_mov_b32_e32 v11, 0
	s_delay_alu instid0(VALU_DEP_3)
	v_mov_b32_e32 v13, v12
	flat_store_b64 v[2:3], v[12:13] offset:32
.LBB3_10:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b64 v[18:19], v[0:1] offset:24
	s_mov_b32 s0, exec_lo
                                        ; implicit-def: $vgpr20_vgpr21
                                        ; implicit-def: $sgpr1
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_ngt_f64_e32 0, v[18:19]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB3_12
; %bb.11:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_getpc_b64 s[4:5]
	s_add_u32 s4, s4, r@rel32@lo+4
	s_addc_u32 s5, s5, r@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_load_b64 s[4:5], s[4:5], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s2, s[2:3], 0x0
	s_load_b32 s1, s[4:5], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[12:13], s2
	v_cvt_f64_i32_e32 v[14:15], s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[12:13], v[12:13], -v[14:15]
	v_add_f64 v[12:13], v[12:13], -v[4:5]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[14:15], null, v[18:19], v[18:19], v[12:13]
	v_rcp_f64_e32 v[20:21], v[14:15]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[22:23], -v[14:15], v[20:21], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[20:21], v[20:21], v[22:23], v[20:21]
	v_fma_f64 v[22:23], -v[14:15], v[20:21], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[20:21], v[20:21], v[22:23], v[20:21]
	v_div_scale_f64 v[22:23], vcc_lo, v[12:13], v[18:19], v[12:13]
	v_mul_f64 v[24:25], v[22:23], v[20:21]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[14:15], -v[14:15], v[24:25], v[22:23]
	v_div_fmas_f64 v[14:15], v[14:15], v[20:21], v[24:25]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[20:21], v[14:15], v[18:19], v[12:13]
.LBB3_12:                               ; %Flow157
	s_or_saveexec_b32 s0, s0
	v_mov_b32_e32 v12, s1
	s_xor_b32 exec_lo, exec_lo, s0
	s_cbranch_execz .LBB3_14
; %bb.13:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, r@rel32@lo+4
	s_addc_u32 s3, s3, r@rel32@hi+12
	v_add_f64 v[14:15], -v[18:19], 0
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[12:13], s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[12:13], v[4:5], -v[12:13]
	v_div_scale_f64 v[20:21], null, v[14:15], v[14:15], v[12:13]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_rcp_f64_e32 v[22:23], v[20:21]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[24:25], -v[20:21], v[22:23], 1.0
	v_fma_f64 v[22:23], v[22:23], v[24:25], v[22:23]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[24:25], -v[20:21], v[22:23], 1.0
	v_fma_f64 v[22:23], v[22:23], v[24:25], v[22:23]
	v_div_scale_f64 v[24:25], vcc_lo, v[12:13], v[14:15], v[12:13]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mul_f64 v[26:27], v[24:25], v[22:23]
	v_fma_f64 v[20:21], -v[20:21], v[26:27], v[24:25]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_fmas_f64 v[20:21], v[20:21], v[22:23], v[26:27]
	v_div_fixup_f64 v[20:21], v[20:21], v[14:15], v[12:13]
	v_mov_b32_e32 v12, s1
.LBB3_14:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b64 v[22:23], v[0:1] offset:32
	v_cvt_f64_i32_e32 v[14:15], v12
	s_mov_b32 s0, exec_lo
                                        ; implicit-def: $vgpr24_vgpr25
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_ngt_f64_e32 0, v[22:23]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB3_16
; %bb.15:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[12:13], s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[12:13], v[12:13], -v[14:15]
	v_add_f64 v[12:13], v[12:13], -v[6:7]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[24:25], null, v[22:23], v[22:23], v[12:13]
	v_rcp_f64_e32 v[26:27], v[24:25]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[28:29], -v[24:25], v[26:27], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[26:27], v[26:27], v[28:29], v[26:27]
	v_fma_f64 v[28:29], -v[24:25], v[26:27], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[26:27], v[26:27], v[28:29], v[26:27]
	v_div_scale_f64 v[28:29], vcc_lo, v[12:13], v[22:23], v[12:13]
	v_mul_f64 v[30:31], v[28:29], v[26:27]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[24:25], -v[24:25], v[30:31], v[28:29]
	v_div_fmas_f64 v[24:25], v[24:25], v[26:27], v[30:31]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[24:25], v[24:25], v[22:23], v[12:13]
.LBB3_16:                               ; %Flow156
	s_and_not1_saveexec_b32 s0, s0
	s_cbranch_execz .LBB3_18
; %bb.17:
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_add_f64 v[12:13], v[6:7], -v[14:15]
	v_add_f64 v[24:25], -v[22:23], 0
	v_div_scale_f64 v[26:27], null, v[24:25], v[24:25], v[12:13]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_rcp_f64_e32 v[28:29], v[26:27]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[30:31], -v[26:27], v[28:29], 1.0
	v_fma_f64 v[28:29], v[28:29], v[30:31], v[28:29]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[30:31], -v[26:27], v[28:29], 1.0
	v_fma_f64 v[28:29], v[28:29], v[30:31], v[28:29]
	v_div_scale_f64 v[30:31], vcc_lo, v[12:13], v[24:25], v[12:13]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mul_f64 v[32:33], v[30:31], v[28:29]
	v_fma_f64 v[26:27], -v[26:27], v[32:33], v[30:31]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_fmas_f64 v[26:27], v[26:27], v[28:29], v[32:33]
	v_div_fixup_f64 v[24:25], v[26:27], v[24:25], v[12:13]
.LBB3_18:
	s_or_b32 exec_lo, exec_lo, s0
	v_add_f64 v[12:13], -v[16:17], 1.0
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_3)
	v_max_f64 v[16:17], v[24:25], v[24:25]
	v_max_f64 v[26:27], v[20:21], v[20:21]
	v_cmp_nge_f64_e32 vcc_lo, v[20:21], v[12:13]
	v_cmp_nge_f64_e64 s0, v[24:25], v[12:13]
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_2)
	v_min_f64 v[16:17], v[26:27], v[16:17]
	s_or_b32 vcc_lo, vcc_lo, s0
	s_mov_b32 s0, exec_lo
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_dual_cndmask_b32 v17, v13, v17 :: v_dual_cndmask_b32 v16, v12, v16
	v_fma_f64 v[4:5], v[18:19], v[16:17], v[4:5]
	v_fma_f64 v[6:7], v[22:23], v[16:17], v[6:7]
	flat_store_b128 v[0:1], v[4:7] offset:8
                                        ; implicit-def: $vgpr6_vgpr7
                                        ; implicit-def: $vgpr4_vgpr5
	v_cmpx_ngt_f64_e32 0, v[8:9]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB3_20
; %bb.19:
	flat_load_b64 v[4:5], v[2:3] offset:8
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[6:7], s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_add_f64 v[6:7], v[6:7], -v[14:15]
	s_waitcnt vmcnt(0)
	v_add_f64 v[6:7], v[6:7], -v[4:5]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[16:17], null, v[8:9], v[8:9], v[6:7]
	v_rcp_f64_e32 v[18:19], v[16:17]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[20:21], -v[16:17], v[18:19], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[18:19], v[18:19], v[20:21], v[18:19]
	v_fma_f64 v[20:21], -v[16:17], v[18:19], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[18:19], v[18:19], v[20:21], v[18:19]
	v_div_scale_f64 v[20:21], vcc_lo, v[6:7], v[8:9], v[6:7]
	v_mul_f64 v[22:23], v[20:21], v[18:19]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[16:17], -v[16:17], v[22:23], v[20:21]
	v_div_fmas_f64 v[16:17], v[16:17], v[18:19], v[22:23]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[6:7], v[16:17], v[8:9], v[6:7]
.LBB3_20:                               ; %Flow155
	s_and_not1_saveexec_b32 s0, s0
	s_cbranch_execz .LBB3_22
; %bb.21:
	flat_load_b64 v[4:5], v[2:3] offset:8
	v_add_f64 v[6:7], -v[8:9], 0
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_f64 v[16:17], v[4:5], -v[14:15]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[18:19], null, v[6:7], v[6:7], v[16:17]
	v_rcp_f64_e32 v[20:21], v[18:19]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[22:23], -v[18:19], v[20:21], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[20:21], v[20:21], v[22:23], v[20:21]
	v_fma_f64 v[22:23], -v[18:19], v[20:21], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[20:21], v[20:21], v[22:23], v[20:21]
	v_div_scale_f64 v[22:23], vcc_lo, v[16:17], v[6:7], v[16:17]
	v_mul_f64 v[24:25], v[22:23], v[20:21]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[18:19], -v[18:19], v[24:25], v[22:23]
	v_div_fmas_f64 v[18:19], v[18:19], v[20:21], v[24:25]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[6:7], v[18:19], v[6:7], v[16:17]
.LBB3_22:
	s_or_b32 exec_lo, exec_lo, s0
	s_delay_alu instid0(SALU_CYCLE_1)
	s_mov_b32 s0, exec_lo
                                        ; implicit-def: $vgpr18_vgpr19
                                        ; implicit-def: $vgpr16_vgpr17
	v_cmpx_ngt_f64_e32 0, v[10:11]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB3_24
; %bb.23:
	flat_load_b64 v[16:17], v[2:3] offset:16
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[18:19], s1
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_add_f64 v[14:15], v[18:19], -v[14:15]
	s_waitcnt vmcnt(0)
	v_add_f64 v[14:15], v[14:15], -v[16:17]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[18:19], null, v[10:11], v[10:11], v[14:15]
	v_rcp_f64_e32 v[20:21], v[18:19]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[22:23], -v[18:19], v[20:21], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[20:21], v[20:21], v[22:23], v[20:21]
	v_fma_f64 v[22:23], -v[18:19], v[20:21], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[20:21], v[20:21], v[22:23], v[20:21]
	v_div_scale_f64 v[22:23], vcc_lo, v[14:15], v[10:11], v[14:15]
	v_mul_f64 v[24:25], v[22:23], v[20:21]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[18:19], -v[18:19], v[24:25], v[22:23]
	v_div_fmas_f64 v[18:19], v[18:19], v[20:21], v[24:25]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[18:19], v[18:19], v[10:11], v[14:15]
                                        ; implicit-def: $vgpr14_vgpr15
.LBB3_24:                               ; %Flow
	s_and_not1_saveexec_b32 s0, s0
	s_cbranch_execz .LBB3_26
; %bb.25:
	flat_load_b64 v[16:17], v[2:3] offset:16
	v_add_f64 v[18:19], -v[10:11], 0
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_f64 v[14:15], v[16:17], -v[14:15]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[20:21], null, v[18:19], v[18:19], v[14:15]
	v_rcp_f64_e32 v[22:23], v[20:21]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[24:25], -v[20:21], v[22:23], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[22:23], v[22:23], v[24:25], v[22:23]
	v_fma_f64 v[24:25], -v[20:21], v[22:23], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[22:23], v[22:23], v[24:25], v[22:23]
	v_div_scale_f64 v[24:25], vcc_lo, v[14:15], v[18:19], v[14:15]
	v_mul_f64 v[26:27], v[24:25], v[22:23]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[20:21], -v[20:21], v[26:27], v[24:25]
	v_div_fmas_f64 v[20:21], v[20:21], v[22:23], v[26:27]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[18:19], v[20:21], v[18:19], v[14:15]
.LBB3_26:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b32 v14, v[0:1] offset:40
	v_cmp_nge_f64_e32 vcc_lo, v[6:7], v[12:13]
	v_cmp_nge_f64_e64 s0, v[18:19], v[12:13]
	s_delay_alu instid0(VALU_DEP_1)
	s_or_b32 vcc_lo, vcc_lo, s0
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_nc_u32_e32 v14, 1, v14
	flat_store_b32 v[0:1], v14 offset:40
	flat_load_b32 v20, v[2:3] offset:40
	v_max_f64 v[0:1], v[18:19], v[18:19]
	v_max_f64 v[14:15], v[6:7], v[6:7]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_min_f64 v[0:1], v[14:15], v[0:1]
	v_dual_cndmask_b32 v1, v13, v1 :: v_dual_cndmask_b32 v0, v12, v0
	s_delay_alu instid0(VALU_DEP_1)
	v_fma_f64 v[4:5], v[8:9], v[0:1], v[4:5]
	v_fma_f64 v[6:7], v[10:11], v[0:1], v[16:17]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_nc_u32_e32 v0, 1, v20
	s_clause 0x1
	flat_store_b128 v[2:3], v[4:7] offset:8
	flat_store_b32 v[2:3], v0 offset:40
.LBB3_27:                               ; %.critedge
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z24executeParticleCollisionv
		.amdhsa_group_segment_fixed_size 0
		.amdhsa_private_segment_fixed_size 0
		.amdhsa_kernarg_size 256
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 0
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 62
		.amdhsa_next_free_sgpr 16
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end3:
	.size	_Z24executeParticleCollisionv, .Lfunc_end3-_Z24executeParticleCollisionv
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 6116
; NumSgprs: 18
; NumVgprs: 62
; ScratchSize: 0
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 0 bytes/workgroup (compile time only)
; SGPRBlocks: 2
; VGPRBlocks: 7
; NumSGPRsForWavesPerEU: 18
; NumVGPRsForWavesPerEU: 62
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 0
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.protected	_Z20executeWallCollisionv ; -- Begin function _Z20executeWallCollisionv
	.globl	_Z20executeWallCollisionv
	.p2align	8
	.type	_Z20executeWallCollisionv,@function
_Z20executeWallCollisionv:              ; @_Z20executeWallCollisionv
; %bb.0:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, wallCollisionsCount@rel32@lo+4
	s_addc_u32 s3, s3, wallCollisionsCount@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_load_b32 s0, s[0:1], 0xc
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_and_b32 s0, s0, 0xffff
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[1:2], null, s15, s0, v[0:1]
	s_mov_b32 s0, exec_lo
	s_waitcnt lgkmcnt(0)
	v_cmpx_gt_i32_e64 s1, v1
	s_cbranch_execz .LBB4_14
; %bb.1:
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, wallCollisions@rel32@lo+4
	s_addc_u32 s1, s1, wallCollisions@rel32@hi+12
	v_ashrrev_i32_e32 v2, 31, v1
	s_load_b64 s[0:1], s[0:1], 0x0
                                        ; implicit-def: $vgpr6_vgpr7
                                        ; implicit-def: $vgpr4_vgpr5
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_3) | instid1(VALU_DEP_1)
	v_lshlrev_b64 v[0:1], 3, v[1:2]
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	v_add_co_u32 v0, vcc_lo, s0, v0
	s_delay_alu instid0(VALU_DEP_2)
	v_add_co_ci_u32_e32 v1, vcc_lo, s1, v1, vcc_lo
	s_mov_b32 s0, exec_lo
                                        ; implicit-def: $sgpr1
	flat_load_b64 v[0:1], v[0:1]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	flat_load_b64 v[0:1], v[0:1] offset:8
	s_waitcnt vmcnt(0) lgkmcnt(0)
	flat_load_b64 v[2:3], v[0:1] offset:24
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_ngt_f64_e32 0, v[2:3]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB4_3
; %bb.2:
	flat_load_b64 v[4:5], v[0:1] offset:8
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, r@rel32@lo+4
	s_addc_u32 s3, s3, r@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[6:7], s1
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[8:9], s1
	s_waitcnt vmcnt(0)
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[6:7], v[6:7], -v[4:5]
	v_add_f64 v[6:7], v[6:7], -v[8:9]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[8:9], null, v[2:3], v[2:3], v[6:7]
	v_rcp_f64_e32 v[10:11], v[8:9]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[12:13], -v[8:9], v[10:11], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[10:11], v[10:11], v[12:13], v[10:11]
	v_fma_f64 v[12:13], -v[8:9], v[10:11], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[10:11], v[10:11], v[12:13], v[10:11]
	v_div_scale_f64 v[12:13], vcc_lo, v[6:7], v[2:3], v[6:7]
	v_mul_f64 v[14:15], v[12:13], v[10:11]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[8:9], -v[8:9], v[14:15], v[12:13]
	v_div_fmas_f64 v[8:9], v[8:9], v[10:11], v[14:15]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[6:7], v[8:9], v[2:3], v[6:7]
.LBB4_3:                                ; %Flow48
	s_or_saveexec_b32 s0, s0
	v_mov_b32_e32 v10, s1
	s_xor_b32 exec_lo, exec_lo, s0
	s_cbranch_execz .LBB4_5
; %bb.4:
	flat_load_b64 v[4:5], v[0:1] offset:8
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, r@rel32@lo+4
	s_addc_u32 s3, s3, r@rel32@hi+12
	v_add_f64 v[8:9], -v[2:3], 0
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[6:7], s1
	s_waitcnt vmcnt(0)
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[6:7], v[4:5], -v[6:7]
	v_div_scale_f64 v[10:11], null, v[8:9], v[8:9], v[6:7]
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_rcp_f64_e32 v[12:13], v[10:11]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[14:15], -v[10:11], v[12:13], 1.0
	v_fma_f64 v[12:13], v[12:13], v[14:15], v[12:13]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[14:15], -v[10:11], v[12:13], 1.0
	v_fma_f64 v[12:13], v[12:13], v[14:15], v[12:13]
	v_div_scale_f64 v[14:15], vcc_lo, v[6:7], v[8:9], v[6:7]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_mul_f64 v[16:17], v[14:15], v[12:13]
	v_fma_f64 v[10:11], -v[10:11], v[16:17], v[14:15]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_fmas_f64 v[10:11], v[10:11], v[12:13], v[16:17]
	v_div_fixup_f64 v[6:7], v[10:11], v[8:9], v[6:7]
	v_mov_b32_e32 v10, s1
.LBB4_5:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b64 v[8:9], v[0:1] offset:32
	v_cvt_f64_i32_e32 v[14:15], v10
	s_mov_b32 s0, exec_lo
                                        ; implicit-def: $vgpr12_vgpr13
                                        ; implicit-def: $vgpr10_vgpr11
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_cmpx_ngt_f64_e32 0, v[8:9]
	s_xor_b32 s0, exec_lo, s0
	s_cbranch_execz .LBB4_7
; %bb.6:
	flat_load_b64 v[10:11], v[0:1] offset:16
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, l@rel32@lo+4
	s_addc_u32 s3, s3, l@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_waitcnt lgkmcnt(0)
	v_cvt_f64_i32_e32 v[12:13], s1
	s_waitcnt vmcnt(0)
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_add_f64 v[12:13], v[12:13], -v[10:11]
	v_add_f64 v[12:13], v[12:13], -v[14:15]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[14:15], null, v[8:9], v[8:9], v[12:13]
	v_rcp_f64_e32 v[16:17], v[14:15]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[18:19], -v[14:15], v[16:17], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[16:17], v[16:17], v[18:19], v[16:17]
	v_fma_f64 v[18:19], -v[14:15], v[16:17], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[16:17], v[16:17], v[18:19], v[16:17]
	v_div_scale_f64 v[18:19], vcc_lo, v[12:13], v[8:9], v[12:13]
	v_mul_f64 v[20:21], v[18:19], v[16:17]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[14:15], -v[14:15], v[20:21], v[18:19]
	v_div_fmas_f64 v[14:15], v[14:15], v[16:17], v[20:21]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[12:13], v[14:15], v[8:9], v[12:13]
                                        ; implicit-def: $vgpr14_vgpr15
.LBB4_7:                                ; %Flow
	s_and_not1_saveexec_b32 s0, s0
	s_cbranch_execz .LBB4_9
; %bb.8:
	flat_load_b64 v[10:11], v[0:1] offset:16
	v_add_f64 v[12:13], -v[8:9], 0
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_f64 v[14:15], v[10:11], -v[14:15]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_div_scale_f64 v[16:17], null, v[12:13], v[12:13], v[14:15]
	v_rcp_f64_e32 v[18:19], v[16:17]
	s_waitcnt_depctr 0xfff
	v_fma_f64 v[20:21], -v[16:17], v[18:19], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[18:19], v[18:19], v[20:21], v[18:19]
	v_fma_f64 v[20:21], -v[16:17], v[18:19], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_1)
	v_fma_f64 v[18:19], v[18:19], v[20:21], v[18:19]
	v_div_scale_f64 v[20:21], vcc_lo, v[14:15], v[12:13], v[14:15]
	v_mul_f64 v[22:23], v[20:21], v[18:19]
	s_delay_alu instid0(VALU_DEP_1) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_fma_f64 v[16:17], -v[16:17], v[22:23], v[20:21]
	v_div_fmas_f64 v[16:17], v[16:17], v[18:19], v[22:23]
	s_delay_alu instid0(VALU_DEP_1)
	v_div_fixup_f64 v[12:13], v[16:17], v[12:13], v[14:15]
.LBB4_9:
	s_or_b32 exec_lo, exec_lo, s0
	v_dual_mov_b32 v15, v3 :: v_dual_mov_b32 v14, v2
	s_mov_b32 s0, exec_lo
	s_delay_alu instid0(VALU_DEP_2)
	v_cmpx_le_f64_e32 v[6:7], v[12:13]
	s_cbranch_execz .LBB4_11
; %bb.10:
	v_xor_b32_e32 v15, 0x80000000, v3
	v_mov_b32_e32 v14, v2
	flat_store_b64 v[0:1], v[14:15] offset:24
.LBB4_11:
	s_or_b32 exec_lo, exec_lo, s0
	v_dual_mov_b32 v17, v9 :: v_dual_mov_b32 v16, v8
	s_mov_b32 s0, exec_lo
	v_cmpx_le_f64_e32 v[12:13], v[6:7]
	s_cbranch_execz .LBB4_13
; %bb.12:
	v_xor_b32_e32 v17, 0x80000000, v9
	v_mov_b32_e32 v16, v8
	flat_store_b64 v[0:1], v[16:17] offset:32
.LBB4_13:
	s_or_b32 exec_lo, exec_lo, s0
	flat_load_b32 v24, v[0:1] offset:44
	v_max_f64 v[18:19], v[12:13], v[12:13]
	v_max_f64 v[20:21], v[6:7], v[6:7]
	v_cmp_neq_f64_e32 vcc_lo, v[6:7], v[12:13]
	s_delay_alu instid0(VALU_DEP_2) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_max_f64 v[22:23], v[20:21], v[18:19]
	v_min_f64 v[12:13], v[20:21], v[18:19]
	v_cndmask_b32_e32 v7, 0x3ff00000, v23, vcc_lo
	s_delay_alu instid0(VALU_DEP_3) | instskip(NEXT) | instid1(VALU_DEP_3)
	v_cndmask_b32_e32 v6, 0, v22, vcc_lo
	v_fma_f64 v[2:3], v[2:3], v[12:13], v[4:5]
	s_delay_alu instid0(VALU_DEP_2) | instskip(NEXT) | instid1(VALU_DEP_1)
	v_max_f64 v[6:7], v[6:7], v[6:7]
	v_min_f64 v[6:7], v[6:7], 1.0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_1) | instid1(VALU_DEP_2)
	v_add_f64 v[4:5], v[6:7], -v[12:13]
	v_fma_f64 v[6:7], v[8:9], v[12:13], v[10:11]
	v_fma_f64 v[2:3], v[4:5], v[14:15], v[2:3]
	s_delay_alu instid0(VALU_DEP_2)
	v_fma_f64 v[4:5], v[4:5], v[16:17], v[6:7]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_nc_u32_e32 v6, 1, v24
	s_clause 0x1
	flat_store_b128 v[0:1], v[2:5] offset:8
	flat_store_b32 v[0:1], v6 offset:44
.LBB4_14:
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z20executeWallCollisionv
		.amdhsa_group_segment_fixed_size 0
		.amdhsa_private_segment_fixed_size 0
		.amdhsa_kernarg_size 256
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 0
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 25
		.amdhsa_next_free_sgpr 16
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end4:
	.size	_Z20executeWallCollisionv, .Lfunc_end4-_Z20executeWallCollisionv
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 1280
; NumSgprs: 18
; NumVgprs: 25
; ScratchSize: 0
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 0 bytes/workgroup (compile time only)
; SGPRBlocks: 2
; VGPRBlocks: 3
; NumSGPRsForWavesPerEU: 18
; NumVGPRsForWavesPerEU: 25
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 0
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.protected	_Z18executeNoCollisionv ; -- Begin function _Z18executeNoCollisionv
	.globl	_Z18executeNoCollisionv
	.p2align	8
	.type	_Z18executeNoCollisionv,@function
_Z18executeNoCollisionv:                ; @_Z18executeNoCollisionv
; %bb.0:
	s_getpc_b64 s[2:3]
	s_add_u32 s2, s2, noCollisionsCount@rel32@lo+4
	s_addc_u32 s3, s3, noCollisionsCount@rel32@hi+12
	s_load_b64 s[2:3], s[2:3], 0x0
	s_load_b32 s0, s[0:1], 0xc
	s_waitcnt lgkmcnt(0)
	s_load_b32 s1, s[2:3], 0x0
	s_and_b32 s0, s0, 0xffff
	s_delay_alu instid0(SALU_CYCLE_1) | instskip(SKIP_2) | instid1(VALU_DEP_1)
	v_mad_u64_u32 v[1:2], null, s15, s0, v[0:1]
	s_mov_b32 s0, exec_lo
	s_waitcnt lgkmcnt(0)
	v_cmpx_gt_i32_e64 s1, v1
	s_cbranch_execz .LBB5_2
; %bb.1:
	s_getpc_b64 s[0:1]
	s_add_u32 s0, s0, noCollisions@rel32@lo+4
	s_addc_u32 s1, s1, noCollisions@rel32@hi+12
	v_ashrrev_i32_e32 v2, 31, v1
	s_load_b64 s[0:1], s[0:1], 0x0
	s_delay_alu instid0(VALU_DEP_1) | instskip(SKIP_3) | instid1(VALU_DEP_1)
	v_lshlrev_b64 v[0:1], 3, v[1:2]
	s_waitcnt lgkmcnt(0)
	s_load_b64 s[0:1], s[0:1], 0x0
	s_waitcnt lgkmcnt(0)
	v_add_co_u32 v0, vcc_lo, s0, v0
	s_delay_alu instid0(VALU_DEP_2)
	v_add_co_ci_u32_e32 v1, vcc_lo, s1, v1, vcc_lo
	flat_load_b64 v[0:1], v[0:1]
	s_waitcnt vmcnt(0) lgkmcnt(0)
	flat_load_b64 v[8:9], v[0:1] offset:8
	s_waitcnt vmcnt(0) lgkmcnt(0)
	s_clause 0x1
	flat_load_b128 v[0:3], v[8:9] offset:24
	flat_load_b128 v[4:7], v[8:9] offset:8
	s_waitcnt vmcnt(0) lgkmcnt(0)
	v_add_f64 v[0:1], v[0:1], v[4:5]
	v_add_f64 v[2:3], v[2:3], v[6:7]
	flat_store_b128 v[8:9], v[0:3] offset:8
.LBB5_2:
	s_endpgm
	.section	.rodata,"a",@progbits
	.p2align	6, 0x0
	.amdhsa_kernel _Z18executeNoCollisionv
		.amdhsa_group_segment_fixed_size 0
		.amdhsa_private_segment_fixed_size 0
		.amdhsa_kernarg_size 256
		.amdhsa_user_sgpr_count 15
		.amdhsa_user_sgpr_dispatch_ptr 0
		.amdhsa_user_sgpr_queue_ptr 0
		.amdhsa_user_sgpr_kernarg_segment_ptr 1
		.amdhsa_user_sgpr_dispatch_id 0
		.amdhsa_user_sgpr_private_segment_size 0
		.amdhsa_wavefront_size32 1
		.amdhsa_uses_dynamic_stack 0
		.amdhsa_enable_private_segment 0
		.amdhsa_system_sgpr_workgroup_id_x 1
		.amdhsa_system_sgpr_workgroup_id_y 0
		.amdhsa_system_sgpr_workgroup_id_z 0
		.amdhsa_system_sgpr_workgroup_info 0
		.amdhsa_system_vgpr_workitem_id 0
		.amdhsa_next_free_vgpr 10
		.amdhsa_next_free_sgpr 16
		.amdhsa_float_round_mode_32 0
		.amdhsa_float_round_mode_16_64 0
		.amdhsa_float_denorm_mode_32 3
		.amdhsa_float_denorm_mode_16_64 3
		.amdhsa_dx10_clamp 1
		.amdhsa_ieee_mode 1
		.amdhsa_fp16_overflow 0
		.amdhsa_workgroup_processor_mode 1
		.amdhsa_memory_ordered 1
		.amdhsa_forward_progress 0
		.amdhsa_shared_vgpr_count 0
		.amdhsa_exception_fp_ieee_invalid_op 0
		.amdhsa_exception_fp_denorm_src 0
		.amdhsa_exception_fp_ieee_div_zero 0
		.amdhsa_exception_fp_ieee_overflow 0
		.amdhsa_exception_fp_ieee_underflow 0
		.amdhsa_exception_fp_ieee_inexact 0
		.amdhsa_exception_int_div_zero 0
	.end_amdhsa_kernel
	.text
.Lfunc_end5:
	.size	_Z18executeNoCollisionv, .Lfunc_end5-_Z18executeNoCollisionv
                                        ; -- End function
	.section	.AMDGPU.csdata,"",@progbits
; Kernel info:
; codeLenInByte = 240
; NumSgprs: 18
; NumVgprs: 10
; ScratchSize: 0
; MemoryBound: 0
; FloatMode: 240
; IeeeMode: 1
; LDSByteSize: 0 bytes/workgroup (compile time only)
; SGPRBlocks: 2
; VGPRBlocks: 1
; NumSGPRsForWavesPerEU: 18
; NumVGPRsForWavesPerEU: 10
; Occupancy: 16
; WaveLimiterHint : 1
; COMPUTE_PGM_RSRC2:SCRATCH_EN: 0
; COMPUTE_PGM_RSRC2:USER_SGPR: 15
; COMPUTE_PGM_RSRC2:TRAP_HANDLER: 0
; COMPUTE_PGM_RSRC2:TGID_X_EN: 1
; COMPUTE_PGM_RSRC2:TGID_Y_EN: 0
; COMPUTE_PGM_RSRC2:TGID_Z_EN: 0
; COMPUTE_PGM_RSRC2:TIDIG_COMP_CNT: 0
	.text
	.p2alignl 7, 3214868480
	.fill 96, 4, 3214868480
	.protected	n.managed               ; @n.managed
	.type	n.managed,@object
	.section	.bss,"aw",@nobits
	.globl	n.managed
	.p2align	2, 0x0
n.managed:
	.long	0                               ; 0x0
	.size	n.managed, 4

	.protected	l.managed               ; @l.managed
	.type	l.managed,@object
	.globl	l.managed
	.p2align	2, 0x0
l.managed:
	.long	0                               ; 0x0
	.size	l.managed, 4

	.protected	r.managed               ; @r.managed
	.type	r.managed,@object
	.globl	r.managed
	.p2align	2, 0x0
r.managed:
	.long	0                               ; 0x0
	.size	r.managed, 4

	.protected	s.managed               ; @s.managed
	.type	s.managed,@object
	.globl	s.managed
	.p2align	2, 0x0
s.managed:
	.long	0                               ; 0x0
	.size	s.managed, 4

	.protected	particles.managed       ; @particles.managed
	.type	particles.managed,@object
	.globl	particles.managed
	.p2align	3, 0x0
particles.managed:
	.quad	0
	.size	particles.managed, 8

	.protected	particleCollisionTimes.managed ; @particleCollisionTimes.managed
	.type	particleCollisionTimes.managed,@object
	.globl	particleCollisionTimes.managed
	.p2align	3, 0x0
particleCollisionTimes.managed:
	.quad	0
	.size	particleCollisionTimes.managed, 8

	.protected	wallCollisionTimes.managed ; @wallCollisionTimes.managed
	.type	wallCollisionTimes.managed,@object
	.globl	wallCollisionTimes.managed
	.p2align	3, 0x0
wallCollisionTimes.managed:
	.quad	0
	.size	wallCollisionTimes.managed, 8

	.protected	temp.managed            ; @temp.managed
	.type	temp.managed,@object
	.globl	temp.managed
	.p2align	3, 0x0
temp.managed:
	.quad	0
	.size	temp.managed, 8

	.protected	found.managed           ; @found.managed
	.type	found.managed,@object
	.globl	found.managed
	.p2align	3, 0x0
found.managed:
	.quad	0
	.size	found.managed, 8

	.protected	particleCollisions.managed ; @particleCollisions.managed
	.type	particleCollisions.managed,@object
	.globl	particleCollisions.managed
	.p2align	3, 0x0
particleCollisions.managed:
	.quad	0
	.size	particleCollisions.managed, 8

	.protected	particleCollisionsCount.managed ; @particleCollisionsCount.managed
	.type	particleCollisionsCount.managed,@object
	.globl	particleCollisionsCount.managed
	.p2align	2, 0x0
particleCollisionsCount.managed:
	.long	0                               ; 0x0
	.size	particleCollisionsCount.managed, 4

	.protected	wallCollisions.managed  ; @wallCollisions.managed
	.type	wallCollisions.managed,@object
	.globl	wallCollisions.managed
	.p2align	3, 0x0
wallCollisions.managed:
	.quad	0
	.size	wallCollisions.managed, 8

	.protected	wallCollisionsCount.managed ; @wallCollisionsCount.managed
	.type	wallCollisionsCount.managed,@object
	.globl	wallCollisionsCount.managed
	.p2align	2, 0x0
wallCollisionsCount.managed:
	.long	0                               ; 0x0
	.size	wallCollisionsCount.managed, 4

	.protected	noCollisions.managed    ; @noCollisions.managed
	.type	noCollisions.managed,@object
	.globl	noCollisions.managed
	.p2align	3, 0x0
noCollisions.managed:
	.quad	0
	.size	noCollisions.managed, 8

	.protected	noCollisionsCount.managed ; @noCollisionsCount.managed
	.type	noCollisionsCount.managed,@object
	.globl	noCollisionsCount.managed
	.p2align	2, 0x0
noCollisionsCount.managed:
	.long	0                               ; 0x0
	.size	noCollisionsCount.managed, 4

	.protected	n                       ; @n
	.type	n,@object
	.globl	n
	.p2align	3, 0x0
n:
	.quad	0
	.size	n, 8

	.protected	l                       ; @l
	.type	l,@object
	.globl	l
	.p2align	3, 0x0
l:
	.quad	0
	.size	l, 8

	.protected	r                       ; @r
	.type	r,@object
	.globl	r
	.p2align	3, 0x0
r:
	.quad	0
	.size	r, 8

	.protected	s                       ; @s
	.type	s,@object
	.globl	s
	.p2align	3, 0x0
s:
	.quad	0
	.size	s, 8

	.protected	particles               ; @particles
	.type	particles,@object
	.globl	particles
	.p2align	3, 0x0
particles:
	.quad	0
	.size	particles, 8

	.protected	particleCollisionTimes  ; @particleCollisionTimes
	.type	particleCollisionTimes,@object
	.globl	particleCollisionTimes
	.p2align	3, 0x0
particleCollisionTimes:
	.quad	0
	.size	particleCollisionTimes, 8

	.protected	wallCollisionTimes      ; @wallCollisionTimes
	.type	wallCollisionTimes,@object
	.globl	wallCollisionTimes
	.p2align	3, 0x0
wallCollisionTimes:
	.quad	0
	.size	wallCollisionTimes, 8

	.protected	temp                    ; @temp
	.type	temp,@object
	.globl	temp
	.p2align	3, 0x0
temp:
	.quad	0
	.size	temp, 8

	.protected	found                   ; @found
	.type	found,@object
	.globl	found
	.p2align	3, 0x0
found:
	.quad	0
	.size	found, 8

	.protected	particleCollisions      ; @particleCollisions
	.type	particleCollisions,@object
	.globl	particleCollisions
	.p2align	3, 0x0
particleCollisions:
	.quad	0
	.size	particleCollisions, 8

	.protected	particleCollisionsCount ; @particleCollisionsCount
	.type	particleCollisionsCount,@object
	.globl	particleCollisionsCount
	.p2align	3, 0x0
particleCollisionsCount:
	.quad	0
	.size	particleCollisionsCount, 8

	.protected	wallCollisions          ; @wallCollisions
	.type	wallCollisions,@object
	.globl	wallCollisions
	.p2align	3, 0x0
wallCollisions:
	.quad	0
	.size	wallCollisions, 8

	.protected	wallCollisionsCount     ; @wallCollisionsCount
	.type	wallCollisionsCount,@object
	.globl	wallCollisionsCount
	.p2align	3, 0x0
wallCollisionsCount:
	.quad	0
	.size	wallCollisionsCount, 8

	.protected	noCollisions            ; @noCollisions
	.type	noCollisions,@object
	.globl	noCollisions
	.p2align	3, 0x0
noCollisions:
	.quad	0
	.size	noCollisions, 8

	.protected	noCollisionsCount       ; @noCollisionsCount
	.type	noCollisionsCount,@object
	.globl	noCollisionsCount
	.p2align	3, 0x0
noCollisionsCount:
	.quad	0
	.size	noCollisionsCount, 8

	.type	__hip_cuid_,@object             ; @__hip_cuid_
	.globl	__hip_cuid_
__hip_cuid_:
	.byte	0                               ; 0x0
	.size	__hip_cuid_, 1

	.ident	"AMD clang version 18.0.0git (https://github.com/RadeonOpenCompute/llvm-project roc-6.3.2 25012 e5bf7e55c91490b07c49d8960fa7983d864936c4)"
	.section	".note.GNU-stack","",@progbits
	.addrsig
	.addrsig_sym n.managed
	.addrsig_sym l.managed
	.addrsig_sym r.managed
	.addrsig_sym s.managed
	.addrsig_sym particles.managed
	.addrsig_sym particleCollisionTimes.managed
	.addrsig_sym wallCollisionTimes.managed
	.addrsig_sym temp.managed
	.addrsig_sym found.managed
	.addrsig_sym particleCollisions.managed
	.addrsig_sym particleCollisionsCount.managed
	.addrsig_sym wallCollisions.managed
	.addrsig_sym wallCollisionsCount.managed
	.addrsig_sym noCollisions.managed
	.addrsig_sym noCollisionsCount.managed
	.addrsig_sym n
	.addrsig_sym l
	.addrsig_sym r
	.addrsig_sym s
	.addrsig_sym particles
	.addrsig_sym particleCollisionTimes
	.addrsig_sym wallCollisionTimes
	.addrsig_sym temp
	.addrsig_sym found
	.addrsig_sym particleCollisions
	.addrsig_sym particleCollisionsCount
	.addrsig_sym wallCollisions
	.addrsig_sym wallCollisionsCount
	.addrsig_sym noCollisions
	.addrsig_sym noCollisionsCount
	.addrsig_sym __hip_cuid_
	.amdgpu_metadata
---
amdhsa.kernels:
  - .args:
      - .offset:         0
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         4
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         8
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         12
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         14
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         16
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         18
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         20
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         22
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         40
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         48
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         56
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         64
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 0
    .kernarg_segment_align: 8
    .kernarg_segment_size: 256
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z21findEarliestCollisionv
    .private_segment_fixed_size: 0
    .sgpr_count:     18
    .sgpr_spill_count: 0
    .symbol:         _Z21findEarliestCollisionv.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     16
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
  - .args:
      - .offset:         0
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         4
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         8
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         12
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         14
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         16
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         18
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         20
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         22
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         40
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         48
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         56
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         64
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 0
    .kernarg_segment_align: 8
    .kernarg_segment_size: 256
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z21timeParticleCollisionv
    .private_segment_fixed_size: 0
    .sgpr_count:     18
    .sgpr_spill_count: 0
    .symbol:         _Z21timeParticleCollisionv.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     91
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
  - .args:
      - .offset:         0
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         4
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         8
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         12
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         14
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         16
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         18
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         20
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         22
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         40
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         48
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         56
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         64
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 0
    .kernarg_segment_align: 8
    .kernarg_segment_size: 256
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z17timeWallCollisionv
    .private_segment_fixed_size: 0
    .sgpr_count:     18
    .sgpr_spill_count: 0
    .symbol:         _Z17timeWallCollisionv.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     17
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
  - .args:
      - .offset:         0
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         4
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         8
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         12
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         14
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         16
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         18
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         20
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         22
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         40
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         48
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         56
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         64
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 0
    .kernarg_segment_align: 8
    .kernarg_segment_size: 256
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z24executeParticleCollisionv
    .private_segment_fixed_size: 0
    .sgpr_count:     18
    .sgpr_spill_count: 0
    .symbol:         _Z24executeParticleCollisionv.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     62
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
  - .args:
      - .offset:         0
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         4
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         8
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         12
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         14
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         16
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         18
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         20
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         22
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         40
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         48
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         56
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         64
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 0
    .kernarg_segment_align: 8
    .kernarg_segment_size: 256
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z20executeWallCollisionv
    .private_segment_fixed_size: 0
    .sgpr_count:     18
    .sgpr_spill_count: 0
    .symbol:         _Z20executeWallCollisionv.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     25
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
  - .args:
      - .offset:         0
        .size:           4
        .value_kind:     hidden_block_count_x
      - .offset:         4
        .size:           4
        .value_kind:     hidden_block_count_y
      - .offset:         8
        .size:           4
        .value_kind:     hidden_block_count_z
      - .offset:         12
        .size:           2
        .value_kind:     hidden_group_size_x
      - .offset:         14
        .size:           2
        .value_kind:     hidden_group_size_y
      - .offset:         16
        .size:           2
        .value_kind:     hidden_group_size_z
      - .offset:         18
        .size:           2
        .value_kind:     hidden_remainder_x
      - .offset:         20
        .size:           2
        .value_kind:     hidden_remainder_y
      - .offset:         22
        .size:           2
        .value_kind:     hidden_remainder_z
      - .offset:         40
        .size:           8
        .value_kind:     hidden_global_offset_x
      - .offset:         48
        .size:           8
        .value_kind:     hidden_global_offset_y
      - .offset:         56
        .size:           8
        .value_kind:     hidden_global_offset_z
      - .offset:         64
        .size:           2
        .value_kind:     hidden_grid_dims
    .group_segment_fixed_size: 0
    .kernarg_segment_align: 8
    .kernarg_segment_size: 256
    .language:       OpenCL C
    .language_version:
      - 2
      - 0
    .max_flat_workgroup_size: 1024
    .name:           _Z18executeNoCollisionv
    .private_segment_fixed_size: 0
    .sgpr_count:     18
    .sgpr_spill_count: 0
    .symbol:         _Z18executeNoCollisionv.kd
    .uniform_work_group_size: 1
    .uses_dynamic_stack: false
    .vgpr_count:     10
    .vgpr_spill_count: 0
    .wavefront_size: 32
    .workgroup_processor_mode: 1
amdhsa.target:   amdgcn-amd-amdhsa--gfx1100
amdhsa.version:
  - 1
  - 2
...

	.end_amdgpu_metadata
