//host処理系のグローバル変数定義
#ifndef INCLUDED_HOSTVALUESACCESSER
#define INCLUDED_HOSTVALUESACCESSER
#include <stdio.h>

int cnnOutputNumsNums;
int *cnnOutputNums;

int execFlg;
int execFlgTraining = 0;
int execFlgOnline = 1;

int sv_xNums;
int sv_yNums;
int svChannelNums;
int miniBatchNums;

float *cnnBnBeta;
float *cnnBnGamma;
float bnEps;

int cnnW_xNums;
int cnnW_yNums;
int cnnWDataNums;
float *cnnW;

int *cnnWba_xNums;
int *cnnWba_yNums;

int *cnnP_xNums;
int *cnnP_yNums;

int cnnPooling_xNums;
int cnnPooling_yNums;

int mlpOutputNumsNums;
int *mlpOutputNums;

float *mlpBnBeta;
float *mlpBnGamma;
int mlpWDataNums;
float *mlpW;

float *teachOut;
float *result;

float learningRate;

float E = 0;

extern __device__ __host__ int getDim2Idx(int x, int y, int X);
extern __device__ __host__ int getDim4Idx(int x, int y, int z, int a, int X, int Y, int Z);
extern int getCnnInputIdxNums(int cnnLayer);
extern int getMlpInputIdxNums(int cnnLayer);
extern int getMlpOutputNumsNums();
extern int getMlpOutputNums(int mlpLayer);
extern int getCnnWba_xNums(int cnnLayer);
extern int getCnnWba_yNums(int cnnLayer);
extern int getHMlpWbaIdx(int outputIdx, int miniBatchIdx, int mlpLayer);
extern int getHCnnWbaIdx(int x, int y, int outputIdx, int miniBatchIdx, int cnnLayer);

void setExecFlg(int execFlg_arg){
	execFlg = execFlg_arg;
}
int getExecFlg(){
	return(execFlg);
}
int getExecFlgTraining(){
	return(execFlgTraining);
}
int getExecFlgOnline(){
	return(execFlgOnline);
}
void setSv_xNums(int sv_xNums_arg){
	sv_xNums = sv_xNums_arg;
}
int getSv_xNums(){
	return(sv_xNums);
}
void setSv_yNums(int sv_yNums_arg){
	sv_yNums = sv_yNums_arg;
}
int getSv_yNums(){
	return(sv_yNums);
}
void setMiniBatchNums(int miniBatchNums_arg){
	miniBatchNums = miniBatchNums_arg;
}
int getMiniBatchNums(){
	return(miniBatchNums);
}
void setSvChannelNums(int svChannelNums_arg){
	svChannelNums = svChannelNums_arg;
}
int getSvChannelNums(){
	return(svChannelNums);
}
void setCnnOutputNumsNums(int cnnOutputNumsNums_arg){
	cnnOutputNumsNums = cnnOutputNumsNums_arg;
}
int getCnnOutputNumsNums(){
	return(cnnOutputNumsNums);
}
void setCnnOutputNums(int *cnnOutputNums_arg){
	cnnOutputNums = cnnOutputNums_arg;
}
int getCnnOutputNums(int cnnLayer){
	return(cnnOutputNums[cnnLayer]);
}
void setCnnBnBeta(float *cnnBnBeta_arg){
	cnnBnBeta = cnnBnBeta_arg;
}
void setLearningRate(float learningRate_arg){
	learningRate = learningRate_arg;
}
float getLearningRate(){
	return(learningRate);
}
int getHCnnBnBetaGammaIdx(int outputIdx, int cnnLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < cnnLayer; layer ++){
		idx += getCnnOutputNums(layer);
	}
	idx += outputIdx;
	return(idx);
}
float getCnnBnBeta(int outputIdx, int cnnLayer){
	return(cnnBnBeta[getHCnnBnBetaGammaIdx(outputIdx, cnnLayer)]);
}
void setCnnBnGamma(float *cnnBnGamma_arg){
	cnnBnGamma = cnnBnGamma_arg;
}
float getCnnBnGamma(int outputIdx, int cnnLayer){
	return(cnnBnGamma[getHCnnBnBetaGammaIdx(outputIdx, cnnLayer)]);
}
void setBnEps(float bnEps_arg){
	bnEps = bnEps_arg;
}
float getBnEps(){
	return(bnEps);
}
void setCnnW_xNums(int cnnW_xNums_arg){
	cnnW_xNums = cnnW_xNums_arg;
}
int getCnnW_xNums(){
	return(cnnW_xNums);
}
void setCnnW_yNums(int cnnW_yNums_arg){
	cnnW_yNums = cnnW_yNums_arg;
}
int getCnnW_yNums(){
	return(cnnW_yNums);
}
void setCnnWDataNums(int cnnWDataNums_arg){
	cnnWDataNums = cnnWDataNums_arg;
}
int getCnnWDataNums(){
	return(cnnWDataNums);
}
void setCnnW(float *cnnW_arg){
	cnnW = cnnW_arg;
}
int getHCnnWIdx(int x, int y, int inputIdx, int outputIdx, int cnnLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < cnnLayer; layer ++){
		idx += getCnnW_xNums() * getCnnW_yNums() * getCnnInputIdxNums(layer) * getCnnOutputNums(layer);
	}
	int inputIdxNums = getCnnInputIdxNums(cnnLayer);
	idx += getDim4Idx(x, y, inputIdx, outputIdx, getCnnW_xNums(), getCnnW_yNums(), inputIdxNums);
	return(idx);
}
float getCnnW(int x, int y, int inputIdx, int outputIdx, int cnnLayer){
	return(cnnW[getHCnnWIdx(x, y, inputIdx, outputIdx, cnnLayer)]);
}
void setCnnWba_xNums(int *cnnWba_xNums_arg){
	cnnWba_xNums = cnnWba_xNums_arg;
}
int getCnnWba_xNums(int cnnLayer){
	return(cnnWba_xNums[cnnLayer]);
}
void setCnnWba_yNums(int *cnnWba_yNums_arg){
	cnnWba_yNums = cnnWba_yNums_arg;
}
int getCnnWba_yNums(int cnnLayer){
	return(cnnWba_yNums[cnnLayer]);
}
int getHCnnWbaIdx(int x, int y, int outputIdx, int miniBatchIdx, int cnnLayer){
	int idx = 0;
	int layer;
	for(layer = 0; layer < cnnLayer; layer ++){
		idx += getCnnWba_xNums(layer) * getCnnWba_yNums(layer) * getCnnOutputNums(layer) * getMiniBatchNums();
	}
	idx += getDim4Idx(x, y, outputIdx, miniBatchIdx, getCnnWba_xNums(cnnLayer), getCnnWba_yNums(cnnLayer), getCnnOutputNums(cnnLayer));
	return(idx);
}
void setCnnP_xNums(int *cnnP_xNums_arg){
	cnnP_xNums = cnnP_xNums_arg;
}
int getCnnP_xNums(int cnnLayer){
	return(cnnP_xNums[cnnLayer]);
}
void setCnnP_yNums(int *cnnP_yNums_arg){
	cnnP_yNums = cnnP_yNums_arg;
}
int getCnnP_yNums(int cnnLayer){
	return(cnnP_yNums[cnnLayer]);
}
void setCnnPooling_xNums(int cnnPooling_xNums_arg){
	cnnPooling_xNums = cnnPooling_xNums_arg;
}
int getCnnPooling_xNums(){
	return(cnnPooling_xNums);
}
void setCnnPooling_yNums(int cnnPooling_yNums_arg){
	cnnPooling_yNums = cnnPooling_yNums_arg;
}
int getCnnPooling_yNums(){
	return(cnnPooling_yNums);
}
void setMlpOutputNumsNums(int mlpOutputNumsNums_arg){
	mlpOutputNumsNums = mlpOutputNumsNums_arg;
}
int getMlpOutputNumsNums(){
	return(mlpOutputNumsNums);
}
void setMlpOutputNums(int *mlpOutputNums_arg){
	mlpOutputNums = mlpOutputNums_arg;
}
int getMlpOutputNums(int mlpLayer){
	return(mlpOutputNums[mlpLayer]);
}
void setMlpBnBeta(float *mlpBnBeta_arg){
	mlpBnBeta = mlpBnBeta_arg;
}
int getHMlpBnBetaGammaIdx(int outputIdx, int mlpLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < mlpLayer; layer ++){
		idx += getMlpOutputNums(layer);
	}
	idx += outputIdx;
	return(idx);
}
float getMlpBnBeta(int outputIdx, int mlpLayer){
	return(mlpBnBeta[getHMlpBnBetaGammaIdx(outputIdx, mlpLayer)]);
}
void setMlpBnGamma(float *mlpBnGamma_arg){
	mlpBnGamma = mlpBnGamma_arg;
}
float getMlpBnGamma(int outputIdx, int mlpLayer){
	return(mlpBnGamma[getHMlpBnBetaGammaIdx(outputIdx, mlpLayer)]);
}
void setMlpWDataNums(int mlpWDataNums_arg){
	mlpWDataNums = mlpWDataNums_arg;
}
int getMlpWDataNums(){
	return(mlpWDataNums);
}
void setMlpW(float *mlpW_arg){
	mlpW = mlpW_arg;
}
int getHMlpWIdx(int inputIdx, int outputIdx, int mlpLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < mlpLayer; layer ++){
		idx += getMlpInputIdxNums(layer) * getMlpOutputNums(layer);
	}
	int inputIdxNums = getMlpInputIdxNums(mlpLayer);
	idx += getDim2Idx(inputIdx, outputIdx, inputIdxNums);
	return(idx);
}
float getMlpW(int inputIdx, int outputIdx, int mlpLayer){
	return(mlpW[getHMlpWIdx(inputIdx, outputIdx, mlpLayer)]);
}
int getHMlpWbaIdx(int outputIdx, int miniBatchIdx, int mlpLayer){
	int idx = 0;
	int layer;
	for(layer = 0; layer < mlpLayer; layer ++){
		idx += getMlpOutputNums(layer) * getMiniBatchNums();
	}
	idx += getDim2Idx(outputIdx, miniBatchIdx, getMlpOutputNums(mlpLayer));
	return(idx);
}
void setResult(float *result_arg){
	result = result_arg;
}
void setTeachOut(float *teachOut_arg){
	teachOut = teachOut_arg;
}
int getTeachOutResultIdx(int outputIdx, int miniBatchIdx){
	return(getDim2Idx(outputIdx, miniBatchIdx, getMlpOutputNums(getMlpOutputNumsNums() - 1)));
}
float getResult(int outputIdx, int miniBatchIdx){
	return(result[getTeachOutResultIdx(outputIdx, miniBatchIdx)]);
}
float getTeachOut(int outputIdx, int miniBatchIdx){
	return(teachOut[getTeachOutResultIdx(outputIdx, miniBatchIdx)]);
}

__device__ __host__
int getDim2Idx(int x, int y, int X){
	return(x + y * X);
}
__device__ __host__
int getDim3Idx(int x, int y, int z, int X, int Y){
	return(getDim2Idx(x, y, X) + z * X * Y);
}
__device__ __host__
int getDim4Idx(int x, int y, int z, int a, int X, int Y, int Z){
	return(getDim3Idx(x, y, z, X, Y) + a * X * Y * Z);
}
__device__ __host__
int getDim5Idx(int x, int y, int z, int a, int b, int X, int Y, int Z, int A){
	return(getDim4Idx(x, y, z, a, X, Y, Z) + b * X * Y * Z * A);
}
//CNN層のinputの総数を取得する。
int getCnnInputIdxNums(int cnnLayer){
	int inputIdxNums;
	if(cnnLayer == 0){
		inputIdxNums = getSvChannelNums();
	}
	else{
		inputIdxNums = getCnnOutputNums(cnnLayer - 1);
	}
	return(inputIdxNums);
}
//MLP層のinputの総数を取得する。
int getMlpInputIdxNums(int mlpLayer){
	int inputIdxNums;
	if(mlpLayer == 0){
		int cnnOutputNumsLastIdx = getCnnOutputNumsNums() - 1;
		inputIdxNums = getCnnP_xNums(cnnOutputNumsLastIdx) * getCnnP_yNums(cnnOutputNumsLastIdx) * getCnnOutputNums(cnnOutputNumsLastIdx);
	}
	else{
		inputIdxNums = getMlpOutputNums(mlpLayer - 1);
	}
	return(inputIdxNums);
}
//CNN層の全outputの合計値を取得する。
int getCnnOutputNumsSum(){
	int layer;
	int count = 0;
	for(layer = 0; layer < getCnnOutputNumsNums(); layer++){
		count += getCnnOutputNums(layer);
	}
	return(count);
}
//MLP層の全outputの合計値を取得する。
int getMlpOutputNumsSum(){
	int layer;
	int count = 0;
	for(layer = 0; layer < getMlpOutputNumsNums(); layer++){
		count += getMlpOutputNums(layer);
	}
	return(count);
}
#endif

	.file	"tmpxft_00331ebd_00000000-6_hostAccesser.cudafe1.cpp"
	.text
#APP

#NO_APP
	.type	_ZL26__cudaUnregisterBinaryUtilv, @function
_ZL26__cudaUnregisterBinaryUtilv:
.LFB2104:
	.cfi_startproc
	endbr64
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	jmp	__cudaUnregisterFatBinary@PLT
	.cfi_endproc
.LFE2104:
	.size	_ZL26__cudaUnregisterBinaryUtilv, .-_ZL26__cudaUnregisterBinaryUtilv
	.globl	_Z10setExecFlgi
	.type	_Z10setExecFlgi, @function
_Z10setExecFlgi:
.LFB2027:
	.cfi_startproc
	endbr64
	movl	%edi, execFlg(%rip)
	ret
	.cfi_endproc
.LFE2027:
	.size	_Z10setExecFlgi, .-_Z10setExecFlgi
	.globl	_Z10getExecFlgv
	.type	_Z10getExecFlgv, @function
_Z10getExecFlgv:
.LFB2028:
	.cfi_startproc
	endbr64
	movl	execFlg(%rip), %eax
	ret
	.cfi_endproc
.LFE2028:
	.size	_Z10getExecFlgv, .-_Z10getExecFlgv
	.globl	_Z18getExecFlgTrainingv
	.type	_Z18getExecFlgTrainingv, @function
_Z18getExecFlgTrainingv:
.LFB2029:
	.cfi_startproc
	endbr64
	movl	execFlgTraining(%rip), %eax
	ret
	.cfi_endproc
.LFE2029:
	.size	_Z18getExecFlgTrainingv, .-_Z18getExecFlgTrainingv
	.globl	_Z16getExecFlgOnlinev
	.type	_Z16getExecFlgOnlinev, @function
_Z16getExecFlgOnlinev:
.LFB2030:
	.cfi_startproc
	endbr64
	movl	execFlgOnline(%rip), %eax
	ret
	.cfi_endproc
.LFE2030:
	.size	_Z16getExecFlgOnlinev, .-_Z16getExecFlgOnlinev
	.globl	_Z11setSv_xNumsi
	.type	_Z11setSv_xNumsi, @function
_Z11setSv_xNumsi:
.LFB2031:
	.cfi_startproc
	endbr64
	movl	%edi, sv_xNums(%rip)
	ret
	.cfi_endproc
.LFE2031:
	.size	_Z11setSv_xNumsi, .-_Z11setSv_xNumsi
	.globl	_Z11getSv_xNumsv
	.type	_Z11getSv_xNumsv, @function
_Z11getSv_xNumsv:
.LFB2032:
	.cfi_startproc
	endbr64
	movl	sv_xNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2032:
	.size	_Z11getSv_xNumsv, .-_Z11getSv_xNumsv
	.globl	_Z11setSv_yNumsi
	.type	_Z11setSv_yNumsi, @function
_Z11setSv_yNumsi:
.LFB2033:
	.cfi_startproc
	endbr64
	movl	%edi, sv_yNums(%rip)
	ret
	.cfi_endproc
.LFE2033:
	.size	_Z11setSv_yNumsi, .-_Z11setSv_yNumsi
	.globl	_Z11getSv_yNumsv
	.type	_Z11getSv_yNumsv, @function
_Z11getSv_yNumsv:
.LFB2034:
	.cfi_startproc
	endbr64
	movl	sv_yNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2034:
	.size	_Z11getSv_yNumsv, .-_Z11getSv_yNumsv
	.globl	_Z16setMiniBatchNumsi
	.type	_Z16setMiniBatchNumsi, @function
_Z16setMiniBatchNumsi:
.LFB2035:
	.cfi_startproc
	endbr64
	movl	%edi, miniBatchNums(%rip)
	ret
	.cfi_endproc
.LFE2035:
	.size	_Z16setMiniBatchNumsi, .-_Z16setMiniBatchNumsi
	.globl	_Z16getMiniBatchNumsv
	.type	_Z16getMiniBatchNumsv, @function
_Z16getMiniBatchNumsv:
.LFB2036:
	.cfi_startproc
	endbr64
	movl	miniBatchNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2036:
	.size	_Z16getMiniBatchNumsv, .-_Z16getMiniBatchNumsv
	.globl	_Z16setSvChannelNumsi
	.type	_Z16setSvChannelNumsi, @function
_Z16setSvChannelNumsi:
.LFB2037:
	.cfi_startproc
	endbr64
	movl	%edi, svChannelNums(%rip)
	ret
	.cfi_endproc
.LFE2037:
	.size	_Z16setSvChannelNumsi, .-_Z16setSvChannelNumsi
	.globl	_Z16getSvChannelNumsv
	.type	_Z16getSvChannelNumsv, @function
_Z16getSvChannelNumsv:
.LFB2038:
	.cfi_startproc
	endbr64
	movl	svChannelNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2038:
	.size	_Z16getSvChannelNumsv, .-_Z16getSvChannelNumsv
	.globl	_Z20setCnnOutputNumsNumsi
	.type	_Z20setCnnOutputNumsNumsi, @function
_Z20setCnnOutputNumsNumsi:
.LFB2039:
	.cfi_startproc
	endbr64
	movl	%edi, cnnOutputNumsNums(%rip)
	ret
	.cfi_endproc
.LFE2039:
	.size	_Z20setCnnOutputNumsNumsi, .-_Z20setCnnOutputNumsNumsi
	.globl	_Z20getCnnOutputNumsNumsv
	.type	_Z20getCnnOutputNumsNumsv, @function
_Z20getCnnOutputNumsNumsv:
.LFB2040:
	.cfi_startproc
	endbr64
	movl	cnnOutputNumsNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2040:
	.size	_Z20getCnnOutputNumsNumsv, .-_Z20getCnnOutputNumsNumsv
	.globl	_Z16setCnnOutputNumsPi
	.type	_Z16setCnnOutputNumsPi, @function
_Z16setCnnOutputNumsPi:
.LFB2041:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnOutputNums(%rip)
	ret
	.cfi_endproc
.LFE2041:
	.size	_Z16setCnnOutputNumsPi, .-_Z16setCnnOutputNumsPi
	.globl	_Z16getCnnOutputNumsi
	.type	_Z16getCnnOutputNumsi, @function
_Z16getCnnOutputNumsi:
.LFB2042:
	.cfi_startproc
	endbr64
	movq	cnnOutputNums(%rip), %rax
	movslq	%edi, %rdi
	movl	(%rax,%rdi,4), %eax
	ret
	.cfi_endproc
.LFE2042:
	.size	_Z16getCnnOutputNumsi, .-_Z16getCnnOutputNumsi
	.globl	_Z12setCnnBnBetaPf
	.type	_Z12setCnnBnBetaPf, @function
_Z12setCnnBnBetaPf:
.LFB2043:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnBnBeta(%rip)
	ret
	.cfi_endproc
.LFE2043:
	.size	_Z12setCnnBnBetaPf, .-_Z12setCnnBnBetaPf
	.globl	_Z15setLearningRatef
	.type	_Z15setLearningRatef, @function
_Z15setLearningRatef:
.LFB2044:
	.cfi_startproc
	endbr64
	movss	%xmm0, learningRate(%rip)
	ret
	.cfi_endproc
.LFE2044:
	.size	_Z15setLearningRatef, .-_Z15setLearningRatef
	.globl	_Z15getLearningRatev
	.type	_Z15getLearningRatev, @function
_Z15getLearningRatev:
.LFB2045:
	.cfi_startproc
	endbr64
	movss	learningRate(%rip), %xmm0
	ret
	.cfi_endproc
.LFE2045:
	.size	_Z15getLearningRatev, .-_Z15getLearningRatev
	.globl	_Z21getHCnnBnBetaGammaIdxii
	.type	_Z21getHCnnBnBetaGammaIdxii, @function
_Z21getHCnnBnBetaGammaIdxii:
.LFB2046:
	.cfi_startproc
	endbr64
	movl	%edi, %r8d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
.L22:
	cmpl	%esi, %ecx
	jge	.L25
	movl	%ecx, %edi
	incl	%ecx
	call	_Z16getCnnOutputNumsi
	addl	%eax, %edx
	jmp	.L22
.L25:
	leal	(%rdx,%r8), %eax
	ret
	.cfi_endproc
.LFE2046:
	.size	_Z21getHCnnBnBetaGammaIdxii, .-_Z21getHCnnBnBetaGammaIdxii
	.globl	_Z12getCnnBnBetaii
	.type	_Z12getCnnBnBetaii, @function
_Z12getCnnBnBetaii:
.LFB2047:
	.cfi_startproc
	endbr64
	call	_Z21getHCnnBnBetaGammaIdxii
	movq	cnnBnBeta(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2047:
	.size	_Z12getCnnBnBetaii, .-_Z12getCnnBnBetaii
	.globl	_Z13setCnnBnGammaPf
	.type	_Z13setCnnBnGammaPf, @function
_Z13setCnnBnGammaPf:
.LFB2048:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnBnGamma(%rip)
	ret
	.cfi_endproc
.LFE2048:
	.size	_Z13setCnnBnGammaPf, .-_Z13setCnnBnGammaPf
	.globl	_Z13getCnnBnGammaii
	.type	_Z13getCnnBnGammaii, @function
_Z13getCnnBnGammaii:
.LFB2049:
	.cfi_startproc
	endbr64
	call	_Z21getHCnnBnBetaGammaIdxii
	movq	cnnBnGamma(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2049:
	.size	_Z13getCnnBnGammaii, .-_Z13getCnnBnGammaii
	.globl	_Z8setBnEpsf
	.type	_Z8setBnEpsf, @function
_Z8setBnEpsf:
.LFB2050:
	.cfi_startproc
	endbr64
	movss	%xmm0, bnEps(%rip)
	ret
	.cfi_endproc
.LFE2050:
	.size	_Z8setBnEpsf, .-_Z8setBnEpsf
	.globl	_Z8getBnEpsv
	.type	_Z8getBnEpsv, @function
_Z8getBnEpsv:
.LFB2051:
	.cfi_startproc
	endbr64
	movss	bnEps(%rip), %xmm0
	ret
	.cfi_endproc
.LFE2051:
	.size	_Z8getBnEpsv, .-_Z8getBnEpsv
	.globl	_Z13setCnnW_xNumsi
	.type	_Z13setCnnW_xNumsi, @function
_Z13setCnnW_xNumsi:
.LFB2052:
	.cfi_startproc
	endbr64
	movl	%edi, cnnW_xNums(%rip)
	ret
	.cfi_endproc
.LFE2052:
	.size	_Z13setCnnW_xNumsi, .-_Z13setCnnW_xNumsi
	.globl	_Z13getCnnW_xNumsv
	.type	_Z13getCnnW_xNumsv, @function
_Z13getCnnW_xNumsv:
.LFB2053:
	.cfi_startproc
	endbr64
	movl	cnnW_xNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2053:
	.size	_Z13getCnnW_xNumsv, .-_Z13getCnnW_xNumsv
	.globl	_Z13setCnnW_yNumsi
	.type	_Z13setCnnW_yNumsi, @function
_Z13setCnnW_yNumsi:
.LFB2054:
	.cfi_startproc
	endbr64
	movl	%edi, cnnW_yNums(%rip)
	ret
	.cfi_endproc
.LFE2054:
	.size	_Z13setCnnW_yNumsi, .-_Z13setCnnW_yNumsi
	.globl	_Z13getCnnW_yNumsv
	.type	_Z13getCnnW_yNumsv, @function
_Z13getCnnW_yNumsv:
.LFB2055:
	.cfi_startproc
	endbr64
	movl	cnnW_yNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2055:
	.size	_Z13getCnnW_yNumsv, .-_Z13getCnnW_yNumsv
	.globl	_Z15setCnnWDataNumsi
	.type	_Z15setCnnWDataNumsi, @function
_Z15setCnnWDataNumsi:
.LFB2056:
	.cfi_startproc
	endbr64
	movl	%edi, cnnWDataNums(%rip)
	ret
	.cfi_endproc
.LFE2056:
	.size	_Z15setCnnWDataNumsi, .-_Z15setCnnWDataNumsi
	.globl	_Z15getCnnWDataNumsv
	.type	_Z15getCnnWDataNumsv, @function
_Z15getCnnWDataNumsv:
.LFB2057:
	.cfi_startproc
	endbr64
	movl	cnnWDataNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2057:
	.size	_Z15getCnnWDataNumsv, .-_Z15getCnnWDataNumsv
	.globl	_Z7setCnnWPf
	.type	_Z7setCnnWPf, @function
_Z7setCnnWPf:
.LFB2058:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnW(%rip)
	ret
	.cfi_endproc
.LFE2058:
	.size	_Z7setCnnWPf, .-_Z7setCnnWPf
	.globl	_Z15setCnnWba_xNumsPi
	.type	_Z15setCnnWba_xNumsPi, @function
_Z15setCnnWba_xNumsPi:
.LFB2061:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnWba_xNums(%rip)
	ret
	.cfi_endproc
.LFE2061:
	.size	_Z15setCnnWba_xNumsPi, .-_Z15setCnnWba_xNumsPi
	.globl	_Z15getCnnWba_xNumsi
	.type	_Z15getCnnWba_xNumsi, @function
_Z15getCnnWba_xNumsi:
.LFB2062:
	.cfi_startproc
	endbr64
	movq	cnnWba_xNums(%rip), %rax
	movslq	%edi, %rdi
	movl	(%rax,%rdi,4), %eax
	ret
	.cfi_endproc
.LFE2062:
	.size	_Z15getCnnWba_xNumsi, .-_Z15getCnnWba_xNumsi
	.globl	_Z15setCnnWba_yNumsPi
	.type	_Z15setCnnWba_yNumsPi, @function
_Z15setCnnWba_yNumsPi:
.LFB2063:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnWba_yNums(%rip)
	ret
	.cfi_endproc
.LFE2063:
	.size	_Z15setCnnWba_yNumsPi, .-_Z15setCnnWba_yNumsPi
	.globl	_Z15getCnnWba_yNumsi
	.type	_Z15getCnnWba_yNumsi, @function
_Z15getCnnWba_yNumsi:
.LFB2064:
	.cfi_startproc
	endbr64
	movq	cnnWba_yNums(%rip), %rax
	movslq	%edi, %rdi
	movl	(%rax,%rdi,4), %eax
	ret
	.cfi_endproc
.LFE2064:
	.size	_Z15getCnnWba_yNumsi, .-_Z15getCnnWba_yNumsi
	.globl	_Z13getHCnnWbaIdxiiiii
	.type	_Z13getHCnnWbaIdxiiiii, @function
_Z13getHCnnWbaIdxiiiii:
.LFB2065:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movl	miniBatchNums(%rip), %ebp
	movl	%ecx, %r11d
	movl	%edi, %r10d
	pushq	%rbx
	.cfi_def_cfa_offset 24
	.cfi_offset 3, -24
	movl	%edx, %r9d
	xorl	%ebx, %ebx
	xorl	%ecx, %ecx
.L43:
	cmpl	%r8d, %ebx
	jge	.L46
	movl	%ebx, %edi
	call	_Z15getCnnWba_xNumsi
	movl	%ebx, %edi
	movl	%eax, %edx
	call	_Z15getCnnWba_yNumsi
	movl	%ebx, %edi
	incl	%ebx
	imull	%eax, %edx
	call	_Z16getCnnOutputNumsi
	imull	%eax, %edx
	imull	%ebp, %edx
	addl	%edx, %ecx
	jmp	.L43
.L46:
	movl	%r8d, %edi
	call	_Z16getCnnOutputNumsi
	movl	%r8d, %edi
	movl	%eax, %edx
	call	_Z15getCnnWba_yNumsi
	movl	%r8d, %edi
	movl	%eax, %ebx
	call	_Z15getCnnWba_xNumsi
	imull	%eax, %esi
	imull	%eax, %r9d
	imull	%r11d, %eax
	addl	%r10d, %esi
	imull	%ebx, %r9d
	imull	%ebx, %eax
	popq	%rbx
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	addl	%r9d, %esi
	imull	%edx, %eax
	addl	%esi, %eax
	addl	%ecx, %eax
	ret
	.cfi_endproc
.LFE2065:
	.size	_Z13getHCnnWbaIdxiiiii, .-_Z13getHCnnWbaIdxiiiii
	.globl	_Z13setCnnP_xNumsPi
	.type	_Z13setCnnP_xNumsPi, @function
_Z13setCnnP_xNumsPi:
.LFB2066:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnP_xNums(%rip)
	ret
	.cfi_endproc
.LFE2066:
	.size	_Z13setCnnP_xNumsPi, .-_Z13setCnnP_xNumsPi
	.globl	_Z13getCnnP_xNumsi
	.type	_Z13getCnnP_xNumsi, @function
_Z13getCnnP_xNumsi:
.LFB2067:
	.cfi_startproc
	endbr64
	movq	cnnP_xNums(%rip), %rax
	movslq	%edi, %rdi
	movl	(%rax,%rdi,4), %eax
	ret
	.cfi_endproc
.LFE2067:
	.size	_Z13getCnnP_xNumsi, .-_Z13getCnnP_xNumsi
	.globl	_Z13setCnnP_yNumsPi
	.type	_Z13setCnnP_yNumsPi, @function
_Z13setCnnP_yNumsPi:
.LFB2068:
	.cfi_startproc
	endbr64
	movq	%rdi, cnnP_yNums(%rip)
	ret
	.cfi_endproc
.LFE2068:
	.size	_Z13setCnnP_yNumsPi, .-_Z13setCnnP_yNumsPi
	.globl	_Z13getCnnP_yNumsi
	.type	_Z13getCnnP_yNumsi, @function
_Z13getCnnP_yNumsi:
.LFB2069:
	.cfi_startproc
	endbr64
	movq	cnnP_yNums(%rip), %rax
	movslq	%edi, %rdi
	movl	(%rax,%rdi,4), %eax
	ret
	.cfi_endproc
.LFE2069:
	.size	_Z13getCnnP_yNumsi, .-_Z13getCnnP_yNumsi
	.globl	_Z19setCnnPooling_xNumsi
	.type	_Z19setCnnPooling_xNumsi, @function
_Z19setCnnPooling_xNumsi:
.LFB2070:
	.cfi_startproc
	endbr64
	movl	%edi, cnnPooling_xNums(%rip)
	ret
	.cfi_endproc
.LFE2070:
	.size	_Z19setCnnPooling_xNumsi, .-_Z19setCnnPooling_xNumsi
	.globl	_Z19getCnnPooling_xNumsv
	.type	_Z19getCnnPooling_xNumsv, @function
_Z19getCnnPooling_xNumsv:
.LFB2071:
	.cfi_startproc
	endbr64
	movl	cnnPooling_xNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2071:
	.size	_Z19getCnnPooling_xNumsv, .-_Z19getCnnPooling_xNumsv
	.globl	_Z19setCnnPooling_yNumsi
	.type	_Z19setCnnPooling_yNumsi, @function
_Z19setCnnPooling_yNumsi:
.LFB2072:
	.cfi_startproc
	endbr64
	movl	%edi, cnnPooling_yNums(%rip)
	ret
	.cfi_endproc
.LFE2072:
	.size	_Z19setCnnPooling_yNumsi, .-_Z19setCnnPooling_yNumsi
	.globl	_Z19getCnnPooling_yNumsv
	.type	_Z19getCnnPooling_yNumsv, @function
_Z19getCnnPooling_yNumsv:
.LFB2073:
	.cfi_startproc
	endbr64
	movl	cnnPooling_yNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2073:
	.size	_Z19getCnnPooling_yNumsv, .-_Z19getCnnPooling_yNumsv
	.globl	_Z20setMlpOutputNumsNumsi
	.type	_Z20setMlpOutputNumsNumsi, @function
_Z20setMlpOutputNumsNumsi:
.LFB2074:
	.cfi_startproc
	endbr64
	movl	%edi, mlpOutputNumsNums(%rip)
	ret
	.cfi_endproc
.LFE2074:
	.size	_Z20setMlpOutputNumsNumsi, .-_Z20setMlpOutputNumsNumsi
	.globl	_Z20getMlpOutputNumsNumsv
	.type	_Z20getMlpOutputNumsNumsv, @function
_Z20getMlpOutputNumsNumsv:
.LFB2075:
	.cfi_startproc
	endbr64
	movl	mlpOutputNumsNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2075:
	.size	_Z20getMlpOutputNumsNumsv, .-_Z20getMlpOutputNumsNumsv
	.globl	_Z16setMlpOutputNumsPi
	.type	_Z16setMlpOutputNumsPi, @function
_Z16setMlpOutputNumsPi:
.LFB2076:
	.cfi_startproc
	endbr64
	movq	%rdi, mlpOutputNums(%rip)
	ret
	.cfi_endproc
.LFE2076:
	.size	_Z16setMlpOutputNumsPi, .-_Z16setMlpOutputNumsPi
	.globl	_Z16getMlpOutputNumsi
	.type	_Z16getMlpOutputNumsi, @function
_Z16getMlpOutputNumsi:
.LFB2077:
	.cfi_startproc
	endbr64
	movq	mlpOutputNums(%rip), %rax
	movslq	%edi, %rdi
	movl	(%rax,%rdi,4), %eax
	ret
	.cfi_endproc
.LFE2077:
	.size	_Z16getMlpOutputNumsi, .-_Z16getMlpOutputNumsi
	.globl	_Z12setMlpBnBetaPf
	.type	_Z12setMlpBnBetaPf, @function
_Z12setMlpBnBetaPf:
.LFB2078:
	.cfi_startproc
	endbr64
	movq	%rdi, mlpBnBeta(%rip)
	ret
	.cfi_endproc
.LFE2078:
	.size	_Z12setMlpBnBetaPf, .-_Z12setMlpBnBetaPf
	.globl	_Z21getHMlpBnBetaGammaIdxii
	.type	_Z21getHMlpBnBetaGammaIdxii, @function
_Z21getHMlpBnBetaGammaIdxii:
.LFB2079:
	.cfi_startproc
	endbr64
	movl	%edi, %r8d
	xorl	%edx, %edx
	xorl	%ecx, %ecx
.L61:
	cmpl	%esi, %ecx
	jge	.L63
	movl	%ecx, %edi
	incl	%ecx
	call	_Z16getMlpOutputNumsi
	addl	%eax, %edx
	jmp	.L61
.L63:
	leal	(%rdx,%r8), %eax
	ret
	.cfi_endproc
.LFE2079:
	.size	_Z21getHMlpBnBetaGammaIdxii, .-_Z21getHMlpBnBetaGammaIdxii
	.globl	_Z12getMlpBnBetaii
	.type	_Z12getMlpBnBetaii, @function
_Z12getMlpBnBetaii:
.LFB2080:
	.cfi_startproc
	endbr64
	call	_Z21getHMlpBnBetaGammaIdxii
	movq	mlpBnBeta(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2080:
	.size	_Z12getMlpBnBetaii, .-_Z12getMlpBnBetaii
	.globl	_Z13setMlpBnGammaPf
	.type	_Z13setMlpBnGammaPf, @function
_Z13setMlpBnGammaPf:
.LFB2081:
	.cfi_startproc
	endbr64
	movq	%rdi, mlpBnGamma(%rip)
	ret
	.cfi_endproc
.LFE2081:
	.size	_Z13setMlpBnGammaPf, .-_Z13setMlpBnGammaPf
	.globl	_Z13getMlpBnGammaii
	.type	_Z13getMlpBnGammaii, @function
_Z13getMlpBnGammaii:
.LFB2082:
	.cfi_startproc
	endbr64
	call	_Z21getHMlpBnBetaGammaIdxii
	movq	mlpBnGamma(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2082:
	.size	_Z13getMlpBnGammaii, .-_Z13getMlpBnGammaii
	.globl	_Z15setMlpWDataNumsi
	.type	_Z15setMlpWDataNumsi, @function
_Z15setMlpWDataNumsi:
.LFB2083:
	.cfi_startproc
	endbr64
	movl	%edi, mlpWDataNums(%rip)
	ret
	.cfi_endproc
.LFE2083:
	.size	_Z15setMlpWDataNumsi, .-_Z15setMlpWDataNumsi
	.globl	_Z15getMlpWDataNumsv
	.type	_Z15getMlpWDataNumsv, @function
_Z15getMlpWDataNumsv:
.LFB2084:
	.cfi_startproc
	endbr64
	movl	mlpWDataNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2084:
	.size	_Z15getMlpWDataNumsv, .-_Z15getMlpWDataNumsv
	.globl	_Z7setMlpWPf
	.type	_Z7setMlpWPf, @function
_Z7setMlpWPf:
.LFB2085:
	.cfi_startproc
	endbr64
	movq	%rdi, mlpW(%rip)
	ret
	.cfi_endproc
.LFE2085:
	.size	_Z7setMlpWPf, .-_Z7setMlpWPf
	.globl	_Z13getHMlpWbaIdxiii
	.type	_Z13getHMlpWbaIdxiii, @function
_Z13getHMlpWbaIdxiii:
.LFB2088:
	.cfi_startproc
	endbr64
	movl	miniBatchNums(%rip), %r10d
	movl	%edi, %r9d
	xorl	%ecx, %ecx
	xorl	%r8d, %r8d
.L71:
	cmpl	%edx, %ecx
	jge	.L73
	movl	%ecx, %edi
	incl	%ecx
	call	_Z16getMlpOutputNumsi
	imull	%r10d, %eax
	addl	%eax, %r8d
	jmp	.L71
.L73:
	movl	%edx, %edi
	call	_Z16getMlpOutputNumsi
	imull	%esi, %eax
	addl	%r9d, %eax
	addl	%r8d, %eax
	ret
	.cfi_endproc
.LFE2088:
	.size	_Z13getHMlpWbaIdxiii, .-_Z13getHMlpWbaIdxiii
	.globl	_Z9setResultPf
	.type	_Z9setResultPf, @function
_Z9setResultPf:
.LFB2089:
	.cfi_startproc
	endbr64
	movq	%rdi, result(%rip)
	ret
	.cfi_endproc
.LFE2089:
	.size	_Z9setResultPf, .-_Z9setResultPf
	.globl	_Z11setTeachOutPf
	.type	_Z11setTeachOutPf, @function
_Z11setTeachOutPf:
.LFB2090:
	.cfi_startproc
	endbr64
	movq	%rdi, teachOut(%rip)
	ret
	.cfi_endproc
.LFE2090:
	.size	_Z11setTeachOutPf, .-_Z11setTeachOutPf
	.globl	_Z20getTeachOutResultIdxii
	.type	_Z20getTeachOutResultIdxii, @function
_Z20getTeachOutResultIdxii:
.LFB2091:
	.cfi_startproc
	endbr64
	movl	mlpOutputNumsNums(%rip), %eax
	movl	%edi, %edx
	leal	-1(%rax), %edi
	call	_Z16getMlpOutputNumsi
	imull	%esi, %eax
	addl	%edx, %eax
	ret
	.cfi_endproc
.LFE2091:
	.size	_Z20getTeachOutResultIdxii, .-_Z20getTeachOutResultIdxii
	.globl	_Z9getResultii
	.type	_Z9getResultii, @function
_Z9getResultii:
.LFB2092:
	.cfi_startproc
	endbr64
	call	_Z20getTeachOutResultIdxii
	movq	result(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2092:
	.size	_Z9getResultii, .-_Z9getResultii
	.globl	_Z11getTeachOutii
	.type	_Z11getTeachOutii, @function
_Z11getTeachOutii:
.LFB2093:
	.cfi_startproc
	endbr64
	call	_Z20getTeachOutResultIdxii
	movq	teachOut(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2093:
	.size	_Z11getTeachOutii, .-_Z11getTeachOutii
	.globl	_Z10getDim2Idxiii
	.type	_Z10getDim2Idxiii, @function
_Z10getDim2Idxiii:
.LFB2094:
	.cfi_startproc
	endbr64
	imull	%edx, %esi
	leal	(%rsi,%rdi), %eax
	ret
	.cfi_endproc
.LFE2094:
	.size	_Z10getDim2Idxiii, .-_Z10getDim2Idxiii
	.globl	_Z10getDim3Idxiiiii
	.type	_Z10getDim3Idxiiiii, @function
_Z10getDim3Idxiiiii:
.LFB2095:
	.cfi_startproc
	endbr64
	imull	%ecx, %edx
	imull	%ecx, %esi
	imull	%r8d, %edx
	addl	%edi, %esi
	leal	(%rdx,%rsi), %eax
	ret
	.cfi_endproc
.LFE2095:
	.size	_Z10getDim3Idxiiiii, .-_Z10getDim3Idxiiiii
	.globl	_Z10getDim4Idxiiiiiii
	.type	_Z10getDim4Idxiiiiiii, @function
_Z10getDim4Idxiiiiiii:
.LFB2096:
	.cfi_startproc
	endbr64
	imull	%r8d, %edx
	imull	%r8d, %esi
	imull	%ecx, %r8d
	imull	%r9d, %edx
	addl	%edi, %esi
	imull	%r9d, %r8d
	imull	8(%rsp), %r8d
	addl	%edx, %esi
	leal	(%rsi,%r8), %eax
	ret
	.cfi_endproc
.LFE2096:
	.size	_Z10getDim4Idxiiiiiii, .-_Z10getDim4Idxiiiiiii
	.globl	_Z10getDim5Idxiiiiiiiii
	.type	_Z10getDim5Idxiiiiiiiii, @function
_Z10getDim5Idxiiiiiiiii:
.LFB2097:
	.cfi_startproc
	endbr64
	imull	%r9d, %ecx
	movl	8(%rsp), %eax
	movl	16(%rsp), %r10d
	imull	%r9d, %esi
	imull	%r9d, %edx
	imull	%r8d, %r9d
	imull	%eax, %ecx
	addl	%edi, %esi
	imull	%eax, %edx
	imull	%eax, %r9d
	imull	%r10d, %ecx
	addl	%edx, %esi
	imull	%r10d, %r9d
	imull	24(%rsp), %r9d
	addl	%ecx, %esi
	leal	(%rsi,%r9), %eax
	ret
	.cfi_endproc
.LFE2097:
	.size	_Z10getDim5Idxiiiiiiiii, .-_Z10getDim5Idxiiiiiiiii
	.globl	_Z18getCnnInputIdxNumsi
	.type	_Z18getCnnInputIdxNumsi, @function
_Z18getCnnInputIdxNumsi:
.LFB2098:
	.cfi_startproc
	endbr64
	testl	%edi, %edi
	je	.L87
	decl	%edi
	jmp	_Z16getCnnOutputNumsi
.L87:
	movl	svChannelNums(%rip), %eax
	ret
	.cfi_endproc
.LFE2098:
	.size	_Z18getCnnInputIdxNumsi, .-_Z18getCnnInputIdxNumsi
	.globl	_Z11getHCnnWIdxiiiii
	.type	_Z11getHCnnWIdxiiiii, @function
_Z11getHCnnWIdxiiiii:
.LFB2059:
	.cfi_startproc
	endbr64
	movl	%edx, %r9d
	movl	cnnW_xNums(%rip), %edx
	pushq	%r13
	.cfi_def_cfa_offset 16
	.cfi_offset 13, -16
	xorl	%r10d, %r10d
	movl	cnnW_yNums(%rip), %r11d
	pushq	%r12
	.cfi_def_cfa_offset 24
	.cfi_offset 12, -24
	movl	%edx, %r13d
	pushq	%rbp
	.cfi_def_cfa_offset 32
	.cfi_offset 6, -32
	movl	%edi, %ebp
	imull	%r11d, %r13d
	pushq	%rbx
	.cfi_def_cfa_offset 40
	.cfi_offset 3, -40
	movl	%ecx, %ebx
	xorl	%ecx, %ecx
.L89:
	cmpl	%r8d, %r10d
	jge	.L92
	movl	%r10d, %edi
	call	_Z18getCnnInputIdxNumsi
	movl	%r10d, %edi
	incl	%r10d
	imull	%r13d, %eax
	movl	%eax, %r12d
	call	_Z16getCnnOutputNumsi
	imull	%eax, %r12d
	addl	%r12d, %ecx
	jmp	.L89
.L92:
	imull	%edx, %esi
	movl	%r8d, %edi
	call	_Z18getCnnInputIdxNumsi
	imull	%edx, %r9d
	imull	%ebx, %edx
	movl	%eax, %edi
	popq	%rbx
	.cfi_def_cfa_offset 32
	leal	(%rsi,%rbp), %eax
	popq	%rbp
	.cfi_def_cfa_offset 24
	popq	%r12
	.cfi_def_cfa_offset 16
	imull	%r11d, %r9d
	popq	%r13
	.cfi_def_cfa_offset 8
	imull	%r11d, %edx
	addl	%r9d, %eax
	imull	%edi, %edx
	addl	%edx, %eax
	addl	%ecx, %eax
	ret
	.cfi_endproc
.LFE2059:
	.size	_Z11getHCnnWIdxiiiii, .-_Z11getHCnnWIdxiiiii
	.globl	_Z7getCnnWiiiii
	.type	_Z7getCnnWiiiii, @function
_Z7getCnnWiiiii:
.LFB2060:
	.cfi_startproc
	endbr64
	call	_Z11getHCnnWIdxiiiii
	movq	cnnW(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2060:
	.size	_Z7getCnnWiiiii, .-_Z7getCnnWiiiii
	.globl	_Z18getMlpInputIdxNumsi
	.type	_Z18getMlpInputIdxNumsi, @function
_Z18getMlpInputIdxNumsi:
.LFB2099:
	.cfi_startproc
	endbr64
	testl	%edi, %edi
	je	.L98
	decl	%edi
	jmp	_Z16getMlpOutputNumsi
.L98:
	movl	cnnOutputNumsNums(%rip), %eax
	leal	-1(%rax), %ecx
	movl	%ecx, %edi
	call	_Z13getCnnP_xNumsi
	movl	%ecx, %edi
	movl	%eax, %edx
	call	_Z13getCnnP_yNumsi
	movl	%ecx, %edi
	imull	%eax, %edx
	call	_Z16getCnnOutputNumsi
	imull	%edx, %eax
	ret
	.cfi_endproc
.LFE2099:
	.size	_Z18getMlpInputIdxNumsi, .-_Z18getMlpInputIdxNumsi
	.globl	_Z11getHMlpWIdxiii
	.type	_Z11getHMlpWIdxiii, @function
_Z11getHMlpWIdxiii:
.LFB2086:
	.cfi_startproc
	endbr64
	movl	%edi, %r11d
	movl	%edx, %r9d
	xorl	%r10d, %r10d
	xorl	%r8d, %r8d
.L100:
	cmpl	%r9d, %r8d
	jge	.L102
	movl	%r8d, %edi
	call	_Z18getMlpInputIdxNumsi
	movl	%r8d, %edi
	incl	%r8d
	movl	%eax, %ecx
	call	_Z16getMlpOutputNumsi
	imull	%eax, %ecx
	addl	%ecx, %r10d
	jmp	.L100
.L102:
	movl	%r9d, %edi
	call	_Z18getMlpInputIdxNumsi
	imull	%esi, %eax
	addl	%r11d, %eax
	addl	%r10d, %eax
	ret
	.cfi_endproc
.LFE2086:
	.size	_Z11getHMlpWIdxiii, .-_Z11getHMlpWIdxiii
	.globl	_Z7getMlpWiii
	.type	_Z7getMlpWiii, @function
_Z7getMlpWiii:
.LFB2087:
	.cfi_startproc
	endbr64
	call	_Z11getHMlpWIdxiii
	movq	mlpW(%rip), %rdx
	cltq
	movss	(%rdx,%rax,4), %xmm0
	ret
	.cfi_endproc
.LFE2087:
	.size	_Z7getMlpWiii, .-_Z7getMlpWiii
	.globl	_Z19getCnnOutputNumsSumv
	.type	_Z19getCnnOutputNumsSumv, @function
_Z19getCnnOutputNumsSumv:
.LFB2100:
	.cfi_startproc
	endbr64
	movl	cnnOutputNumsNums(%rip), %esi
	xorl	%ecx, %ecx
	xorl	%edx, %edx
.L105:
	cmpl	%esi, %edx
	jge	.L107
	movl	%edx, %edi
	incl	%edx
	call	_Z16getCnnOutputNumsi
	addl	%eax, %ecx
	jmp	.L105
.L107:
	movl	%ecx, %eax
	ret
	.cfi_endproc
.LFE2100:
	.size	_Z19getCnnOutputNumsSumv, .-_Z19getCnnOutputNumsSumv
	.globl	_Z19getMlpOutputNumsSumv
	.type	_Z19getMlpOutputNumsSumv, @function
_Z19getMlpOutputNumsSumv:
.LFB2101:
	.cfi_startproc
	endbr64
	movl	mlpOutputNumsNums(%rip), %esi
	xorl	%ecx, %ecx
	xorl	%edx, %edx
.L109:
	cmpl	%esi, %edx
	jge	.L111
	movl	%edx, %edi
	incl	%edx
	call	_Z16getMlpOutputNumsi
	addl	%eax, %ecx
	jmp	.L109
.L111:
	movl	%ecx, %eax
	ret
	.cfi_endproc
.LFE2101:
	.size	_Z19getMlpOutputNumsSumv, .-_Z19getMlpOutputNumsSumv
	.section	.text.startup,"ax",@progbits
	.type	_ZL24__sti____cudaRegisterAllv, @function
_ZL24__sti____cudaRegisterAllv:
.LFB2127:
	.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
.LFE2127:
	.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
	.globl	E
	.bss
	.align 4
	.type	E, @object
	.size	E, 4
E:
	.zero	4
	.globl	learningRate
	.align 4
	.type	learningRate, @object
	.size	learningRate, 4
learningRate:
	.zero	4
	.globl	result
	.align 8
	.type	result, @object
	.size	result, 8
result:
	.zero	8
	.globl	teachOut
	.align 8
	.type	teachOut, @object
	.size	teachOut, 8
teachOut:
	.zero	8
	.globl	mlpW
	.align 8
	.type	mlpW, @object
	.size	mlpW, 8
mlpW:
	.zero	8
	.globl	mlpWDataNums
	.align 4
	.type	mlpWDataNums, @object
	.size	mlpWDataNums, 4
mlpWDataNums:
	.zero	4
	.globl	mlpBnGamma
	.align 8
	.type	mlpBnGamma, @object
	.size	mlpBnGamma, 8
mlpBnGamma:
	.zero	8
	.globl	mlpBnBeta
	.align 8
	.type	mlpBnBeta, @object
	.size	mlpBnBeta, 8
mlpBnBeta:
	.zero	8
	.globl	mlpOutputNums
	.align 8
	.type	mlpOutputNums, @object
	.size	mlpOutputNums, 8
mlpOutputNums:
	.zero	8
	.globl	mlpOutputNumsNums
	.align 4
	.type	mlpOutputNumsNums, @object
	.size	mlpOutputNumsNums, 4
mlpOutputNumsNums:
	.zero	4
	.globl	cnnPooling_yNums
	.align 4
	.type	cnnPooling_yNums, @object
	.size	cnnPooling_yNums, 4
cnnPooling_yNums:
	.zero	4
	.globl	cnnPooling_xNums
	.align 4
	.type	cnnPooling_xNums, @object
	.size	cnnPooling_xNums, 4
cnnPooling_xNums:
	.zero	4
	.globl	cnnP_yNums
	.align 8
	.type	cnnP_yNums, @object
	.size	cnnP_yNums, 8
cnnP_yNums:
	.zero	8
	.globl	cnnP_xNums
	.align 8
	.type	cnnP_xNums, @object
	.size	cnnP_xNums, 8
cnnP_xNums:
	.zero	8
	.globl	cnnWba_yNums
	.align 8
	.type	cnnWba_yNums, @object
	.size	cnnWba_yNums, 8
cnnWba_yNums:
	.zero	8
	.globl	cnnWba_xNums
	.align 8
	.type	cnnWba_xNums, @object
	.size	cnnWba_xNums, 8
cnnWba_xNums:
	.zero	8
	.globl	cnnW
	.align 8
	.type	cnnW, @object
	.size	cnnW, 8
cnnW:
	.zero	8
	.globl	cnnWDataNums
	.align 4
	.type	cnnWDataNums, @object
	.size	cnnWDataNums, 4
cnnWDataNums:
	.zero	4
	.globl	cnnW_yNums
	.align 4
	.type	cnnW_yNums, @object
	.size	cnnW_yNums, 4
cnnW_yNums:
	.zero	4
	.globl	cnnW_xNums
	.align 4
	.type	cnnW_xNums, @object
	.size	cnnW_xNums, 4
cnnW_xNums:
	.zero	4
	.globl	bnEps
	.align 4
	.type	bnEps, @object
	.size	bnEps, 4
bnEps:
	.zero	4
	.globl	cnnBnGamma
	.align 8
	.type	cnnBnGamma, @object
	.size	cnnBnGamma, 8
cnnBnGamma:
	.zero	8
	.globl	cnnBnBeta
	.align 8
	.type	cnnBnBeta, @object
	.size	cnnBnBeta, 8
cnnBnBeta:
	.zero	8
	.globl	miniBatchNums
	.align 4
	.type	miniBatchNums, @object
	.size	miniBatchNums, 4
miniBatchNums:
	.zero	4
	.globl	svChannelNums
	.align 4
	.type	svChannelNums, @object
	.size	svChannelNums, 4
svChannelNums:
	.zero	4
	.globl	sv_yNums
	.align 4
	.type	sv_yNums, @object
	.size	sv_yNums, 4
sv_yNums:
	.zero	4
	.globl	sv_xNums
	.align 4
	.type	sv_xNums, @object
	.size	sv_xNums, 4
sv_xNums:
	.zero	4
	.globl	execFlgOnline
	.data
	.align 4
	.type	execFlgOnline, @object
	.size	execFlgOnline, 4
execFlgOnline:
	.long	1
	.globl	execFlgTraining
	.bss
	.align 4
	.type	execFlgTraining, @object
	.size	execFlgTraining, 4
execFlgTraining:
	.zero	4
	.globl	execFlg
	.align 4
	.type	execFlg, @object
	.size	execFlg, 4
execFlg:
	.zero	4
	.globl	cnnOutputNums
	.align 8
	.type	cnnOutputNums, @object
	.size	cnnOutputNums, 8
cnnOutputNums:
	.zero	8
	.globl	cnnOutputNumsNums
	.align 4
	.type	cnnOutputNumsNums, @object
	.size	cnnOutputNumsNums, 4
cnnOutputNumsNums:
	.zero	4
	.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:

//host処理系のグローバル変数定義
#ifndef INCLUDED_HOSTVALUESACCESSER
#define INCLUDED_HOSTVALUESACCESSER
#include <stdio.h>

int cnnOutputNumsNums;
int *cnnOutputNums;

int execFlg;
int execFlgTraining = 0;
int execFlgOnline = 1;

int sv_xNums;
int sv_yNums;
int svChannelNums;
int miniBatchNums;

float *cnnBnBeta;
float *cnnBnGamma;
float bnEps;

int cnnW_xNums;
int cnnW_yNums;
int cnnWDataNums;
float *cnnW;

int *cnnWba_xNums;
int *cnnWba_yNums;

int *cnnP_xNums;
int *cnnP_yNums;

int cnnPooling_xNums;
int cnnPooling_yNums;

int mlpOutputNumsNums;
int *mlpOutputNums;

float *mlpBnBeta;
float *mlpBnGamma;
int mlpWDataNums;
float *mlpW;

float *teachOut;
float *result;

float learningRate;

float E = 0;

extern __device__ __host__ int getDim2Idx(int x, int y, int X);
extern __device__ __host__ int getDim4Idx(int x, int y, int z, int a, int X, int Y, int Z);
extern int getCnnInputIdxNums(int cnnLayer);
extern int getMlpInputIdxNums(int cnnLayer);
extern int getMlpOutputNumsNums();
extern int getMlpOutputNums(int mlpLayer);
extern int getCnnWba_xNums(int cnnLayer);
extern int getCnnWba_yNums(int cnnLayer);
extern int getHMlpWbaIdx(int outputIdx, int miniBatchIdx, int mlpLayer);
extern int getHCnnWbaIdx(int x, int y, int outputIdx, int miniBatchIdx, int cnnLayer);

void setExecFlg(int execFlg_arg){
	execFlg = execFlg_arg;
}
int getExecFlg(){
	return(execFlg);
}
int getExecFlgTraining(){
	return(execFlgTraining);
}
int getExecFlgOnline(){
	return(execFlgOnline);
}
void setSv_xNums(int sv_xNums_arg){
	sv_xNums = sv_xNums_arg;
}
int getSv_xNums(){
	return(sv_xNums);
}
void setSv_yNums(int sv_yNums_arg){
	sv_yNums = sv_yNums_arg;
}
int getSv_yNums(){
	return(sv_yNums);
}
void setMiniBatchNums(int miniBatchNums_arg){
	miniBatchNums = miniBatchNums_arg;
}
int getMiniBatchNums(){
	return(miniBatchNums);
}
void setSvChannelNums(int svChannelNums_arg){
	svChannelNums = svChannelNums_arg;
}
int getSvChannelNums(){
	return(svChannelNums);
}
void setCnnOutputNumsNums(int cnnOutputNumsNums_arg){
	cnnOutputNumsNums = cnnOutputNumsNums_arg;
}
int getCnnOutputNumsNums(){
	return(cnnOutputNumsNums);
}
void setCnnOutputNums(int *cnnOutputNums_arg){
	cnnOutputNums = cnnOutputNums_arg;
}
int getCnnOutputNums(int cnnLayer){
	return(cnnOutputNums[cnnLayer]);
}
void setCnnBnBeta(float *cnnBnBeta_arg){
	cnnBnBeta = cnnBnBeta_arg;
}
void setLearningRate(float learningRate_arg){
	learningRate = learningRate_arg;
}
float getLearningRate(){
	return(learningRate);
}
int getHCnnBnBetaGammaIdx(int outputIdx, int cnnLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < cnnLayer; layer ++){
		idx += getCnnOutputNums(layer);
	}
	idx += outputIdx;
	return(idx);
}
float getCnnBnBeta(int outputIdx, int cnnLayer){
	return(cnnBnBeta[getHCnnBnBetaGammaIdx(outputIdx, cnnLayer)]);
}
void setCnnBnGamma(float *cnnBnGamma_arg){
	cnnBnGamma = cnnBnGamma_arg;
}
float getCnnBnGamma(int outputIdx, int cnnLayer){
	return(cnnBnGamma[getHCnnBnBetaGammaIdx(outputIdx, cnnLayer)]);
}
void setBnEps(float bnEps_arg){
	bnEps = bnEps_arg;
}
float getBnEps(){
	return(bnEps);
}
void setCnnW_xNums(int cnnW_xNums_arg){
	cnnW_xNums = cnnW_xNums_arg;
}
int getCnnW_xNums(){
	return(cnnW_xNums);
}
void setCnnW_yNums(int cnnW_yNums_arg){
	cnnW_yNums = cnnW_yNums_arg;
}
int getCnnW_yNums(){
	return(cnnW_yNums);
}
void setCnnWDataNums(int cnnWDataNums_arg){
	cnnWDataNums = cnnWDataNums_arg;
}
int getCnnWDataNums(){
	return(cnnWDataNums);
}
void setCnnW(float *cnnW_arg){
	cnnW = cnnW_arg;
}
int getHCnnWIdx(int x, int y, int inputIdx, int outputIdx, int cnnLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < cnnLayer; layer ++){
		idx += getCnnW_xNums() * getCnnW_yNums() * getCnnInputIdxNums(layer) * getCnnOutputNums(layer);
	}
	int inputIdxNums = getCnnInputIdxNums(cnnLayer);
	idx += getDim4Idx(x, y, inputIdx, outputIdx, getCnnW_xNums(), getCnnW_yNums(), inputIdxNums);
	return(idx);
}
float getCnnW(int x, int y, int inputIdx, int outputIdx, int cnnLayer){
	return(cnnW[getHCnnWIdx(x, y, inputIdx, outputIdx, cnnLayer)]);
}
void setCnnWba_xNums(int *cnnWba_xNums_arg){
	cnnWba_xNums = cnnWba_xNums_arg;
}
int getCnnWba_xNums(int cnnLayer){
	return(cnnWba_xNums[cnnLayer]);
}
void setCnnWba_yNums(int *cnnWba_yNums_arg){
	cnnWba_yNums = cnnWba_yNums_arg;
}
int getCnnWba_yNums(int cnnLayer){
	return(cnnWba_yNums[cnnLayer]);
}
int getHCnnWbaIdx(int x, int y, int outputIdx, int miniBatchIdx, int cnnLayer){
	int idx = 0;
	int layer;
	for(layer = 0; layer < cnnLayer; layer ++){
		idx += getCnnWba_xNums(layer) * getCnnWba_yNums(layer) * getCnnOutputNums(layer) * getMiniBatchNums();
	}
	idx += getDim4Idx(x, y, outputIdx, miniBatchIdx, getCnnWba_xNums(cnnLayer), getCnnWba_yNums(cnnLayer), getCnnOutputNums(cnnLayer));
	return(idx);
}
void setCnnP_xNums(int *cnnP_xNums_arg){
	cnnP_xNums = cnnP_xNums_arg;
}
int getCnnP_xNums(int cnnLayer){
	return(cnnP_xNums[cnnLayer]);
}
void setCnnP_yNums(int *cnnP_yNums_arg){
	cnnP_yNums = cnnP_yNums_arg;
}
int getCnnP_yNums(int cnnLayer){
	return(cnnP_yNums[cnnLayer]);
}
void setCnnPooling_xNums(int cnnPooling_xNums_arg){
	cnnPooling_xNums = cnnPooling_xNums_arg;
}
int getCnnPooling_xNums(){
	return(cnnPooling_xNums);
}
void setCnnPooling_yNums(int cnnPooling_yNums_arg){
	cnnPooling_yNums = cnnPooling_yNums_arg;
}
int getCnnPooling_yNums(){
	return(cnnPooling_yNums);
}
void setMlpOutputNumsNums(int mlpOutputNumsNums_arg){
	mlpOutputNumsNums = mlpOutputNumsNums_arg;
}
int getMlpOutputNumsNums(){
	return(mlpOutputNumsNums);
}
void setMlpOutputNums(int *mlpOutputNums_arg){
	mlpOutputNums = mlpOutputNums_arg;
}
int getMlpOutputNums(int mlpLayer){
	return(mlpOutputNums[mlpLayer]);
}
void setMlpBnBeta(float *mlpBnBeta_arg){
	mlpBnBeta = mlpBnBeta_arg;
}
int getHMlpBnBetaGammaIdx(int outputIdx, int mlpLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < mlpLayer; layer ++){
		idx += getMlpOutputNums(layer);
	}
	idx += outputIdx;
	return(idx);
}
float getMlpBnBeta(int outputIdx, int mlpLayer){
	return(mlpBnBeta[getHMlpBnBetaGammaIdx(outputIdx, mlpLayer)]);
}
void setMlpBnGamma(float *mlpBnGamma_arg){
	mlpBnGamma = mlpBnGamma_arg;
}
float getMlpBnGamma(int outputIdx, int mlpLayer){
	return(mlpBnGamma[getHMlpBnBetaGammaIdx(outputIdx, mlpLayer)]);
}
void setMlpWDataNums(int mlpWDataNums_arg){
	mlpWDataNums = mlpWDataNums_arg;
}
int getMlpWDataNums(){
	return(mlpWDataNums);
}
void setMlpW(float *mlpW_arg){
	mlpW = mlpW_arg;
}
int getHMlpWIdx(int inputIdx, int outputIdx, int mlpLayer){
	int layer;
	int idx = 0;
	for(layer = 0; layer < mlpLayer; layer ++){
		idx += getMlpInputIdxNums(layer) * getMlpOutputNums(layer);
	}
	int inputIdxNums = getMlpInputIdxNums(mlpLayer);
	idx += getDim2Idx(inputIdx, outputIdx, inputIdxNums);
	return(idx);
}
float getMlpW(int inputIdx, int outputIdx, int mlpLayer){
	return(mlpW[getHMlpWIdx(inputIdx, outputIdx, mlpLayer)]);
}
int getHMlpWbaIdx(int outputIdx, int miniBatchIdx, int mlpLayer){
	int idx = 0;
	int layer;
	for(layer = 0; layer < mlpLayer; layer ++){
		idx += getMlpOutputNums(layer) * getMiniBatchNums();
	}
	idx += getDim2Idx(outputIdx, miniBatchIdx, getMlpOutputNums(mlpLayer));
	return(idx);
}
void setResult(float *result_arg){
	result = result_arg;
}
void setTeachOut(float *teachOut_arg){
	teachOut = teachOut_arg;
}
int getTeachOutResultIdx(int outputIdx, int miniBatchIdx){
	return(getDim2Idx(outputIdx, miniBatchIdx, getMlpOutputNums(getMlpOutputNumsNums() - 1)));
}
float getResult(int outputIdx, int miniBatchIdx){
	return(result[getTeachOutResultIdx(outputIdx, miniBatchIdx)]);
}
float getTeachOut(int outputIdx, int miniBatchIdx){
	return(teachOut[getTeachOutResultIdx(outputIdx, miniBatchIdx)]);
}

__device__ __host__
int getDim2Idx(int x, int y, int X){
	return(x + y * X);
}
__device__ __host__
int getDim3Idx(int x, int y, int z, int X, int Y){
	return(getDim2Idx(x, y, X) + z * X * Y);
}
__device__ __host__
int getDim4Idx(int x, int y, int z, int a, int X, int Y, int Z){
	return(getDim3Idx(x, y, z, X, Y) + a * X * Y * Z);
}
__device__ __host__
int getDim5Idx(int x, int y, int z, int a, int b, int X, int Y, int Z, int A){
	return(getDim4Idx(x, y, z, a, X, Y, Z) + b * X * Y * Z * A);
}
//CNN層のinputの総数を取得する。
int getCnnInputIdxNums(int cnnLayer){
	int inputIdxNums;
	if(cnnLayer == 0){
		inputIdxNums = getSvChannelNums();
	}
	else{
		inputIdxNums = getCnnOutputNums(cnnLayer - 1);
	}
	return(inputIdxNums);
}
//MLP層のinputの総数を取得する。
int getMlpInputIdxNums(int mlpLayer){
	int inputIdxNums;
	if(mlpLayer == 0){
		int cnnOutputNumsLastIdx = getCnnOutputNumsNums() - 1;
		inputIdxNums = getCnnP_xNums(cnnOutputNumsLastIdx) * getCnnP_yNums(cnnOutputNumsLastIdx) * getCnnOutputNums(cnnOutputNumsLastIdx);
	}
	else{
		inputIdxNums = getMlpOutputNums(mlpLayer - 1);
	}
	return(inputIdxNums);
}
//CNN層の全outputの合計値を取得する。
int getCnnOutputNumsSum(){
	int layer;
	int count = 0;
	for(layer = 0; layer < getCnnOutputNumsNums(); layer++){
		count += getCnnOutputNums(layer);
	}
	return(count);
}
//MLP層の全outputの合計値を取得する。
int getMlpOutputNumsSum(){
	int layer;
	int count = 0;
	for(layer = 0; layer < getMlpOutputNumsNums(); layer++){
		count += getMlpOutputNums(layer);
	}
	return(count);
}
#endif

	.text
	.file	"hostAccesser.hip"
	.globl	_Z10setExecFlgi                 # -- Begin function _Z10setExecFlgi
	.type	_Z10setExecFlgi,@function
_Z10setExecFlgi:                        # @_Z10setExecFlgi
	.cfi_startproc
# %bb.0:
	movl	%edi, execFlg(%rip)
	retq
.Lfunc_end0:
	.size	_Z10setExecFlgi, .Lfunc_end0-_Z10setExecFlgi
	.cfi_endproc
                                        # -- End function
	.globl	_Z10getExecFlgv                 # -- Begin function _Z10getExecFlgv
	.type	_Z10getExecFlgv,@function
_Z10getExecFlgv:                        # @_Z10getExecFlgv
	.cfi_startproc
# %bb.0:
	movl	execFlg(%rip), %eax
	retq
.Lfunc_end1:
	.size	_Z10getExecFlgv, .Lfunc_end1-_Z10getExecFlgv
	.cfi_endproc
                                        # -- End function
	.globl	_Z18getExecFlgTrainingv         # -- Begin function _Z18getExecFlgTrainingv
	.type	_Z18getExecFlgTrainingv,@function
_Z18getExecFlgTrainingv:                # @_Z18getExecFlgTrainingv
	.cfi_startproc
# %bb.0:
	movl	execFlgTraining(%rip), %eax
	retq
.Lfunc_end2:
	.size	_Z18getExecFlgTrainingv, .Lfunc_end2-_Z18getExecFlgTrainingv
	.cfi_endproc
                                        # -- End function
	.globl	_Z16getExecFlgOnlinev           # -- Begin function _Z16getExecFlgOnlinev
	.type	_Z16getExecFlgOnlinev,@function
_Z16getExecFlgOnlinev:                  # @_Z16getExecFlgOnlinev
	.cfi_startproc
# %bb.0:
	movl	execFlgOnline(%rip), %eax
	retq
.Lfunc_end3:
	.size	_Z16getExecFlgOnlinev, .Lfunc_end3-_Z16getExecFlgOnlinev
	.cfi_endproc
                                        # -- End function
	.globl	_Z11setSv_xNumsi                # -- Begin function _Z11setSv_xNumsi
	.type	_Z11setSv_xNumsi,@function
_Z11setSv_xNumsi:                       # @_Z11setSv_xNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, sv_xNums(%rip)
	retq
.Lfunc_end4:
	.size	_Z11setSv_xNumsi, .Lfunc_end4-_Z11setSv_xNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z11getSv_xNumsv                # -- Begin function _Z11getSv_xNumsv
	.type	_Z11getSv_xNumsv,@function
_Z11getSv_xNumsv:                       # @_Z11getSv_xNumsv
	.cfi_startproc
# %bb.0:
	movl	sv_xNums(%rip), %eax
	retq
.Lfunc_end5:
	.size	_Z11getSv_xNumsv, .Lfunc_end5-_Z11getSv_xNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z11setSv_yNumsi                # -- Begin function _Z11setSv_yNumsi
	.type	_Z11setSv_yNumsi,@function
_Z11setSv_yNumsi:                       # @_Z11setSv_yNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, sv_yNums(%rip)
	retq
.Lfunc_end6:
	.size	_Z11setSv_yNumsi, .Lfunc_end6-_Z11setSv_yNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z11getSv_yNumsv                # -- Begin function _Z11getSv_yNumsv
	.type	_Z11getSv_yNumsv,@function
_Z11getSv_yNumsv:                       # @_Z11getSv_yNumsv
	.cfi_startproc
# %bb.0:
	movl	sv_yNums(%rip), %eax
	retq
.Lfunc_end7:
	.size	_Z11getSv_yNumsv, .Lfunc_end7-_Z11getSv_yNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z16setMiniBatchNumsi           # -- Begin function _Z16setMiniBatchNumsi
	.type	_Z16setMiniBatchNumsi,@function
_Z16setMiniBatchNumsi:                  # @_Z16setMiniBatchNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, miniBatchNums(%rip)
	retq
.Lfunc_end8:
	.size	_Z16setMiniBatchNumsi, .Lfunc_end8-_Z16setMiniBatchNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z16getMiniBatchNumsv           # -- Begin function _Z16getMiniBatchNumsv
	.type	_Z16getMiniBatchNumsv,@function
_Z16getMiniBatchNumsv:                  # @_Z16getMiniBatchNumsv
	.cfi_startproc
# %bb.0:
	movl	miniBatchNums(%rip), %eax
	retq
.Lfunc_end9:
	.size	_Z16getMiniBatchNumsv, .Lfunc_end9-_Z16getMiniBatchNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z16setSvChannelNumsi           # -- Begin function _Z16setSvChannelNumsi
	.type	_Z16setSvChannelNumsi,@function
_Z16setSvChannelNumsi:                  # @_Z16setSvChannelNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, svChannelNums(%rip)
	retq
.Lfunc_end10:
	.size	_Z16setSvChannelNumsi, .Lfunc_end10-_Z16setSvChannelNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z16getSvChannelNumsv           # -- Begin function _Z16getSvChannelNumsv
	.type	_Z16getSvChannelNumsv,@function
_Z16getSvChannelNumsv:                  # @_Z16getSvChannelNumsv
	.cfi_startproc
# %bb.0:
	movl	svChannelNums(%rip), %eax
	retq
.Lfunc_end11:
	.size	_Z16getSvChannelNumsv, .Lfunc_end11-_Z16getSvChannelNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z20setCnnOutputNumsNumsi       # -- Begin function _Z20setCnnOutputNumsNumsi
	.type	_Z20setCnnOutputNumsNumsi,@function
_Z20setCnnOutputNumsNumsi:              # @_Z20setCnnOutputNumsNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, cnnOutputNumsNums(%rip)
	retq
.Lfunc_end12:
	.size	_Z20setCnnOutputNumsNumsi, .Lfunc_end12-_Z20setCnnOutputNumsNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z20getCnnOutputNumsNumsv       # -- Begin function _Z20getCnnOutputNumsNumsv
	.type	_Z20getCnnOutputNumsNumsv,@function
_Z20getCnnOutputNumsNumsv:              # @_Z20getCnnOutputNumsNumsv
	.cfi_startproc
# %bb.0:
	movl	cnnOutputNumsNums(%rip), %eax
	retq
.Lfunc_end13:
	.size	_Z20getCnnOutputNumsNumsv, .Lfunc_end13-_Z20getCnnOutputNumsNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z16setCnnOutputNumsPi          # -- Begin function _Z16setCnnOutputNumsPi
	.type	_Z16setCnnOutputNumsPi,@function
_Z16setCnnOutputNumsPi:                 # @_Z16setCnnOutputNumsPi
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnOutputNums(%rip)
	retq
.Lfunc_end14:
	.size	_Z16setCnnOutputNumsPi, .Lfunc_end14-_Z16setCnnOutputNumsPi
	.cfi_endproc
                                        # -- End function
	.globl	_Z16getCnnOutputNumsi           # -- Begin function _Z16getCnnOutputNumsi
	.type	_Z16getCnnOutputNumsi,@function
_Z16getCnnOutputNumsi:                  # @_Z16getCnnOutputNumsi
	.cfi_startproc
# %bb.0:
	movq	cnnOutputNums(%rip), %rax
	movslq	%edi, %rcx
	movl	(%rax,%rcx,4), %eax
	retq
.Lfunc_end15:
	.size	_Z16getCnnOutputNumsi, .Lfunc_end15-_Z16getCnnOutputNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z12setCnnBnBetaPf              # -- Begin function _Z12setCnnBnBetaPf
	.type	_Z12setCnnBnBetaPf,@function
_Z12setCnnBnBetaPf:                     # @_Z12setCnnBnBetaPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnBnBeta(%rip)
	retq
.Lfunc_end16:
	.size	_Z12setCnnBnBetaPf, .Lfunc_end16-_Z12setCnnBnBetaPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z15setLearningRatef            # -- Begin function _Z15setLearningRatef
	.type	_Z15setLearningRatef,@function
_Z15setLearningRatef:                   # @_Z15setLearningRatef
	.cfi_startproc
# %bb.0:
	movss	%xmm0, learningRate(%rip)
	retq
.Lfunc_end17:
	.size	_Z15setLearningRatef, .Lfunc_end17-_Z15setLearningRatef
	.cfi_endproc
                                        # -- End function
	.globl	_Z15getLearningRatev            # -- Begin function _Z15getLearningRatev
	.type	_Z15getLearningRatev,@function
_Z15getLearningRatev:                   # @_Z15getLearningRatev
	.cfi_startproc
# %bb.0:
	movss	learningRate(%rip), %xmm0       # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end18:
	.size	_Z15getLearningRatev, .Lfunc_end18-_Z15getLearningRatev
	.cfi_endproc
                                        # -- End function
	.globl	_Z21getHCnnBnBetaGammaIdxii     # -- Begin function _Z21getHCnnBnBetaGammaIdxii
	.type	_Z21getHCnnBnBetaGammaIdxii,@function
_Z21getHCnnBnBetaGammaIdxii:            # @_Z21getHCnnBnBetaGammaIdxii
	.cfi_startproc
# %bb.0:
	testl	%esi, %esi
	jle	.LBB19_1
# %bb.3:                                # %.lr.ph
	movq	cnnOutputNums(%rip), %rcx
	movl	%esi, %edx
	xorl	%esi, %esi
	xorl	%eax, %eax
.LBB19_4:                               # =>This Inner Loop Header: Depth=1
	addl	(%rcx,%rsi,4), %eax
	incq	%rsi
	cmpq	%rsi, %rdx
	jne	.LBB19_4
	jmp	.LBB19_2
.LBB19_1:
	xorl	%eax, %eax
.LBB19_2:                               # %._crit_edge
	addl	%edi, %eax
	retq
.Lfunc_end19:
	.size	_Z21getHCnnBnBetaGammaIdxii, .Lfunc_end19-_Z21getHCnnBnBetaGammaIdxii
	.cfi_endproc
                                        # -- End function
	.globl	_Z12getCnnBnBetaii              # -- Begin function _Z12getCnnBnBetaii
	.type	_Z12getCnnBnBetaii,@function
_Z12getCnnBnBetaii:                     # @_Z12getCnnBnBetaii
	.cfi_startproc
# %bb.0:
	movq	cnnBnBeta(%rip), %rax
	testl	%esi, %esi
	jle	.LBB20_1
# %bb.2:                                # %.lr.ph.i
	movq	cnnOutputNums(%rip), %rdx
	movl	%esi, %esi
	xorl	%r8d, %r8d
	xorl	%ecx, %ecx
.LBB20_3:                               # =>This Inner Loop Header: Depth=1
	addl	(%rdx,%r8,4), %ecx
	incq	%r8
	cmpq	%r8, %rsi
	jne	.LBB20_3
	jmp	.LBB20_4
.LBB20_1:
	xorl	%ecx, %ecx
.LBB20_4:                               # %_Z21getHCnnBnBetaGammaIdxii.exit
	addl	%edi, %ecx
	movslq	%ecx, %rcx
	movss	(%rax,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end20:
	.size	_Z12getCnnBnBetaii, .Lfunc_end20-_Z12getCnnBnBetaii
	.cfi_endproc
                                        # -- End function
	.globl	_Z13setCnnBnGammaPf             # -- Begin function _Z13setCnnBnGammaPf
	.type	_Z13setCnnBnGammaPf,@function
_Z13setCnnBnGammaPf:                    # @_Z13setCnnBnGammaPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnBnGamma(%rip)
	retq
.Lfunc_end21:
	.size	_Z13setCnnBnGammaPf, .Lfunc_end21-_Z13setCnnBnGammaPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getCnnBnGammaii             # -- Begin function _Z13getCnnBnGammaii
	.type	_Z13getCnnBnGammaii,@function
_Z13getCnnBnGammaii:                    # @_Z13getCnnBnGammaii
	.cfi_startproc
# %bb.0:
	movq	cnnBnGamma(%rip), %rax
	testl	%esi, %esi
	jle	.LBB22_1
# %bb.2:                                # %.lr.ph.i
	movq	cnnOutputNums(%rip), %rdx
	movl	%esi, %esi
	xorl	%r8d, %r8d
	xorl	%ecx, %ecx
.LBB22_3:                               # =>This Inner Loop Header: Depth=1
	addl	(%rdx,%r8,4), %ecx
	incq	%r8
	cmpq	%r8, %rsi
	jne	.LBB22_3
	jmp	.LBB22_4
.LBB22_1:
	xorl	%ecx, %ecx
.LBB22_4:                               # %_Z21getHCnnBnBetaGammaIdxii.exit
	addl	%edi, %ecx
	movslq	%ecx, %rcx
	movss	(%rax,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end22:
	.size	_Z13getCnnBnGammaii, .Lfunc_end22-_Z13getCnnBnGammaii
	.cfi_endproc
                                        # -- End function
	.globl	_Z8setBnEpsf                    # -- Begin function _Z8setBnEpsf
	.type	_Z8setBnEpsf,@function
_Z8setBnEpsf:                           # @_Z8setBnEpsf
	.cfi_startproc
# %bb.0:
	movss	%xmm0, bnEps(%rip)
	retq
.Lfunc_end23:
	.size	_Z8setBnEpsf, .Lfunc_end23-_Z8setBnEpsf
	.cfi_endproc
                                        # -- End function
	.globl	_Z8getBnEpsv                    # -- Begin function _Z8getBnEpsv
	.type	_Z8getBnEpsv,@function
_Z8getBnEpsv:                           # @_Z8getBnEpsv
	.cfi_startproc
# %bb.0:
	movss	bnEps(%rip), %xmm0              # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end24:
	.size	_Z8getBnEpsv, .Lfunc_end24-_Z8getBnEpsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z13setCnnW_xNumsi              # -- Begin function _Z13setCnnW_xNumsi
	.type	_Z13setCnnW_xNumsi,@function
_Z13setCnnW_xNumsi:                     # @_Z13setCnnW_xNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, cnnW_xNums(%rip)
	retq
.Lfunc_end25:
	.size	_Z13setCnnW_xNumsi, .Lfunc_end25-_Z13setCnnW_xNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getCnnW_xNumsv              # -- Begin function _Z13getCnnW_xNumsv
	.type	_Z13getCnnW_xNumsv,@function
_Z13getCnnW_xNumsv:                     # @_Z13getCnnW_xNumsv
	.cfi_startproc
# %bb.0:
	movl	cnnW_xNums(%rip), %eax
	retq
.Lfunc_end26:
	.size	_Z13getCnnW_xNumsv, .Lfunc_end26-_Z13getCnnW_xNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z13setCnnW_yNumsi              # -- Begin function _Z13setCnnW_yNumsi
	.type	_Z13setCnnW_yNumsi,@function
_Z13setCnnW_yNumsi:                     # @_Z13setCnnW_yNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, cnnW_yNums(%rip)
	retq
.Lfunc_end27:
	.size	_Z13setCnnW_yNumsi, .Lfunc_end27-_Z13setCnnW_yNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getCnnW_yNumsv              # -- Begin function _Z13getCnnW_yNumsv
	.type	_Z13getCnnW_yNumsv,@function
_Z13getCnnW_yNumsv:                     # @_Z13getCnnW_yNumsv
	.cfi_startproc
# %bb.0:
	movl	cnnW_yNums(%rip), %eax
	retq
.Lfunc_end28:
	.size	_Z13getCnnW_yNumsv, .Lfunc_end28-_Z13getCnnW_yNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z15setCnnWDataNumsi            # -- Begin function _Z15setCnnWDataNumsi
	.type	_Z15setCnnWDataNumsi,@function
_Z15setCnnWDataNumsi:                   # @_Z15setCnnWDataNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, cnnWDataNums(%rip)
	retq
.Lfunc_end29:
	.size	_Z15setCnnWDataNumsi, .Lfunc_end29-_Z15setCnnWDataNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z15getCnnWDataNumsv            # -- Begin function _Z15getCnnWDataNumsv
	.type	_Z15getCnnWDataNumsv,@function
_Z15getCnnWDataNumsv:                   # @_Z15getCnnWDataNumsv
	.cfi_startproc
# %bb.0:
	movl	cnnWDataNums(%rip), %eax
	retq
.Lfunc_end30:
	.size	_Z15getCnnWDataNumsv, .Lfunc_end30-_Z15getCnnWDataNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z7setCnnWPf                    # -- Begin function _Z7setCnnWPf
	.type	_Z7setCnnWPf,@function
_Z7setCnnWPf:                           # @_Z7setCnnWPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnW(%rip)
	retq
.Lfunc_end31:
	.size	_Z7setCnnWPf, .Lfunc_end31-_Z7setCnnWPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z11getHCnnWIdxiiiii            # -- Begin function _Z11getHCnnWIdxiiiii
	.type	_Z11getHCnnWIdxiiiii,@function
_Z11getHCnnWIdxiiiii:                   # @_Z11getHCnnWIdxiiiii
	.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	%r13
	.cfi_def_cfa_offset 40
	pushq	%r12
	.cfi_def_cfa_offset 48
	pushq	%rbx
	.cfi_def_cfa_offset 56
	.cfi_offset %rbx, -56
	.cfi_offset %r12, -48
	.cfi_offset %r13, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	cnnOutputNums(%rip), %r11
	movl	cnnW_xNums(%rip), %r9d
	movl	cnnW_yNums(%rip), %r10d
	testl	%r8d, %r8d
	jle	.LBB32_1
# %bb.2:                                # %.lr.ph
	movl	%r10d, %ebx
	imull	%r9d, %ebx
	movl	%r8d, %r14d
	leaq	-4(%r11), %r12
	negq	%r14
	xorl	%r15d, %r15d
	movl	$svChannelNums, %r13d
	xorl	%eax, %eax
.LBB32_3:                               # =>This Inner Loop Header: Depth=1
	subq	$1, %r15
	movq	%r12, %rbp
	cmovbq	%r13, %rbp
	movl	(%rbp), %ebp
	imull	%ebx, %ebp
	imull	4(%r12), %ebp
	addq	$4, %r12
	addl	%ebp, %eax
	cmpq	%r15, %r14
	jne	.LBB32_3
	jmp	.LBB32_4
.LBB32_1:
	xorl	%eax, %eax
.LBB32_4:                               # %._crit_edge
	testl	%r8d, %r8d
	movslq	%r8d, %r8
	leaq	-4(%r11,%r8,4), %r8
	movl	$svChannelNums, %r11d
	cmovneq	%r8, %r11
	imull	(%r11), %ecx
	addl	%edx, %ecx
	imull	%r10d, %ecx
	addl	%esi, %ecx
	imull	%r9d, %ecx
	addl	%edi, %eax
	addl	%ecx, %eax
	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
.Lfunc_end32:
	.size	_Z11getHCnnWIdxiiiii, .Lfunc_end32-_Z11getHCnnWIdxiiiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z18getCnnInputIdxNumsi         # -- Begin function _Z18getCnnInputIdxNumsi
	.type	_Z18getCnnInputIdxNumsi,@function
_Z18getCnnInputIdxNumsi:                # @_Z18getCnnInputIdxNumsi
	.cfi_startproc
# %bb.0:
	testl	%edi, %edi
	movq	cnnOutputNums(%rip), %rax
	movslq	%edi, %rcx
	leaq	-4(%rax,%rcx,4), %rax
	movl	$svChannelNums, %ecx
	cmovneq	%rax, %rcx
	movl	(%rcx), %eax
	retq
.Lfunc_end33:
	.size	_Z18getCnnInputIdxNumsi, .Lfunc_end33-_Z18getCnnInputIdxNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z10getDim4Idxiiiiiii           # -- Begin function _Z10getDim4Idxiiiiiii
	.type	_Z10getDim4Idxiiiiiii,@function
_Z10getDim4Idxiiiiiii:                  # @_Z10getDim4Idxiiiiiii
	.cfi_startproc
# %bb.0:
                                        # kill: def $ecx killed $ecx def $rcx
                                        # kill: def $edx killed $edx def $rdx
	imull	8(%rsp), %ecx
	leal	(%rcx,%rdx), %eax
	imull	%r9d, %eax
	addl	%esi, %eax
	imull	%r8d, %eax
	addl	%edi, %eax
	retq
.Lfunc_end34:
	.size	_Z10getDim4Idxiiiiiii, .Lfunc_end34-_Z10getDim4Idxiiiiiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z7getCnnWiiiii                 # -- Begin function _Z7getCnnWiiiii
	.type	_Z7getCnnWiiiii,@function
_Z7getCnnWiiiii:                        # @_Z7getCnnWiiiii
	.cfi_startproc
# %bb.0:
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset %rbx, -16
	movq	cnnW(%rip), %rbx
	callq	_Z11getHCnnWIdxiiiii
	cltq
	movss	(%rbx,%rax,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	popq	%rbx
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end35:
	.size	_Z7getCnnWiiiii, .Lfunc_end35-_Z7getCnnWiiiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z15setCnnWba_xNumsPi           # -- Begin function _Z15setCnnWba_xNumsPi
	.type	_Z15setCnnWba_xNumsPi,@function
_Z15setCnnWba_xNumsPi:                  # @_Z15setCnnWba_xNumsPi
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnWba_xNums(%rip)
	retq
.Lfunc_end36:
	.size	_Z15setCnnWba_xNumsPi, .Lfunc_end36-_Z15setCnnWba_xNumsPi
	.cfi_endproc
                                        # -- End function
	.globl	_Z15getCnnWba_xNumsi            # -- Begin function _Z15getCnnWba_xNumsi
	.type	_Z15getCnnWba_xNumsi,@function
_Z15getCnnWba_xNumsi:                   # @_Z15getCnnWba_xNumsi
	.cfi_startproc
# %bb.0:
	movq	cnnWba_xNums(%rip), %rax
	movslq	%edi, %rcx
	movl	(%rax,%rcx,4), %eax
	retq
.Lfunc_end37:
	.size	_Z15getCnnWba_xNumsi, .Lfunc_end37-_Z15getCnnWba_xNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z15setCnnWba_yNumsPi           # -- Begin function _Z15setCnnWba_yNumsPi
	.type	_Z15setCnnWba_yNumsPi,@function
_Z15setCnnWba_yNumsPi:                  # @_Z15setCnnWba_yNumsPi
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnWba_yNums(%rip)
	retq
.Lfunc_end38:
	.size	_Z15setCnnWba_yNumsPi, .Lfunc_end38-_Z15setCnnWba_yNumsPi
	.cfi_endproc
                                        # -- End function
	.globl	_Z15getCnnWba_yNumsi            # -- Begin function _Z15getCnnWba_yNumsi
	.type	_Z15getCnnWba_yNumsi,@function
_Z15getCnnWba_yNumsi:                   # @_Z15getCnnWba_yNumsi
	.cfi_startproc
# %bb.0:
	movq	cnnWba_yNums(%rip), %rax
	movslq	%edi, %rcx
	movl	(%rax,%rcx,4), %eax
	retq
.Lfunc_end39:
	.size	_Z15getCnnWba_yNumsi, .Lfunc_end39-_Z15getCnnWba_yNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getHCnnWbaIdxiiiii          # -- Begin function _Z13getHCnnWbaIdxiiiii
	.type	_Z13getHCnnWbaIdxiiiii,@function
_Z13getHCnnWbaIdxiiiii:                 # @_Z13getHCnnWbaIdxiiiii
	.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
	.cfi_offset %rbx, -40
	.cfi_offset %r14, -32
	.cfi_offset %r15, -24
	.cfi_offset %rbp, -16
	movq	cnnWba_xNums(%rip), %r9
	movq	cnnWba_yNums(%rip), %r10
	movq	cnnOutputNums(%rip), %r11
	testl	%r8d, %r8d
	jle	.LBB40_1
# %bb.2:                                # %.lr.ph
	movl	miniBatchNums(%rip), %ebx
	movl	%r8d, %r14d
	xorl	%r15d, %r15d
	xorl	%eax, %eax
.LBB40_3:                               # =>This Inner Loop Header: Depth=1
	movl	(%r10,%r15,4), %ebp
	imull	(%r9,%r15,4), %ebp
	imull	(%r11,%r15,4), %ebp
	imull	%ebx, %ebp
	addl	%ebp, %eax
	incq	%r15
	cmpq	%r15, %r14
	jne	.LBB40_3
	jmp	.LBB40_4
.LBB40_1:
	xorl	%eax, %eax
.LBB40_4:                               # %._crit_edge
	movslq	%r8d, %r8
	imull	(%r11,%r8,4), %ecx
	addl	%edx, %ecx
	imull	(%r10,%r8,4), %ecx
	addl	%esi, %ecx
	imull	(%r9,%r8,4), %ecx
	addl	%edi, %eax
	addl	%ecx, %eax
	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
	retq
.Lfunc_end40:
	.size	_Z13getHCnnWbaIdxiiiii, .Lfunc_end40-_Z13getHCnnWbaIdxiiiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z13setCnnP_xNumsPi             # -- Begin function _Z13setCnnP_xNumsPi
	.type	_Z13setCnnP_xNumsPi,@function
_Z13setCnnP_xNumsPi:                    # @_Z13setCnnP_xNumsPi
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnP_xNums(%rip)
	retq
.Lfunc_end41:
	.size	_Z13setCnnP_xNumsPi, .Lfunc_end41-_Z13setCnnP_xNumsPi
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getCnnP_xNumsi              # -- Begin function _Z13getCnnP_xNumsi
	.type	_Z13getCnnP_xNumsi,@function
_Z13getCnnP_xNumsi:                     # @_Z13getCnnP_xNumsi
	.cfi_startproc
# %bb.0:
	movq	cnnP_xNums(%rip), %rax
	movslq	%edi, %rcx
	movl	(%rax,%rcx,4), %eax
	retq
.Lfunc_end42:
	.size	_Z13getCnnP_xNumsi, .Lfunc_end42-_Z13getCnnP_xNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z13setCnnP_yNumsPi             # -- Begin function _Z13setCnnP_yNumsPi
	.type	_Z13setCnnP_yNumsPi,@function
_Z13setCnnP_yNumsPi:                    # @_Z13setCnnP_yNumsPi
	.cfi_startproc
# %bb.0:
	movq	%rdi, cnnP_yNums(%rip)
	retq
.Lfunc_end43:
	.size	_Z13setCnnP_yNumsPi, .Lfunc_end43-_Z13setCnnP_yNumsPi
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getCnnP_yNumsi              # -- Begin function _Z13getCnnP_yNumsi
	.type	_Z13getCnnP_yNumsi,@function
_Z13getCnnP_yNumsi:                     # @_Z13getCnnP_yNumsi
	.cfi_startproc
# %bb.0:
	movq	cnnP_yNums(%rip), %rax
	movslq	%edi, %rcx
	movl	(%rax,%rcx,4), %eax
	retq
.Lfunc_end44:
	.size	_Z13getCnnP_yNumsi, .Lfunc_end44-_Z13getCnnP_yNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z19setCnnPooling_xNumsi        # -- Begin function _Z19setCnnPooling_xNumsi
	.type	_Z19setCnnPooling_xNumsi,@function
_Z19setCnnPooling_xNumsi:               # @_Z19setCnnPooling_xNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, cnnPooling_xNums(%rip)
	retq
.Lfunc_end45:
	.size	_Z19setCnnPooling_xNumsi, .Lfunc_end45-_Z19setCnnPooling_xNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z19getCnnPooling_xNumsv        # -- Begin function _Z19getCnnPooling_xNumsv
	.type	_Z19getCnnPooling_xNumsv,@function
_Z19getCnnPooling_xNumsv:               # @_Z19getCnnPooling_xNumsv
	.cfi_startproc
# %bb.0:
	movl	cnnPooling_xNums(%rip), %eax
	retq
.Lfunc_end46:
	.size	_Z19getCnnPooling_xNumsv, .Lfunc_end46-_Z19getCnnPooling_xNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z19setCnnPooling_yNumsi        # -- Begin function _Z19setCnnPooling_yNumsi
	.type	_Z19setCnnPooling_yNumsi,@function
_Z19setCnnPooling_yNumsi:               # @_Z19setCnnPooling_yNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, cnnPooling_yNums(%rip)
	retq
.Lfunc_end47:
	.size	_Z19setCnnPooling_yNumsi, .Lfunc_end47-_Z19setCnnPooling_yNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z19getCnnPooling_yNumsv        # -- Begin function _Z19getCnnPooling_yNumsv
	.type	_Z19getCnnPooling_yNumsv,@function
_Z19getCnnPooling_yNumsv:               # @_Z19getCnnPooling_yNumsv
	.cfi_startproc
# %bb.0:
	movl	cnnPooling_yNums(%rip), %eax
	retq
.Lfunc_end48:
	.size	_Z19getCnnPooling_yNumsv, .Lfunc_end48-_Z19getCnnPooling_yNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z20setMlpOutputNumsNumsi       # -- Begin function _Z20setMlpOutputNumsNumsi
	.type	_Z20setMlpOutputNumsNumsi,@function
_Z20setMlpOutputNumsNumsi:              # @_Z20setMlpOutputNumsNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, mlpOutputNumsNums(%rip)
	retq
.Lfunc_end49:
	.size	_Z20setMlpOutputNumsNumsi, .Lfunc_end49-_Z20setMlpOutputNumsNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z20getMlpOutputNumsNumsv       # -- Begin function _Z20getMlpOutputNumsNumsv
	.type	_Z20getMlpOutputNumsNumsv,@function
_Z20getMlpOutputNumsNumsv:              # @_Z20getMlpOutputNumsNumsv
	.cfi_startproc
# %bb.0:
	movl	mlpOutputNumsNums(%rip), %eax
	retq
.Lfunc_end50:
	.size	_Z20getMlpOutputNumsNumsv, .Lfunc_end50-_Z20getMlpOutputNumsNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z16setMlpOutputNumsPi          # -- Begin function _Z16setMlpOutputNumsPi
	.type	_Z16setMlpOutputNumsPi,@function
_Z16setMlpOutputNumsPi:                 # @_Z16setMlpOutputNumsPi
	.cfi_startproc
# %bb.0:
	movq	%rdi, mlpOutputNums(%rip)
	retq
.Lfunc_end51:
	.size	_Z16setMlpOutputNumsPi, .Lfunc_end51-_Z16setMlpOutputNumsPi
	.cfi_endproc
                                        # -- End function
	.globl	_Z16getMlpOutputNumsi           # -- Begin function _Z16getMlpOutputNumsi
	.type	_Z16getMlpOutputNumsi,@function
_Z16getMlpOutputNumsi:                  # @_Z16getMlpOutputNumsi
	.cfi_startproc
# %bb.0:
	movq	mlpOutputNums(%rip), %rax
	movslq	%edi, %rcx
	movl	(%rax,%rcx,4), %eax
	retq
.Lfunc_end52:
	.size	_Z16getMlpOutputNumsi, .Lfunc_end52-_Z16getMlpOutputNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z12setMlpBnBetaPf              # -- Begin function _Z12setMlpBnBetaPf
	.type	_Z12setMlpBnBetaPf,@function
_Z12setMlpBnBetaPf:                     # @_Z12setMlpBnBetaPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, mlpBnBeta(%rip)
	retq
.Lfunc_end53:
	.size	_Z12setMlpBnBetaPf, .Lfunc_end53-_Z12setMlpBnBetaPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z21getHMlpBnBetaGammaIdxii     # -- Begin function _Z21getHMlpBnBetaGammaIdxii
	.type	_Z21getHMlpBnBetaGammaIdxii,@function
_Z21getHMlpBnBetaGammaIdxii:            # @_Z21getHMlpBnBetaGammaIdxii
	.cfi_startproc
# %bb.0:
	testl	%esi, %esi
	jle	.LBB54_1
# %bb.3:                                # %.lr.ph
	movq	mlpOutputNums(%rip), %rcx
	movl	%esi, %edx
	xorl	%esi, %esi
	xorl	%eax, %eax
.LBB54_4:                               # =>This Inner Loop Header: Depth=1
	addl	(%rcx,%rsi,4), %eax
	incq	%rsi
	cmpq	%rsi, %rdx
	jne	.LBB54_4
	jmp	.LBB54_2
.LBB54_1:
	xorl	%eax, %eax
.LBB54_2:                               # %._crit_edge
	addl	%edi, %eax
	retq
.Lfunc_end54:
	.size	_Z21getHMlpBnBetaGammaIdxii, .Lfunc_end54-_Z21getHMlpBnBetaGammaIdxii
	.cfi_endproc
                                        # -- End function
	.globl	_Z12getMlpBnBetaii              # -- Begin function _Z12getMlpBnBetaii
	.type	_Z12getMlpBnBetaii,@function
_Z12getMlpBnBetaii:                     # @_Z12getMlpBnBetaii
	.cfi_startproc
# %bb.0:
	movq	mlpBnBeta(%rip), %rax
	testl	%esi, %esi
	jle	.LBB55_1
# %bb.2:                                # %.lr.ph.i
	movq	mlpOutputNums(%rip), %rdx
	movl	%esi, %esi
	xorl	%r8d, %r8d
	xorl	%ecx, %ecx
.LBB55_3:                               # =>This Inner Loop Header: Depth=1
	addl	(%rdx,%r8,4), %ecx
	incq	%r8
	cmpq	%r8, %rsi
	jne	.LBB55_3
	jmp	.LBB55_4
.LBB55_1:
	xorl	%ecx, %ecx
.LBB55_4:                               # %_Z21getHMlpBnBetaGammaIdxii.exit
	addl	%edi, %ecx
	movslq	%ecx, %rcx
	movss	(%rax,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end55:
	.size	_Z12getMlpBnBetaii, .Lfunc_end55-_Z12getMlpBnBetaii
	.cfi_endproc
                                        # -- End function
	.globl	_Z13setMlpBnGammaPf             # -- Begin function _Z13setMlpBnGammaPf
	.type	_Z13setMlpBnGammaPf,@function
_Z13setMlpBnGammaPf:                    # @_Z13setMlpBnGammaPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, mlpBnGamma(%rip)
	retq
.Lfunc_end56:
	.size	_Z13setMlpBnGammaPf, .Lfunc_end56-_Z13setMlpBnGammaPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getMlpBnGammaii             # -- Begin function _Z13getMlpBnGammaii
	.type	_Z13getMlpBnGammaii,@function
_Z13getMlpBnGammaii:                    # @_Z13getMlpBnGammaii
	.cfi_startproc
# %bb.0:
	movq	mlpBnGamma(%rip), %rax
	testl	%esi, %esi
	jle	.LBB57_1
# %bb.2:                                # %.lr.ph.i
	movq	mlpOutputNums(%rip), %rdx
	movl	%esi, %esi
	xorl	%r8d, %r8d
	xorl	%ecx, %ecx
.LBB57_3:                               # =>This Inner Loop Header: Depth=1
	addl	(%rdx,%r8,4), %ecx
	incq	%r8
	cmpq	%r8, %rsi
	jne	.LBB57_3
	jmp	.LBB57_4
.LBB57_1:
	xorl	%ecx, %ecx
.LBB57_4:                               # %_Z21getHMlpBnBetaGammaIdxii.exit
	addl	%edi, %ecx
	movslq	%ecx, %rcx
	movss	(%rax,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end57:
	.size	_Z13getMlpBnGammaii, .Lfunc_end57-_Z13getMlpBnGammaii
	.cfi_endproc
                                        # -- End function
	.globl	_Z15setMlpWDataNumsi            # -- Begin function _Z15setMlpWDataNumsi
	.type	_Z15setMlpWDataNumsi,@function
_Z15setMlpWDataNumsi:                   # @_Z15setMlpWDataNumsi
	.cfi_startproc
# %bb.0:
	movl	%edi, mlpWDataNums(%rip)
	retq
.Lfunc_end58:
	.size	_Z15setMlpWDataNumsi, .Lfunc_end58-_Z15setMlpWDataNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z15getMlpWDataNumsv            # -- Begin function _Z15getMlpWDataNumsv
	.type	_Z15getMlpWDataNumsv,@function
_Z15getMlpWDataNumsv:                   # @_Z15getMlpWDataNumsv
	.cfi_startproc
# %bb.0:
	movl	mlpWDataNums(%rip), %eax
	retq
.Lfunc_end59:
	.size	_Z15getMlpWDataNumsv, .Lfunc_end59-_Z15getMlpWDataNumsv
	.cfi_endproc
                                        # -- End function
	.globl	_Z7setMlpWPf                    # -- Begin function _Z7setMlpWPf
	.type	_Z7setMlpWPf,@function
_Z7setMlpWPf:                           # @_Z7setMlpWPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, mlpW(%rip)
	retq
.Lfunc_end60:
	.size	_Z7setMlpWPf, .Lfunc_end60-_Z7setMlpWPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z11getHMlpWIdxiii              # -- Begin function _Z11getHMlpWIdxiii
	.type	_Z11getHMlpWIdxiii,@function
_Z11getHMlpWIdxiii:                     # @_Z11getHMlpWIdxiii
	.cfi_startproc
# %bb.0:
	pushq	%rbp
	.cfi_def_cfa_offset 16
	pushq	%r14
	.cfi_def_cfa_offset 24
	pushq	%rbx
	.cfi_def_cfa_offset 32
	.cfi_offset %rbx, -32
	.cfi_offset %r14, -24
	.cfi_offset %rbp, -16
	testl	%edx, %edx
	jle	.LBB61_1
# %bb.2:                                # %.lr.ph
	movq	mlpOutputNums(%rip), %rcx
	movslq	cnnOutputNumsNums(%rip), %r8
	movq	cnnP_xNums(%rip), %r9
	movq	cnnP_yNums(%rip), %r10
	movq	cnnOutputNums(%rip), %r11
	movl	%edx, %ebx
	xorl	%r14d, %r14d
	xorl	%eax, %eax
.LBB61_3:                               # =>This Inner Loop Header: Depth=1
	testq	%r14, %r14
	je	.LBB61_4
# %bb.5:                                #   in Loop: Header=BB61_3 Depth=1
	movl	-4(%rcx,%r14,4), %ebp
	jmp	.LBB61_6
.LBB61_4:                               #   in Loop: Header=BB61_3 Depth=1
	movl	-4(%r10,%r8,4), %ebp
	imull	-4(%r9,%r8,4), %ebp
	imull	-4(%r11,%r8,4), %ebp
.LBB61_6:                               # %_Z18getMlpInputIdxNumsi.exit
                                        #   in Loop: Header=BB61_3 Depth=1
	imull	(%rcx,%r14,4), %ebp
	addl	%ebp, %eax
	incq	%r14
	cmpq	%r14, %rbx
	jne	.LBB61_3
	jmp	.LBB61_7
.LBB61_1:
	xorl	%eax, %eax
.LBB61_7:                               # %._crit_edge
	testl	%edx, %edx
	je	.LBB61_8
# %bb.9:
	movq	mlpOutputNums(%rip), %rcx
	movslq	%edx, %rdx
	movl	-4(%rcx,%rdx,4), %ecx
	jmp	.LBB61_10
.LBB61_8:
	movslq	cnnOutputNumsNums(%rip), %rdx
	movq	cnnP_xNums(%rip), %r8
	movq	cnnP_yNums(%rip), %rcx
	movl	-4(%rcx,%rdx,4), %ecx
	imull	-4(%r8,%rdx,4), %ecx
	movq	cnnOutputNums(%rip), %r8
	imull	-4(%r8,%rdx,4), %ecx
.LBB61_10:                              # %_Z18getMlpInputIdxNumsi.exit15
	imull	%esi, %ecx
	addl	%edi, %eax
	addl	%ecx, %eax
	popq	%rbx
	.cfi_def_cfa_offset 24
	popq	%r14
	.cfi_def_cfa_offset 16
	popq	%rbp
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end61:
	.size	_Z11getHMlpWIdxiii, .Lfunc_end61-_Z11getHMlpWIdxiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z18getMlpInputIdxNumsi         # -- Begin function _Z18getMlpInputIdxNumsi
	.type	_Z18getMlpInputIdxNumsi,@function
_Z18getMlpInputIdxNumsi:                # @_Z18getMlpInputIdxNumsi
	.cfi_startproc
# %bb.0:
	testl	%edi, %edi
	je	.LBB62_1
# %bb.2:
	movq	mlpOutputNums(%rip), %rax
	movslq	%edi, %rcx
	movl	-4(%rax,%rcx,4), %eax
	retq
.LBB62_1:
	movslq	cnnOutputNumsNums(%rip), %rcx
	movq	cnnP_xNums(%rip), %rdx
	movq	cnnP_yNums(%rip), %rax
	movl	-4(%rax,%rcx,4), %eax
	imull	-4(%rdx,%rcx,4), %eax
	movq	cnnOutputNums(%rip), %rdx
	imull	-4(%rdx,%rcx,4), %eax
	retq
.Lfunc_end62:
	.size	_Z18getMlpInputIdxNumsi, .Lfunc_end62-_Z18getMlpInputIdxNumsi
	.cfi_endproc
                                        # -- End function
	.globl	_Z10getDim2Idxiii               # -- Begin function _Z10getDim2Idxiii
	.type	_Z10getDim2Idxiii,@function
_Z10getDim2Idxiii:                      # @_Z10getDim2Idxiii
	.cfi_startproc
# %bb.0:
                                        # kill: def $esi killed $esi def $rsi
                                        # kill: def $edi killed $edi def $rdi
	imull	%edx, %esi
	leal	(%rsi,%rdi), %eax
	retq
.Lfunc_end63:
	.size	_Z10getDim2Idxiii, .Lfunc_end63-_Z10getDim2Idxiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z7getMlpWiii                   # -- Begin function _Z7getMlpWiii
	.type	_Z7getMlpWiii,@function
_Z7getMlpWiii:                          # @_Z7getMlpWiii
	.cfi_startproc
# %bb.0:
	pushq	%rbx
	.cfi_def_cfa_offset 16
	.cfi_offset %rbx, -16
	movq	mlpW(%rip), %rbx
	callq	_Z11getHMlpWIdxiii
	cltq
	movss	(%rbx,%rax,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	popq	%rbx
	.cfi_def_cfa_offset 8
	retq
.Lfunc_end64:
	.size	_Z7getMlpWiii, .Lfunc_end64-_Z7getMlpWiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z13getHMlpWbaIdxiii            # -- Begin function _Z13getHMlpWbaIdxiii
	.type	_Z13getHMlpWbaIdxiii,@function
_Z13getHMlpWbaIdxiii:                   # @_Z13getHMlpWbaIdxiii
	.cfi_startproc
# %bb.0:
	movq	mlpOutputNums(%rip), %rcx
	testl	%edx, %edx
	jle	.LBB65_1
# %bb.2:                                # %.lr.ph
	movl	miniBatchNums(%rip), %r8d
	movl	%edx, %r9d
	xorl	%r10d, %r10d
	xorl	%eax, %eax
.LBB65_3:                               # =>This Inner Loop Header: Depth=1
	movl	(%rcx,%r10,4), %r11d
	imull	%r8d, %r11d
	addl	%r11d, %eax
	incq	%r10
	cmpq	%r10, %r9
	jne	.LBB65_3
	jmp	.LBB65_4
.LBB65_1:
	xorl	%eax, %eax
.LBB65_4:                               # %._crit_edge
	movslq	%edx, %rdx
	imull	(%rcx,%rdx,4), %esi
	addl	%edi, %eax
	addl	%esi, %eax
	retq
.Lfunc_end65:
	.size	_Z13getHMlpWbaIdxiii, .Lfunc_end65-_Z13getHMlpWbaIdxiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z9setResultPf                  # -- Begin function _Z9setResultPf
	.type	_Z9setResultPf,@function
_Z9setResultPf:                         # @_Z9setResultPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, result(%rip)
	retq
.Lfunc_end66:
	.size	_Z9setResultPf, .Lfunc_end66-_Z9setResultPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z11setTeachOutPf               # -- Begin function _Z11setTeachOutPf
	.type	_Z11setTeachOutPf,@function
_Z11setTeachOutPf:                      # @_Z11setTeachOutPf
	.cfi_startproc
# %bb.0:
	movq	%rdi, teachOut(%rip)
	retq
.Lfunc_end67:
	.size	_Z11setTeachOutPf, .Lfunc_end67-_Z11setTeachOutPf
	.cfi_endproc
                                        # -- End function
	.globl	_Z20getTeachOutResultIdxii      # -- Begin function _Z20getTeachOutResultIdxii
	.type	_Z20getTeachOutResultIdxii,@function
_Z20getTeachOutResultIdxii:             # @_Z20getTeachOutResultIdxii
	.cfi_startproc
# %bb.0:
                                        # kill: def $esi killed $esi def $rsi
                                        # kill: def $edi killed $edi def $rdi
	movslq	mlpOutputNumsNums(%rip), %rax
	movq	mlpOutputNums(%rip), %rcx
	imull	-4(%rcx,%rax,4), %esi
	leal	(%rsi,%rdi), %eax
	retq
.Lfunc_end68:
	.size	_Z20getTeachOutResultIdxii, .Lfunc_end68-_Z20getTeachOutResultIdxii
	.cfi_endproc
                                        # -- End function
	.globl	_Z9getResultii                  # -- Begin function _Z9getResultii
	.type	_Z9getResultii,@function
_Z9getResultii:                         # @_Z9getResultii
	.cfi_startproc
# %bb.0:
	movq	result(%rip), %rax
	movslq	mlpOutputNumsNums(%rip), %rcx
	movq	mlpOutputNums(%rip), %rdx
	imull	-4(%rdx,%rcx,4), %esi
	addl	%edi, %esi
	movslq	%esi, %rcx
	movss	(%rax,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end69:
	.size	_Z9getResultii, .Lfunc_end69-_Z9getResultii
	.cfi_endproc
                                        # -- End function
	.globl	_Z11getTeachOutii               # -- Begin function _Z11getTeachOutii
	.type	_Z11getTeachOutii,@function
_Z11getTeachOutii:                      # @_Z11getTeachOutii
	.cfi_startproc
# %bb.0:
	movq	teachOut(%rip), %rax
	movslq	mlpOutputNumsNums(%rip), %rcx
	movq	mlpOutputNums(%rip), %rdx
	imull	-4(%rdx,%rcx,4), %esi
	addl	%edi, %esi
	movslq	%esi, %rcx
	movss	(%rax,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
	retq
.Lfunc_end70:
	.size	_Z11getTeachOutii, .Lfunc_end70-_Z11getTeachOutii
	.cfi_endproc
                                        # -- End function
	.globl	_Z10getDim3Idxiiiii             # -- Begin function _Z10getDim3Idxiiiii
	.type	_Z10getDim3Idxiiiii,@function
_Z10getDim3Idxiiiii:                    # @_Z10getDim3Idxiiiii
	.cfi_startproc
# %bb.0:
                                        # kill: def $edx killed $edx def $rdx
                                        # kill: def $esi killed $esi def $rsi
	imull	%r8d, %edx
	leal	(%rdx,%rsi), %eax
	imull	%ecx, %eax
	addl	%edi, %eax
	retq
.Lfunc_end71:
	.size	_Z10getDim3Idxiiiii, .Lfunc_end71-_Z10getDim3Idxiiiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z10getDim5Idxiiiiiiiii         # -- Begin function _Z10getDim5Idxiiiiiiiii
	.type	_Z10getDim5Idxiiiiiiiii,@function
_Z10getDim5Idxiiiiiiiii:                # @_Z10getDim5Idxiiiiiiiii
	.cfi_startproc
# %bb.0:
                                        # kill: def $r8d killed $r8d def $r8
                                        # kill: def $ecx killed $ecx def $rcx
	imull	24(%rsp), %r8d
	leal	(%r8,%rcx), %eax
	imull	16(%rsp), %eax
	addl	%edx, %eax
	imull	8(%rsp), %eax
	addl	%esi, %eax
	imull	%r9d, %eax
	addl	%edi, %eax
	retq
.Lfunc_end72:
	.size	_Z10getDim5Idxiiiiiiiii, .Lfunc_end72-_Z10getDim5Idxiiiiiiiii
	.cfi_endproc
                                        # -- End function
	.globl	_Z19getCnnOutputNumsSumv        # -- Begin function _Z19getCnnOutputNumsSumv
	.type	_Z19getCnnOutputNumsSumv,@function
_Z19getCnnOutputNumsSumv:               # @_Z19getCnnOutputNumsSumv
	.cfi_startproc
# %bb.0:
	movl	cnnOutputNumsNums(%rip), %ecx
	testl	%ecx, %ecx
	jle	.LBB73_1
# %bb.3:                                # %.lr.ph
	xorl	%edx, %edx
	movq	cnnOutputNums(%rip), %rsi
	xorl	%eax, %eax
.LBB73_4:                               # =>This Inner Loop Header: Depth=1
	addl	(%rsi,%rdx,4), %eax
	incq	%rdx
	cmpq	%rdx, %rcx
	jne	.LBB73_4
# %bb.2:                                # %._crit_edge
	retq
.LBB73_1:
	xorl	%eax, %eax
	retq
.Lfunc_end73:
	.size	_Z19getCnnOutputNumsSumv, .Lfunc_end73-_Z19getCnnOutputNumsSumv
	.cfi_endproc
                                        # -- End function
	.globl	_Z19getMlpOutputNumsSumv        # -- Begin function _Z19getMlpOutputNumsSumv
	.type	_Z19getMlpOutputNumsSumv,@function
_Z19getMlpOutputNumsSumv:               # @_Z19getMlpOutputNumsSumv
	.cfi_startproc
# %bb.0:
	movl	mlpOutputNumsNums(%rip), %ecx
	testl	%ecx, %ecx
	jle	.LBB74_1
# %bb.3:                                # %.lr.ph
	xorl	%edx, %edx
	movq	mlpOutputNums(%rip), %rsi
	xorl	%eax, %eax
.LBB74_4:                               # =>This Inner Loop Header: Depth=1
	addl	(%rsi,%rdx,4), %eax
	incq	%rdx
	cmpq	%rdx, %rcx
	jne	.LBB74_4
# %bb.2:                                # %._crit_edge
	retq
.LBB74_1:
	xorl	%eax, %eax
	retq
.Lfunc_end74:
	.size	_Z19getMlpOutputNumsSumv, .Lfunc_end74-_Z19getMlpOutputNumsSumv
	.cfi_endproc
                                        # -- End function
	.type	cnnOutputNumsNums,@object       # @cnnOutputNumsNums
	.bss
	.globl	cnnOutputNumsNums
	.p2align	2, 0x0
cnnOutputNumsNums:
	.long	0                               # 0x0
	.size	cnnOutputNumsNums, 4

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

	.type	execFlg,@object                 # @execFlg
	.globl	execFlg
	.p2align	2, 0x0
execFlg:
	.long	0                               # 0x0
	.size	execFlg, 4

	.type	execFlgTraining,@object         # @execFlgTraining
	.globl	execFlgTraining
	.p2align	2, 0x0
execFlgTraining:
	.long	0                               # 0x0
	.size	execFlgTraining, 4

	.type	execFlgOnline,@object           # @execFlgOnline
	.data
	.globl	execFlgOnline
	.p2align	2, 0x0
execFlgOnline:
	.long	1                               # 0x1
	.size	execFlgOnline, 4

	.type	sv_xNums,@object                # @sv_xNums
	.bss
	.globl	sv_xNums
	.p2align	2, 0x0
sv_xNums:
	.long	0                               # 0x0
	.size	sv_xNums, 4

	.type	sv_yNums,@object                # @sv_yNums
	.globl	sv_yNums
	.p2align	2, 0x0
sv_yNums:
	.long	0                               # 0x0
	.size	sv_yNums, 4

	.type	svChannelNums,@object           # @svChannelNums
	.globl	svChannelNums
	.p2align	2, 0x0
svChannelNums:
	.long	0                               # 0x0
	.size	svChannelNums, 4

	.type	miniBatchNums,@object           # @miniBatchNums
	.globl	miniBatchNums
	.p2align	2, 0x0
miniBatchNums:
	.long	0                               # 0x0
	.size	miniBatchNums, 4

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

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

	.type	bnEps,@object                   # @bnEps
	.globl	bnEps
	.p2align	2, 0x0
bnEps:
	.long	0x00000000                      # float 0
	.size	bnEps, 4

	.type	cnnW_xNums,@object              # @cnnW_xNums
	.globl	cnnW_xNums
	.p2align	2, 0x0
cnnW_xNums:
	.long	0                               # 0x0
	.size	cnnW_xNums, 4

	.type	cnnW_yNums,@object              # @cnnW_yNums
	.globl	cnnW_yNums
	.p2align	2, 0x0
cnnW_yNums:
	.long	0                               # 0x0
	.size	cnnW_yNums, 4

	.type	cnnWDataNums,@object            # @cnnWDataNums
	.globl	cnnWDataNums
	.p2align	2, 0x0
cnnWDataNums:
	.long	0                               # 0x0
	.size	cnnWDataNums, 4

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

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

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

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

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

	.type	cnnPooling_xNums,@object        # @cnnPooling_xNums
	.globl	cnnPooling_xNums
	.p2align	2, 0x0
cnnPooling_xNums:
	.long	0                               # 0x0
	.size	cnnPooling_xNums, 4

	.type	cnnPooling_yNums,@object        # @cnnPooling_yNums
	.globl	cnnPooling_yNums
	.p2align	2, 0x0
cnnPooling_yNums:
	.long	0                               # 0x0
	.size	cnnPooling_yNums, 4

	.type	mlpOutputNumsNums,@object       # @mlpOutputNumsNums
	.globl	mlpOutputNumsNums
	.p2align	2, 0x0
mlpOutputNumsNums:
	.long	0                               # 0x0
	.size	mlpOutputNumsNums, 4

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

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

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

	.type	mlpWDataNums,@object            # @mlpWDataNums
	.globl	mlpWDataNums
	.p2align	2, 0x0
mlpWDataNums:
	.long	0                               # 0x0
	.size	mlpWDataNums, 4

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

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

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

	.type	learningRate,@object            # @learningRate
	.globl	learningRate
	.p2align	2, 0x0
learningRate:
	.long	0x00000000                      # float 0
	.size	learningRate, 4

	.type	E,@object                       # @E
	.globl	E
	.p2align	2, 0x0
E:
	.long	0x00000000                      # float 0
	.size	E, 4

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