/* Modified for FFTW3          BCJ 05/11/2004  */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#include <tgmath.h>
//#include <fftw3.h>

#define TWOPI 6.2831853071796
#define DFFAC 2.41e-10 /*DM (pc cm-3) = DFFAC*D (MHz) */

/* IHS getchirp routine - adapted by SMO APRIL 4 1999 */
/* revised mk */

void getchirp(float2 *chirp,int nfft,int sideband,double fsky,double bw,double dm,double z4c)
{
  double r,s,f;
  int i;
  double taper;
  //FILE *fp;
  //fp = fopen("chirp.dat","w");
  bw = bw*1e-6;
  printf( "Calculating chirp function.");
  fflush(stdout);
  printf(  "\nnfft: %d flag: %d fsky: %f bw: %f dm: %f \n",nfft,sideband,fsky,bw,dm);
  //s = TWOPI*dm/(DFFAC*(1.0+z4c/10000.0));
  s = TWOPI*dm/(DFFAC);
  
  for(i=0;i<nfft;i++) {
    f = i*bw/(nfft/2);
    
    if(f > bw) 
    {
      f -= bw; 
      f = bw -f;
    } 
    
    //r = ((double) sideband)*f*f*s/((fsky+sideband*f)*fsky*fsky);  
    if(i<=nfft/2) r = -1*f*f*s/((fsky+sideband*f)*fsky*fsky);  
    else r = f*f*s/((fsky+sideband*f)*fsky*fsky);
    
    //if(i%1000==0) printf("%lf \n",(fsky+sideband*f));
    if (f > 0.5*bw) taper = 1.0/sqrt(1.0 + pow((f/(0.94*bw)),80));
    else  taper = 1.0/sqrt(1.0 + pow(((bw-f)/(0.84*bw)),80));
//    taper = 1.0; 
      //taper = 1.0/sqrt(1.0 + pow((f/(0.94*bw)),80));
//    chirp[i] = (double)( cos(r) * taper / (float)(nfft) ) + I *
//              ( -1.0* (double)( sin(r) * taper / (float)(nfft) ));
    chirp[i].x = (float)( cos(r) * taper );
    chirp[i].y = ( -1.0* (float)( sin(r) * taper));
    //chirp[i].x = 0.0;
    //chirp[i].y = 0.0;
    //fprintf(fp,"%1.25f \n",chirp[i].x);
//    chirp[i].re = (float)( cos(r) * taper / (float)(nfft) ); 
//    chirp[i].im = -1.0* (float)( sin(r) * taper / (float)(nfft) );
//    chirp[i].im = sin(r) * taper / (nfft);

  }
//  chirp[0] = 0. + I * 0.;
  chirp[0].x = 0.0;
  chirp[0].y = 0.0;
  //fclose(fp);
//  chirp[0].re = 0.;
//  chirp[0].im = 0.;


}


	.file	"tmpxft_002c523e_00000000-6_getchirp.cudafe1.cpp"
	.text
#APP

#NO_APP
	.type	_ZL26__cudaUnregisterBinaryUtilv, @function
_ZL26__cudaUnregisterBinaryUtilv:
.LFB2030:
	.cfi_startproc
	endbr64
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	jmp	__cudaUnregisterFatBinary@PLT
	.cfi_endproc
.LFE2030:
	.size	_ZL26__cudaUnregisterBinaryUtilv, .-_ZL26__cudaUnregisterBinaryUtilv
	.section	.rodata.str1.1,"aMS",@progbits,1
.LC1:
	.string	"Calculating chirp function."
.LC2:
	.string	"\nnfft: %d flag: %d fsky: %f bw: %f dm: %f \n"
	.text
	.globl	_Z8getchirpP6float2iidddd
	.type	_Z8getchirpP6float2iidddd, @function
_Z8getchirpP6float2iidddd:
.LFB2027:
	.cfi_startproc
	endbr64
	pushq	%r15
	.cfi_def_cfa_offset 16
	.cfi_offset 15, -16
	xorl	%eax, %eax
	pushq	%r14
	.cfi_def_cfa_offset 24
	.cfi_offset 14, -24
	xorl	%r14d, %r14d
	pushq	%r13
	.cfi_def_cfa_offset 32
	.cfi_offset 13, -32
	pushq	%r12
	.cfi_def_cfa_offset 40
	.cfi_offset 12, -40
	movl	%edx, %r12d
	pushq	%rbp
	.cfi_def_cfa_offset 48
	.cfi_offset 6, -48
	movl	%esi, %ebp
	leaq	.LC1(%rip), %rsi
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset 3, -56
	movq	%rdi, %rbx
	movl	$2, %edi
	movl	%ebp, %r13d
	sarl	%r13d
	subq	$56, %rsp
	.cfi_def_cfa_offset 112
	mulsd	.LC0(%rip), %xmm1
	movsd	%xmm0, 8(%rsp)
	movsd	%xmm2, 16(%rsp)
	movsd	%xmm1, (%rsp)
	call	__printf_chk@PLT
	movq	stdout(%rip), %rdi
	call	fflush@PLT
	movsd	16(%rsp), %xmm2
	movl	%r12d, %ecx
	movl	%ebp, %edx
	movsd	(%rsp), %xmm1
	movsd	8(%rsp), %xmm0
	leaq	.LC2(%rip), %rsi
	movb	$3, %al
	movl	$2, %edi
	call	__printf_chk@PLT
	movsd	16(%rsp), %xmm2
	mulsd	.LC3(%rip), %xmm2
	divsd	.LC4(%rip), %xmm2
	movsd	%xmm2, 16(%rsp)
.L3:
	movl	%r14d, %eax
	cmpl	%r14d, %ebp
	jle	.L18
	cvtsi2sdl	%r14d, %xmm1
	mulsd	(%rsp), %xmm1
	cvtsi2sdl	%r13d, %xmm0
	divsd	%xmm0, %xmm1
	comisd	(%rsp), %xmm1
	jbe	.L4
	subsd	(%rsp), %xmm1
	movaps	%xmm1, %xmm0
	movsd	(%rsp), %xmm1
	subsd	%xmm0, %xmm1
.L4:
	cvtsi2sdl	%r12d, %xmm0
	movaps	%xmm1, %xmm2
	mulsd	%xmm1, %xmm0
	addsd	8(%rsp), %xmm0
	mulsd	8(%rsp), %xmm0
	mulsd	8(%rsp), %xmm0
	cmpl	%eax, %r13d
	jl	.L6
	xorps	.LC5(%rip), %xmm2
.L6:
	mulsd	%xmm1, %xmm2
	mulsd	16(%rsp), %xmm2
	divsd	%xmm0, %xmm2
	movsd	(%rsp), %xmm0
	mulsd	.LC6(%rip), %xmm0
	comisd	%xmm0, %xmm1
	movq	%xmm2, %r15
	jbe	.L14
	movsd	(%rsp), %xmm2
	mulsd	.LC8(%rip), %xmm2
	divsd	%xmm2, %xmm1
	movaps	%xmm1, %xmm0
	jmp	.L16
.L14:
	movsd	(%rsp), %xmm0
	subsd	%xmm1, %xmm0
	movsd	(%rsp), %xmm1
	mulsd	.LC10(%rip), %xmm1
	divsd	%xmm1, %xmm0
.L16:
	movsd	.LC7(%rip), %xmm1
	call	pow@PLT
	addsd	.LC9(%rip), %xmm0
	call	sqrt@PLT
	leaq	40(%rsp), %rdi
	leaq	32(%rsp), %rsi
	movsd	.LC9(%rip), %xmm1
	divsd	%xmm0, %xmm1
	movq	%r15, %xmm0
	movsd	%xmm1, 24(%rsp)
	call	sincos@PLT
	movsd	32(%rsp), %xmm0
	movsd	24(%rsp), %xmm1
	mulsd	%xmm1, %xmm0
	mulsd	40(%rsp), %xmm1
	cvtsd2ss	%xmm0, %xmm0
	movss	%xmm0, (%rbx,%r14,8)
	cvtsd2ss	%xmm1, %xmm1
	cvtss2sd	%xmm1, %xmm1
	xorps	.LC5(%rip), %xmm1
	cvtsd2ss	%xmm1, %xmm1
	movss	%xmm1, 4(%rbx,%r14,8)
	incq	%r14
	jmp	.L3
.L18:
	xorl	%eax, %eax
	movq	%rax, (%rbx)
	addq	$56, %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
	ret
	.cfi_endproc
.LFE2027:
	.size	_Z8getchirpP6float2iidddd, .-_Z8getchirpP6float2iidddd
	.section	.text.startup,"ax",@progbits
	.type	_ZL24__sti____cudaRegisterAllv, @function
_ZL24__sti____cudaRegisterAllv:
.LFB2053:
	.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
.LFE2053:
	.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
	.section	.rodata.cst8,"aM",@progbits,8
	.align 8
.LC0:
	.long	-1598689907
	.long	1051772663
	.align 8
.LC3:
	.long	1413754152
	.long	1075388923
	.align 8
.LC4:
	.long	-2103690918
	.long	1039175607
	.section	.rodata.cst16,"aM",@progbits,16
	.align 16
.LC5:
	.long	0
	.long	-2147483648
	.long	0
	.long	0
	.section	.rodata.cst8
	.align 8
.LC6:
	.long	0
	.long	1071644672
	.align 8
.LC7:
	.long	0
	.long	1079246848
	.align 8
.LC8:
	.long	-515396076
	.long	1072567418
	.align 8
.LC9:
	.long	0
	.long	1072693248
	.align 8
.LC10:
	.long	-1374389535
	.long	1072357703
	.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:

/* Modified for FFTW3          BCJ 05/11/2004  */

#include <hip/hip_runtime.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//#include <tgmath.h>
//#include <fftw3.h>

#define TWOPI 6.2831853071796
#define DFFAC 2.41e-10 /*DM (pc cm-3) = DFFAC*D (MHz) */

/* IHS getchirp routine - adapted by SMO APRIL 4 1999 */
/* revised mk */

void getchirp(float2 *chirp,int nfft,int sideband,double fsky,double bw,double dm,double z4c)
{
  double r,s,f;
  int i;
  double taper;
  //FILE *fp;
  //fp = fopen("chirp.dat","w");
  bw = bw*1e-6;
  printf( "Calculating chirp function.");
  fflush(stdout);
  printf(  "\nnfft: %d flag: %d fsky: %f bw: %f dm: %f \n",nfft,sideband,fsky,bw,dm);
  //s = TWOPI*dm/(DFFAC*(1.0+z4c/10000.0));
  s = TWOPI*dm/(DFFAC);
  
  for(i=0;i<nfft;i++) {
    f = i*bw/(nfft/2);
    
    if(f > bw) 
    {
      f -= bw; 
      f = bw -f;
    } 
    
    //r = ((double) sideband)*f*f*s/((fsky+sideband*f)*fsky*fsky);  
    if(i<=nfft/2) r = -1*f*f*s/((fsky+sideband*f)*fsky*fsky);  
    else r = f*f*s/((fsky+sideband*f)*fsky*fsky);
    
    //if(i%1000==0) printf("%lf \n",(fsky+sideband*f));
    if (f > 0.5*bw) taper = 1.0/sqrt(1.0 + pow((f/(0.94*bw)),80));
    else  taper = 1.0/sqrt(1.0 + pow(((bw-f)/(0.84*bw)),80));
//    taper = 1.0; 
      //taper = 1.0/sqrt(1.0 + pow((f/(0.94*bw)),80));
//    chirp[i] = (double)( cos(r) * taper / (float)(nfft) ) + I *
//              ( -1.0* (double)( sin(r) * taper / (float)(nfft) ));
    chirp[i].x = (float)( cos(r) * taper );
    chirp[i].y = ( -1.0* (float)( sin(r) * taper));
    //chirp[i].x = 0.0;
    //chirp[i].y = 0.0;
    //fprintf(fp,"%1.25f \n",chirp[i].x);
//    chirp[i].re = (float)( cos(r) * taper / (float)(nfft) ); 
//    chirp[i].im = -1.0* (float)( sin(r) * taper / (float)(nfft) );
//    chirp[i].im = sin(r) * taper / (nfft);

  }
//  chirp[0] = 0. + I * 0.;
  chirp[0].x = 0.0;
  chirp[0].y = 0.0;
  //fclose(fp);
//  chirp[0].re = 0.;
//  chirp[0].im = 0.;


}


	.text
	.file	"getchirp.hip"
	.section	.rodata.cst8,"aM",@progbits,8
	.p2align	3, 0x0                          # -- Begin function _Z8getchirpP15HIP_vector_typeIfLj2EEiidddd
.LCPI0_0:
	.quad	0x3eb0c6f7a0b5ed8d              # double 9.9999999999999995E-7
.LCPI0_1:
	.quad	0x401921fb54442d28              # double 6.2831853071796004
.LCPI0_2:
	.quad	0x3df08fb7829c395a              # double 2.4099999999999999E-10
.LCPI0_3:
	.quad	0x3fe0000000000000              # double 0.5
.LCPI0_4:
	.quad	0x3feae147ae147ae1              # double 0.83999999999999997
.LCPI0_5:
	.quad	0x3fee147ae147ae14              # double 0.93999999999999994
.LCPI0_7:
	.quad	0x4054000000000000              # double 80
.LCPI0_8:
	.quad	0x3ff0000000000000              # double 1
.LCPI0_10:
	.quad	0x0000000000000000              # double 0
	.section	.rodata.cst16,"aM",@progbits,16
	.p2align	4, 0x0
.LCPI0_6:
	.quad	0x8000000000000000              # double -0
	.quad	0x8000000000000000              # double -0
.LCPI0_9:
	.long	0x80000000                      # float -0
	.long	0x80000000                      # float -0
	.long	0x80000000                      # float -0
	.long	0x80000000                      # float -0
	.text
	.globl	_Z8getchirpP15HIP_vector_typeIfLj2EEiidddd
	.type	_Z8getchirpP15HIP_vector_typeIfLj2EEiidddd,@function
_Z8getchirpP15HIP_vector_typeIfLj2EEiidddd: # @_Z8getchirpP15HIP_vector_typeIfLj2EEiidddd
	.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	$112, %rsp
	.cfi_def_cfa_offset 160
	.cfi_offset %rbx, -48
	.cfi_offset %r12, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movsd	%xmm2, 8(%rsp)                  # 8-byte Spill
	movsd	%xmm0, 24(%rsp)                 # 8-byte Spill
	movl	%edx, %ebp
	movl	%esi, %r14d
	movq	%rdi, %rbx
	mulsd	.LCPI0_0(%rip), %xmm1
	movsd	%xmm1, 16(%rsp)                 # 8-byte Spill
	movl	$.L.str, %edi
	xorl	%eax, %eax
	callq	printf
	movq	stdout(%rip), %rdi
	callq	fflush
	movl	$.L.str.1, %edi
	movl	%r14d, %esi
	movl	%ebp, %edx
	movsd	24(%rsp), %xmm0                 # 8-byte Reload
                                        # xmm0 = mem[0],zero
	movsd	16(%rsp), %xmm1                 # 8-byte Reload
                                        # xmm1 = mem[0],zero
	movsd	8(%rsp), %xmm2                  # 8-byte Reload
                                        # xmm2 = mem[0],zero
	movb	$3, %al
	callq	printf
	testl	%r14d, %r14d
	jle	.LBB0_9
# %bb.1:                                # %.lr.ph
	movsd	8(%rsp), %xmm0                  # 8-byte Reload
                                        # xmm0 = mem[0],zero
	mulsd	.LCPI0_1(%rip), %xmm0
	divsd	.LCPI0_2(%rip), %xmm0
	movsd	%xmm0, 8(%rsp)                  # 8-byte Spill
	movl	%r14d, %r15d
	shrl	%r14d
	xorps	%xmm0, %xmm0
	cvtsi2sd	%r14d, %xmm0
	movsd	%xmm0, 104(%rsp)                # 8-byte Spill
	xorps	%xmm0, %xmm0
	cvtsi2sd	%ebp, %xmm0
	movsd	%xmm0, 96(%rsp)                 # 8-byte Spill
	movsd	.LCPI0_3(%rip), %xmm1           # xmm1 = mem[0],zero
	movsd	16(%rsp), %xmm0                 # 8-byte Reload
                                        # xmm0 = mem[0],zero
	mulsd	%xmm0, %xmm1
	movsd	%xmm1, 88(%rsp)                 # 8-byte Spill
	movsd	.LCPI0_4(%rip), %xmm1           # xmm1 = mem[0],zero
	mulsd	%xmm0, %xmm1
	movsd	%xmm1, 80(%rsp)                 # 8-byte Spill
	movsd	.LCPI0_5(%rip), %xmm1           # xmm1 = mem[0],zero
	mulsd	%xmm0, %xmm1
	movsd	%xmm1, 72(%rsp)                 # 8-byte Spill
	xorl	%r12d, %r12d
.LBB0_2:                                # =>This Inner Loop Header: Depth=1
	xorps	%xmm0, %xmm0
	cvtsi2sd	%r12d, %xmm0
	movsd	16(%rsp), %xmm2                 # 8-byte Reload
                                        # xmm2 = mem[0],zero
	mulsd	%xmm2, %xmm0
	divsd	104(%rsp), %xmm0                # 8-byte Folded Reload
	movapd	%xmm2, %xmm3
	cmpltsd	%xmm0, %xmm3
	movapd	%xmm3, %xmm1
	andnpd	%xmm0, %xmm1
	subsd	%xmm2, %xmm0
	subsd	%xmm0, %xmm2
	andpd	%xmm2, %xmm3
	orpd	%xmm1, %xmm3
	cmpq	%r14, %r12
	ja	.LBB0_3
# %bb.4:                                #   in Loop: Header=BB0_2 Depth=1
	movapd	%xmm3, %xmm0
	xorpd	.LCPI0_6(%rip), %xmm0
	movapd	%xmm0, 48(%rsp)                 # 16-byte Spill
	jmp	.LBB0_5
.LBB0_3:                                #   in Loop: Header=BB0_2 Depth=1
	movapd	%xmm3, 48(%rsp)                 # 16-byte Spill
.LBB0_5:                                #   in Loop: Header=BB0_2 Depth=1
	movsd	16(%rsp), %xmm1                 # 8-byte Reload
                                        # xmm1 = mem[0],zero
	subsd	%xmm3, %xmm1
	divsd	80(%rsp), %xmm1                 # 8-byte Folded Reload
	movapd	%xmm3, %xmm2
	divsd	72(%rsp), %xmm2                 # 8-byte Folded Reload
	movsd	88(%rsp), %xmm0                 # 8-byte Reload
                                        # xmm0 = mem[0],zero
	movapd	%xmm3, 32(%rsp)                 # 16-byte Spill
	cmpltsd	%xmm3, %xmm0
	andpd	%xmm0, %xmm2
	andnpd	%xmm1, %xmm0
	orpd	%xmm2, %xmm0
	movsd	.LCPI0_7(%rip), %xmm1           # xmm1 = mem[0],zero
	callq	pow
	addsd	.LCPI0_8(%rip), %xmm0
	ucomisd	.LCPI0_10(%rip), %xmm0
	jb	.LBB0_7
# %bb.6:                                #   in Loop: Header=BB0_2 Depth=1
	sqrtsd	%xmm0, %xmm0
	jmp	.LBB0_8
.LBB0_7:                                # %call.sqrt
                                        #   in Loop: Header=BB0_2 Depth=1
	callq	sqrt
.LBB0_8:                                # %.split
                                        #   in Loop: Header=BB0_2 Depth=1
	movapd	32(%rsp), %xmm2                 # 16-byte Reload
	movapd	48(%rsp), %xmm3                 # 16-byte Reload
	mulsd	%xmm2, %xmm3
	mulsd	8(%rsp), %xmm3                  # 8-byte Folded Reload
	mulsd	96(%rsp), %xmm2                 # 8-byte Folded Reload
	movsd	24(%rsp), %xmm1                 # 8-byte Reload
                                        # xmm1 = mem[0],zero
	addsd	%xmm1, %xmm2
	mulsd	%xmm1, %xmm2
	mulsd	%xmm1, %xmm2
	divsd	%xmm2, %xmm3
	movapd	%xmm3, 48(%rsp)                 # 16-byte Spill
	movsd	.LCPI0_8(%rip), %xmm1           # xmm1 = mem[0],zero
	divsd	%xmm0, %xmm1
	movsd	%xmm1, 32(%rsp)                 # 8-byte Spill
	movapd	%xmm3, %xmm0
	callq	cos
	mulsd	32(%rsp), %xmm0                 # 8-byte Folded Reload
	cvtsd2ss	%xmm0, %xmm0
	movss	%xmm0, (%rbx,%r12,8)
	movapd	48(%rsp), %xmm0                 # 16-byte Reload
	callq	sin
	mulsd	32(%rsp), %xmm0                 # 8-byte Folded Reload
	cvtsd2ss	%xmm0, %xmm0
	xorps	.LCPI0_9(%rip), %xmm0
	movss	%xmm0, 4(%rbx,%r12,8)
	incq	%r12
	cmpq	%r12, %r15
	jne	.LBB0_2
.LBB0_9:                                # %._crit_edge
	movq	$0, (%rbx)
	addq	$112, %rsp
	.cfi_def_cfa_offset 48
	popq	%rbx
	.cfi_def_cfa_offset 40
	popq	%r12
	.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
.Lfunc_end0:
	.size	_Z8getchirpP15HIP_vector_typeIfLj2EEiidddd, .Lfunc_end0-_Z8getchirpP15HIP_vector_typeIfLj2EEiidddd
	.cfi_endproc
                                        # -- End function
	.type	.L.str,@object                  # @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"Calculating chirp function."
	.size	.L.str, 28

	.type	.L.str.1,@object                # @.str.1
.L.str.1:
	.asciz	"\nnfft: %d flag: %d fsky: %f bw: %f dm: %f \n"
	.size	.L.str.1, 44

	.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 __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
