/*#include "RulePossibilities.cuh"
#include <numeric>
#include "LargeNumber.h"
#include "Bigint.h"
#include "Timer.h"
int temp;


RulePossibilities::RulePossibilities(
	int lineSize, int lineIndex, bool isRow, const std::vector<int>& rules) :
	lineSize(lineSize), lineIndex(lineIndex), isRow(isRow), rules(rules) {
	LoadAllPossibilities();
}

RulePossibilities::~RulePossibilities()
{
}

Cell * RulePossibilities::getLinePtr(int lineIndex)
{
	return &possibilities[lineIndex * lineSize];
}

void RulePossibilities::LoadAllPossibilities()
{
	Timer::start("calcAllPossibilities");
	possSize = calcPossSize();

	MemAllocSherd(&possibilities, sizeof(Cell)*possSize*lineSize);
	
	std::cout << "rule: (";
	for (int i = 0; i < rules.size(); i++)
		std::cout << rules.at(i) << " ";
	std::cout << ") pos: " << possSize;

	temp = 0;

	int numInserted = 0;
	fillPossibilities(0,rules.begin(), numInserted, std::vector<Cell>(lineSize, Cell::WHITE));
	std::cout << " recur iteration: " << temp << " num inserted: " << numInserted << std::endl;
	Timer::stop("calcAllPossibilities");
}
void RulePossibilities::fillPossibilities(
	int startIndex, 
	std::vector<int>::const_iterator currRule,
	int& insertLineIndex,
	std::vector<Cell> currLine) {
	temp++;
	if (currRule == rules.end()) {
		//MemAllocSherd(&possibilities[insertLineIndex], sizeof(Cell) * lineSize);
		
		cudaMemcpy(getLinePtr(insertLineIndex), currLine.data(), sizeof(Cell)*lineSize, cudaMemcpyHostToDevice);
		insertLineIndex++;
		return;
	}

	const int dist = std::distance(currRule, rules.end()) - 1;
	const int sum = std::accumulate(currRule, rules.end(), 0);
	if (startIndex + dist + sum > lineSize)
		return;

	if(startIndex + dist + sum + 1 <= lineSize)
		fillPossibilities(startIndex + 1, currRule, insertLineIndex, currLine);
	paint(currLine, startIndex, *currRule);
	fillPossibilities(startIndex + *currRule + 1, currRule + 1, insertLineIndex, currLine);
}

void RulePossibilities::paint(std::vector<Cell>& line, int startIndex, int rule) {
	for (int i = startIndex; i < startIndex + rule; i++) {
		line.at(i) = Cell::BLACK;
	}
}

int RulePossibilities::calcPossSize()
{
	int res1;
	const int ruleSum = std::accumulate(rules.begin(), rules.end(), 0);
	const int W = lineSize - ruleSum - rules.size() + 1;
	{
		Timer::start("LargeNumber");
		LargeNumber n1 = LargeNumber::Factorial(rules.size() + W);
		LargeNumber n2 = LargeNumber::Factorial(rules.size());
		LargeNumber n3 = LargeNumber::Factorial(W);
		n2.Multiply(n3);
		res1 = n1.Divide(n2);
		Timer::stop("LargeNumber");
}
	//assert(res2 == res1);
	return res1;
}
*/
	.file	"tmpxft_00250540_00000000-6_RulePossibilities.cudafe1.cpp"
	.text
#APP

#NO_APP
	.type	_ZL26__cudaUnregisterBinaryUtilv, @function
_ZL26__cudaUnregisterBinaryUtilv:
.LFB2010:
	.cfi_startproc
	endbr64
	movq	_ZL20__cudaFatCubinHandle(%rip), %rdi
	jmp	__cudaUnregisterFatBinary@PLT
	.cfi_endproc
.LFE2010:
	.size	_ZL26__cudaUnregisterBinaryUtilv, .-_ZL26__cudaUnregisterBinaryUtilv
	.section	.text.startup,"ax",@progbits
	.type	_ZL24__sti____cudaRegisterAllv, @function
_ZL24__sti____cudaRegisterAllv:
.LFB2033:
	.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
.LFE2033:
	.size	_ZL24__sti____cudaRegisterAllv, .-_ZL24__sti____cudaRegisterAllv
	.section	.init_array,"aw"
	.align 8
	.quad	_ZL24__sti____cudaRegisterAllv
	.section	.nvFatBinSegment,"aw"
	.align 8
	.type	_ZL15__fatDeviceText, @object
	.size	_ZL15__fatDeviceText, 24
_ZL15__fatDeviceText:
	.long	1180844977
	.long	1
	.quad	fatbinData
	.quad	0
	.local	_ZL20__cudaFatCubinHandle
	.comm	_ZL20__cudaFatCubinHandle,8,8
	.ident	"GCC: (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	1f - 0f
	.long	4f - 1f
	.long	5
0:
	.string	"GNU"
1:
	.align 8
	.long	0xc0000002
	.long	3f - 2f
2:
	.long	0x3
3:
	.align 8
4:


#include <hip/hip_runtime.h>
/*#include <vector>
#include "Utils.cuh"

#define MAX_POSSIBILITIES_TO_CALCULATE 10000

class RulePossibilities {
public:
	RulePossibilities(int lineSize, int lineIndex, bool isRow, const std::vector<int>& rules);
	~RulePossibilities();
private:
	Cell* possibilities; // [possibilitiesSize][lineSize]
	int lineSize, lineIndex;
	int possSize;
	bool isRow;
	const std::vector<int>& rules;

	Cell* getLinePtr(int lineIndex);
	void LoadAllPossibilities();
	int calcPossSize();
	void fillPossibilities(
		int startIndex,
		std::vector<int>::const_iterator currRule,
		int& insertLineIndex,
		std::vector<Cell> currLine);
	void paint(std::vector<Cell>& line, int startIndex, int rule);

};


*/
	.text
	.file	"RulePossibilities.hip"
	.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
