// std::system includes
#include <memory>
#include <iostream>
#include <stdio.h>
#include <time.h>

// CUDA-C includes
#include <cuda.h>
#include <cuda_runtime.h>

//#include <helper_cuda.h>

////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char** argv)
{
	printf("test\n");
	const int num_vert = 629;
	char const* const inputFile = argv[1];
	FILE* file = fopen(inputFile, "r");
	int vert_x[num_vert];
	int vert_y[num_vert];
	printf("test\n");
	
	char line[256];
	int i = 0;
	while (fgets(line, sizeof(line), file) != NULL) {
		sscanf(line, "%d %d", &vert_x[i], &vert_y[i]);
		++i;
	}
	fclose(file);
	printf("test\n");


	//Sanity check for read:
	srand(time(NULL));
	int rand_i = rand() % num_vert;
	printf("Coordinates on random index %d are (%d,%d)\n", rand_i, vert_x[rand_i], vert_y[rand_i]);
	printf("Coordinates on first index are (%d,%d)\n", vert_x[0], vert_y[0]);
	printf("Coordinates on last index are (%d,%d)\n", vert_x[num_vert - 1], vert_y[num_vert - 1]);

	int deviceCount = 0;
	cudaError_t error_id = cudaGetDeviceCount(&deviceCount);

	if (error_id != cudaSuccess)
	{
		printf("cudaGetDeviceCount returned %d\n-> %s\n", (int)error_id, cudaGetErrorString(error_id));
		printf("Result = FAIL\n");
		exit(EXIT_FAILURE);
	}

	// This function call returns 0 if there are no CUDA capable devices.
	if (deviceCount == 0)
	{
		printf("There are no available device(s) that support CUDA\n");
	}
	else
	{
		printf("Detected %d CUDA Capable device(s)\n", deviceCount);
	}

	for (int dev = 0; dev < deviceCount; ++dev)
	{
		cudaSetDevice(dev);
		cudaDeviceProp deviceProp;



		cudaGetDeviceProperties(&deviceProp, dev);

		printf("\nDevice %d: %s \n", dev, deviceProp.name);
		printf("\nMaxThreadsPerBlock: %d \n", deviceProp.maxThreadsPerBlock);
		printf("\nMaxThreadDim (%d,%d,%d)  \n", deviceProp.maxThreadsDim[0], deviceProp.maxThreadsDim[1], deviceProp.maxThreadsDim[2]);
		printf("\nMaxGridSize (%d,%d,%d)  \n", deviceProp.maxGridSize[0], deviceProp.maxGridSize[1], deviceProp.maxGridSize[2]);

	}

	// finish
	// cudaDeviceReset causes the driver to clean up all state. While 
	// not mandatory in normal operation, it is good practice.  It is also
	// needed to ensure correct operation when the application is being
	// profiled. Calling cudaDeviceReset causes all profile data to be
	// flushed before the application exits
	cudaDeviceReset();

	char ch;
	std::cin >> ch;

	exit(EXIT_SUCCESS);
}
	.file	"tmpxft_0021d83a_00000000-6_circle.cudafe1.cpp"
	.text
#APP
	.globl _ZSt21ios_base_library_initv

#NO_APP
	.type	_ZL26__cudaUnregisterBinaryUtilv, @function
_ZL26__cudaUnregisterBinaryUtilv:
.LFB4282:
	.cfi_startproc
	endbr64
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	jmp	__cudaUnregisterFatBinary@PLT
	.cfi_endproc
.LFE4282:
	.size	_ZL26__cudaUnregisterBinaryUtilv, .-_ZL26__cudaUnregisterBinaryUtilv
	.section	.rodata.str1.1,"aMS",@progbits,1
.LC0:
	.string	"test\n"
.LC1:
	.string	"r"
.LC2:
	.string	"%d %d"
.LC3:
	.string	"Coordinates on random index %d are (%d,%d)\n"
.LC4:
	.string	"Coordinates on first index are (%d,%d)\n"
.LC5:
	.string	"Coordinates on last index are (%d,%d)\n"
.LC6:
	.string	"cudaGetDeviceCount returned %d\n-> %s\n"
.LC7:
	.string	"Result = FAIL\n"
.LC8:
	.string	"There are no available device(s) that support CUDA\n"
.LC9:
	.string	"Detected %d CUDA Capable device(s)\n"
.LC10:
	.string	"\nDevice %d: %s \n"
.LC11:
	.string	"\nMaxThreadsPerBlock: %d \n"
.LC12:
	.string	"\nMaxThreadDim (%d,%d,%d)  \n"
.LC13:
	.string	"\nMaxGridSize (%d,%d,%d)  \n"
	.section	.text.startup,"ax",@progbits
	.globl	main
	.type	main, @function
main:
.LFB4279:
	.cfi_startproc
	endbr64
	pushq	%r14
	.cfi_def_cfa_offset 16
	.cfi_offset 14, -16
	pushq	%r13
	.cfi_def_cfa_offset 24
	.cfi_offset 13, -24
	pushq	%r12
	.cfi_def_cfa_offset 32
	.cfi_offset 12, -32
	pushq	%rbp
	.cfi_def_cfa_offset 40
	.cfi_offset 6, -40
	pushq	%rbx
	.cfi_def_cfa_offset 48
	.cfi_offset 3, -48
	subq	$4096, %rsp
	.cfi_def_cfa_offset 4144
	orq	$0, (%rsp)
	subq	$2240, %rsp
	.cfi_def_cfa_offset 6384
	leaq	.LC0(%rip), %r12
	movl	$2, %edi
	xorl	%ebp, %ebp
	leaq	.LC2(%rip), %r14
	movq	%fs:40, %rax
	movq	%rax, 6328(%rsp)
	xorl	%eax, %eax
	movq	%rsi, %rbx
	movq	%r12, %rsi
	call	__printf_chk@PLT
	movq	8(%rbx), %rdi
	leaq	.LC1(%rip), %rsi
	call	fopen@PLT
	movq	%r12, %rsi
	movl	$2, %edi
	movq	%rax, %rbx
	xorl	%eax, %eax
	call	__printf_chk@PLT
.L3:
	leaq	6072(%rsp), %r13
	movq	%rbx, %rcx
	movl	$256, %edx
	movl	$256, %esi
	movq	%r13, %rdi
	call	__fgets_chk@PLT
	testq	%rax, %rax
	je	.L14
	leaq	3556(%rsp,%rbp), %rcx
	movq	%r14, %rsi
	movq	%r13, %rdi
	xorl	%eax, %eax
	leaq	1040(%rsp,%rbp), %rdx
	addq	$4, %rbp
	call	__isoc23_sscanf@PLT
	jmp	.L3
.L14:
	movq	%rbx, %rdi
	call	fclose@PLT
	movq	%r12, %rsi
	movl	$2, %edi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	xorl	%edi, %edi
	call	time@PLT
	movl	%eax, %edi
	call	srand@PLT
	call	rand@PLT
	movl	$629, %ecx
	movl	$2, %edi
	leaq	.LC3(%rip), %rsi
	cltd
	idivl	%ecx
	movslq	%edx, %rax
	movl	3556(%rsp,%rax,4), %r8d
	movl	1040(%rsp,%rax,4), %ecx
	xorl	%eax, %eax
	call	__printf_chk@PLT
	movl	3556(%rsp), %ecx
	movl	$2, %edi
	xorl	%eax, %eax
	movl	1040(%rsp), %edx
	leaq	.LC4(%rip), %rsi
	call	__printf_chk@PLT
	movl	6068(%rsp), %ecx
	movl	$2, %edi
	xorl	%eax, %eax
	movl	3552(%rsp), %edx
	leaq	.LC5(%rip), %rsi
	call	__printf_chk@PLT
	xorl	%eax, %eax
	leaq	4(%rsp), %rdi
	movl	%eax, 4(%rsp)
	call	cudaGetDeviceCount@PLT
	movl	%eax, %ebx
	testl	%eax, %eax
	je	.L5
	movl	%eax, %edi
	call	cudaGetErrorString@PLT
	movl	%ebx, %edx
	movl	$2, %edi
	leaq	.LC6(%rip), %rsi
	movq	%rax, %rcx
	xorl	%eax, %eax
	call	__printf_chk@PLT
	movl	$2, %edi
	leaq	.LC7(%rip), %rsi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	movl	$1, %edi
	jmp	.L12
.L5:
	movl	4(%rsp), %edx
	testl	%edx, %edx
	jne	.L6
	leaq	.LC8(%rip), %rsi
	movl	$2, %edi
	xorl	%eax, %eax
	call	__printf_chk@PLT
.L8:
	xorl	%ebx, %ebx
	leaq	.LC10(%rip), %r12
	jmp	.L7
.L6:
	leaq	.LC9(%rip), %rsi
	movl	$2, %edi
	xorl	%eax, %eax
	call	__printf_chk@PLT
	jmp	.L8
.L7:
	cmpl	%ebx, 4(%rsp)
	jle	.L15
	movl	%ebx, %edi
	leaq	8(%rsp), %rbp
	call	cudaSetDevice@PLT
	movl	%ebx, %esi
	movq	%rbp, %rdi
	call	cudaGetDeviceProperties_v2@PLT
	movq	%rbp, %rcx
	movl	%ebx, %edx
	movq	%r12, %rsi
	movl	$2, %edi
	xorl	%eax, %eax
	incl	%ebx
	call	__printf_chk@PLT
	movl	328(%rsp), %edx
	leaq	.LC11(%rip), %rsi
	xorl	%eax, %eax
	movl	$2, %edi
	call	__printf_chk@PLT
	movl	340(%rsp), %r8d
	xorl	%eax, %eax
	movl	336(%rsp), %ecx
	movl	332(%rsp), %edx
	leaq	.LC12(%rip), %rsi
	movl	$2, %edi
	call	__printf_chk@PLT
	movl	352(%rsp), %r8d
	xorl	%eax, %eax
	movl	348(%rsp), %ecx
	movl	344(%rsp), %edx
	leaq	.LC13(%rip), %rsi
	movl	$2, %edi
	call	__printf_chk@PLT
	jmp	.L7
.L15:
	call	cudaDeviceReset@PLT
	leaq	_ZSt3cin(%rip), %rdi
	leaq	3(%rsp), %rsi
	call	_ZStrsIcSt11char_traitsIcEERSt13basic_istreamIT_T0_ES6_RS3_@PLT
	xorl	%edi, %edi
.L12:
	call	exit@PLT
	.cfi_endproc
.LFE4279:
	.size	main, .-main
	.type	_ZL24__sti____cudaRegisterAllv, @function
_ZL24__sti____cudaRegisterAllv:
.LFB4305:
	.cfi_startproc
	endbr64
	pushq	%rax
	.cfi_def_cfa_offset 16
	leaq	_ZL15__fatDeviceText(%rip), %rdi
	call	__cudaRegisterFatBinary@PLT
	movq	%rax, %rdi
	movq	%rax, _ZL20__cudaFatCubinHandle(%rip)
	call	__cudaRegisterFatBinaryEnd@PLT
	leaq	_ZL26__cudaUnregisterBinaryUtilv(%rip), %rdi
	popq	%rdx
	.cfi_def_cfa_offset 8
	jmp	atexit@PLT
	.cfi_endproc
.LFE4305:
	.size	_ZL24__sti____cudaRegisterAllv, .-_ZL24__sti____cudaRegisterAllv
	.section	.init_array,"aw"
	.align 8
	.quad	_ZL24__sti____cudaRegisterAllv
	.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
	.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:

// std::system includes
#include <memory>
#include <iostream>
#include <stdio.h>
#include <time.h>

// CUDA-C includes
#include <hip/hip_runtime.h>


//#include <helper_cuda.h>

////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char** argv)
{
	printf("test\n");
	const int num_vert = 629;
	char const* const inputFile = argv[1];
	FILE* file = fopen(inputFile, "r");
	int vert_x[num_vert];
	int vert_y[num_vert];
	printf("test\n");
	
	char line[256];
	int i = 0;
	while (fgets(line, sizeof(line), file) != NULL) {
		sscanf(line, "%d %d", &vert_x[i], &vert_y[i]);
		++i;
	}
	fclose(file);
	printf("test\n");


	//Sanity check for read:
	srand(time(NULL));
	int rand_i = rand() % num_vert;
	printf("Coordinates on random index %d are (%d,%d)\n", rand_i, vert_x[rand_i], vert_y[rand_i]);
	printf("Coordinates on first index are (%d,%d)\n", vert_x[0], vert_y[0]);
	printf("Coordinates on last index are (%d,%d)\n", vert_x[num_vert - 1], vert_y[num_vert - 1]);

	int deviceCount = 0;
	hipError_t error_id = hipGetDeviceCount(&deviceCount);

	if (error_id != hipSuccess)
	{
		printf("hipGetDeviceCount returned %d\n-> %s\n", (int)error_id, hipGetErrorString(error_id));
		printf("Result = FAIL\n");
		exit(EXIT_FAILURE);
	}

	// This function call returns 0 if there are no CUDA capable devices.
	if (deviceCount == 0)
	{
		printf("There are no available device(s) that support CUDA\n");
	}
	else
	{
		printf("Detected %d CUDA Capable device(s)\n", deviceCount);
	}

	for (int dev = 0; dev < deviceCount; ++dev)
	{
		hipSetDevice(dev);
		hipDeviceProp_t deviceProp;



		hipGetDeviceProperties(&deviceProp, dev);

		printf("\nDevice %d: %s \n", dev, deviceProp.name);
		printf("\nMaxThreadsPerBlock: %d \n", deviceProp.maxThreadsPerBlock);
		printf("\nMaxThreadDim (%d,%d,%d)  \n", deviceProp.maxThreadsDim[0], deviceProp.maxThreadsDim[1], deviceProp.maxThreadsDim[2]);
		printf("\nMaxGridSize (%d,%d,%d)  \n", deviceProp.maxGridSize[0], deviceProp.maxGridSize[1], deviceProp.maxGridSize[2]);

	}

	// finish
	// cudaDeviceReset causes the driver to clean up all state. While 
	// not mandatory in normal operation, it is good practice.  It is also
	// needed to ensure correct operation when the application is being
	// profiled. Calling cudaDeviceReset causes all profile data to be
	// flushed before the application exits
	hipDeviceReset();

	char ch;
	std::cin >> ch;

	exit(EXIT_SUCCESS);
}
	.text
	.file	"circle.hip"
                                        # Start of file scope inline assembly
	.globl	_ZSt21ios_base_library_initv

                                        # End of file scope inline assembly
	.globl	main                            # -- Begin function main
	.type	main,@function
main:                                   # @main
	.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	%r12
	.cfi_def_cfa_offset 40
	pushq	%rbx
	.cfi_def_cfa_offset 48
	subq	$6800, %rsp                     # imm = 0x1A90
	.cfi_def_cfa_offset 6848
	.cfi_offset %rbx, -48
	.cfi_offset %r12, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	%rsi, %rbx
	movl	$.Lstr.2, %edi
	callq	puts@PLT
	movq	8(%rbx), %rdi
	movl	$.L.str.1, %esi
	callq	fopen
	movq	%rax, %rbx
	movl	$.Lstr.2, %edi
	callq	puts@PLT
	leaq	16(%rsp), %rdi
	movl	$256, %esi                      # imm = 0x100
	movq	%rbx, %rdx
	callq	fgets
	testq	%rax, %rax
	je	.LBB0_3
# %bb.1:                                # %.lr.ph.preheader
	leaq	1744(%rsp), %r14
	leaq	4272(%rsp), %r15
	leaq	16(%rsp), %r12
.LBB0_2:                                # %.lr.ph
                                        # =>This Inner Loop Header: Depth=1
	movl	$.L.str.2, %esi
	movq	%r12, %rdi
	movq	%r15, %rdx
	movq	%r14, %rcx
	xorl	%eax, %eax
	callq	__isoc23_sscanf
	movq	%r12, %rdi
	movl	$256, %esi                      # imm = 0x100
	movq	%rbx, %rdx
	callq	fgets
	addq	$4, %r14
	addq	$4, %r15
	testq	%rax, %rax
	jne	.LBB0_2
.LBB0_3:                                # %._crit_edge
	movq	%rbx, %rdi
	callq	fclose
	movl	$.Lstr.2, %edi
	callq	puts@PLT
	xorl	%edi, %edi
	callq	time
	movl	%eax, %edi
	callq	srand
	callq	rand
	cltq
	imulq	$1748031205, %rax, %rcx         # imm = 0x6830D6E5
	movq	%rcx, %rdx
	shrq	$63, %rdx
	sarq	$40, %rcx
	addl	%edx, %ecx
	imull	$629, %ecx, %ecx                # imm = 0x275
	subl	%ecx, %eax
	movslq	%eax, %rsi
	movl	4272(%rsp,%rsi,4), %edx
	movl	1744(%rsp,%rsi,4), %ecx
	movl	$.L.str.3, %edi
                                        # kill: def $esi killed $esi killed $rsi
	xorl	%eax, %eax
	callq	printf
	movl	4272(%rsp), %esi
	movl	1744(%rsp), %edx
	movl	$.L.str.4, %edi
	xorl	%eax, %eax
	callq	printf
	movl	6784(%rsp), %esi
	movl	4256(%rsp), %edx
	movl	$.L.str.5, %edi
	xorl	%eax, %eax
	callq	printf
	leaq	12(%rsp), %rdi
	movl	$0, (%rdi)
	callq	hipGetDeviceCount
	testl	%eax, %eax
	jne	.LBB0_11
# %bb.4:
	movl	12(%rsp), %esi
	testl	%esi, %esi
	jne	.LBB0_6
# %bb.5:
	movl	$.Lstr.3, %edi
	callq	puts@PLT
	jmp	.LBB0_7
.LBB0_11:
	movl	%eax, %ebx
	movl	%eax, %edi
	callq	hipGetErrorString
	movl	$.L.str.6, %edi
	movl	%ebx, %esi
	movq	%rax, %rdx
	xorl	%eax, %eax
	callq	printf
	movl	$.Lstr.4, %edi
	callq	puts@PLT
	movl	$1, %edi
	callq	exit
.LBB0_6:
	movl	$.L.str.9, %edi
	xorl	%eax, %eax
	callq	printf
.LBB0_7:
	cmpl	$0, 12(%rsp)
	jle	.LBB0_10
# %bb.8:                                # %.lr.ph29
	leaq	272(%rsp), %rbx
	xorl	%ebp, %ebp
.LBB0_9:                                # =>This Inner Loop Header: Depth=1
	movl	%ebp, %edi
	callq	hipSetDevice
	movq	%rbx, %rdi
	movl	%ebp, %esi
	callq	hipGetDevicePropertiesR0600
	movl	$.L.str.10, %edi
	movl	%ebp, %esi
	movq	%rbx, %rdx
	xorl	%eax, %eax
	callq	printf
	movl	592(%rsp), %esi
	movl	$.L.str.11, %edi
	xorl	%eax, %eax
	callq	printf
	movl	596(%rsp), %esi
	movl	600(%rsp), %edx
	movl	604(%rsp), %ecx
	movl	$.L.str.12, %edi
	xorl	%eax, %eax
	callq	printf
	movl	608(%rsp), %esi
	movl	612(%rsp), %edx
	movl	616(%rsp), %ecx
	movl	$.L.str.13, %edi
	xorl	%eax, %eax
	callq	printf
	incl	%ebp
	cmpl	12(%rsp), %ebp
	jl	.LBB0_9
.LBB0_10:                               # %._crit_edge30
	callq	hipDeviceReset
	leaq	272(%rsp), %rsi
	movl	$_ZSt3cin, %edi
	callq	_ZStrsIcSt11char_traitsIcEERSt13basic_istreamIT_T0_ES6_RS3_
	xorl	%edi, %edi
	callq	exit
.Lfunc_end0:
	.size	main, .Lfunc_end0-main
	.cfi_endproc
                                        # -- End function
	.type	.L.str.1,@object                # @.str.1
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.1:
	.asciz	"r"
	.size	.L.str.1, 2

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

	.type	.L.str.3,@object                # @.str.3
.L.str.3:
	.asciz	"Coordinates on random index %d are (%d,%d)\n"
	.size	.L.str.3, 44

	.type	.L.str.4,@object                # @.str.4
.L.str.4:
	.asciz	"Coordinates on first index are (%d,%d)\n"
	.size	.L.str.4, 40

	.type	.L.str.5,@object                # @.str.5
.L.str.5:
	.asciz	"Coordinates on last index are (%d,%d)\n"
	.size	.L.str.5, 39

	.type	.L.str.6,@object                # @.str.6
.L.str.6:
	.asciz	"hipGetDeviceCount returned %d\n-> %s\n"
	.size	.L.str.6, 37

	.type	.L.str.9,@object                # @.str.9
.L.str.9:
	.asciz	"Detected %d CUDA Capable device(s)\n"
	.size	.L.str.9, 36

	.type	.L.str.10,@object               # @.str.10
.L.str.10:
	.asciz	"\nDevice %d: %s \n"
	.size	.L.str.10, 17

	.type	.L.str.11,@object               # @.str.11
.L.str.11:
	.asciz	"\nMaxThreadsPerBlock: %d \n"
	.size	.L.str.11, 26

	.type	.L.str.12,@object               # @.str.12
.L.str.12:
	.asciz	"\nMaxThreadDim (%d,%d,%d)  \n"
	.size	.L.str.12, 28

	.type	.L.str.13,@object               # @.str.13
.L.str.13:
	.asciz	"\nMaxGridSize (%d,%d,%d)  \n"
	.size	.L.str.13, 27

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

	.type	.Lstr.2,@object                 # @str.2
	.section	.rodata.str1.1,"aMS",@progbits,1
.Lstr.2:
	.asciz	"test"
	.size	.Lstr.2, 5

	.type	.Lstr.3,@object                 # @str.3
.Lstr.3:
	.asciz	"There are no available device(s) that support CUDA"
	.size	.Lstr.3, 51

	.type	.Lstr.4,@object                 # @str.4
.Lstr.4:
	.asciz	"Result = FAIL"
	.size	.Lstr.4, 14

	.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 _ZSt3cin
	.addrsig_sym __hip_cuid_

	.text
	.p2alignl 7, 3214868480
	.fill 96, 4, 3214868480
	.type	__hip_cuid_,@object             ; @__hip_cuid_
	.section	.bss,"aw",@nobits
	.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 __hip_cuid_
	.amdgcn_target "amdgcn-amd-amdhsa--gfx1100"
	.amdgpu_metadata
---
amdhsa.kernels:  []
amdhsa.target:   amdgcn-amd-amdhsa--gfx1100
amdhsa.version:
  - 1
  - 2
...

	.end_amdgpu_metadata
