Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision f1149acdd1aec2da8d7e43ad6e4025f8b736412b)
+++ src/ResolvExpr/ConversionCost.cc	(revision 00eaeb8994cf3f494e7144b8b16c571570217395)
@@ -288,4 +288,7 @@
             cost = Cost::unsafe;
 		}
+	} else if ( dynamic_cast< const ast::EnumPosType *>(dst) ) {
+		static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+		cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
 	}
 }
@@ -366,5 +369,4 @@
 	static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
 	cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-	// }
 	if ( cost < Cost::unsafe ) {
 		cost.incSafe();
@@ -373,9 +375,15 @@
 
 void ConversionCost::postvisit( const ast::EnumPosType * ) {
-	static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-	cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-	if ( cost < Cost::unsafe ) {
-		cost.incSafe();
-	}
+	if ( dynamic_cast<const ast::EnumPosType *>( dst ) ) {
+		// Tempoarary
+		cost = Cost::zero;
+	} else {
+		static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+		cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+		if ( cost < Cost::unsafe ) {
+			cost.incSafe();
+		}
+	}
+
 }
 
Index: src/Validate/Autogen.cpp
===================================================================
--- src/Validate/Autogen.cpp	(revision f1149acdd1aec2da8d7e43ad6e4025f8b736412b)
+++ src/Validate/Autogen.cpp	(revision 00eaeb8994cf3f494e7144b8b16c571570217395)
@@ -197,4 +197,5 @@
 	bool shouldAutogen() const final { return true; }
 	void genAttrFuncForward();
+	void genPosFunctions();
 private:
 	void genFuncBody( ast::FunctionDecl * decl ) final;
@@ -205,5 +206,11 @@
 	ast::FunctionDecl * genLabelProto() const;
 	ast::FunctionDecl * genValueProto() const;
-	// ast::FunctionDecl * genValueProto2() const;
+	ast::FunctionDecl * genSuccProto() const;
+	ast::FunctionDecl * genPredProto() const;
+
+	ast::FunctionDecl * genSuccPosProto() const;
+	ast::FunctionDecl * genPredPosProto() const;
+
+	void genSuccFunc(ast::FunctionDecl *);
 };
 
@@ -250,4 +257,5 @@
 	if ( enumDecl->base ) {
 		gen.genAttrFuncForward();
+		gen.genPosFunctions();
 	}
 	gen.generateAndAppendFunctions( declsToAddAfter );
@@ -790,21 +798,107 @@
 }
 
-// ast::FunctionDecl * EnumFuncGenerator::genValueProto2() const {
-// 	return genProto( "valueE", 
-// 		{ new ast::ObjectDecl( getLocation(), "_i", new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
-// 		{ new ast::ObjectDecl( getLocation(), "_ret", ast::deepCopy( decl->base ) ) } );
-// }
+ast::FunctionDecl * EnumFuncGenerator::genSuccProto() const {
+	return genProto( "succ",
+		{ new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ) )},
+		{ new ast::ObjectDecl( getLocation(), "_ret", new ast::EnumInstType( decl ))} ); 
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genPredProto() const {
+	return genProto( "pred",
+		{ new ast::ObjectDecl( getLocation(), "_i", new ast::EnumInstType( decl ))},
+		{ new ast::ObjectDecl( getLocation(), "_ret", new ast::EnumInstType( decl ))} );
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genSuccPosProto() const {
+	return genProto( "succ",
+		{ new ast::ObjectDecl( getLocation(), "_i", 
+			new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
+		{ 
+			new ast::ObjectDecl( getLocation(), "_ret", 
+			new ast::EnumPosType( new ast::EnumInstType( decl ) ) )
+		} ); 
+}
+
+ast::FunctionDecl * EnumFuncGenerator::genPredPosProto() const {
+	return genProto( "pred",
+		{ new ast::ObjectDecl( getLocation(), "_i", 
+			new ast::EnumPosType( new ast::EnumInstType( decl ) ) )},
+		{ 
+			new ast::ObjectDecl( getLocation(), "_ret", 
+			new ast::EnumPosType( new ast::EnumInstType( decl ) ) )
+		} ); 
+}
+
+void EnumFuncGenerator::genSuccFunc(ast::FunctionDecl * succDecl) {
+	const CodeLocation& location = getLocation();
+
+	auto & params = succDecl->params;
+	assert( params.size() == 1 );
+	auto param = params.front().strict_as<ast::ObjectDecl>();
+
+	// auto & returns = succDecl->returns;
+	// assert( returns.size() == 1 );
+	// auto oldRet = returns.front().strict_as<ast::ObjectDecl>();
+
+	// auto param = new ast::ObjectDecl( getLocation(), "_i", 
+	// 		new ast::EnumPosType( new ast::EnumInstType( decl ) ) );
+
+	auto newReturn = new ast::ObjectDecl( location, "_returns",
+		new ast::BasicType{ ast::BasicType::SignedInt} );
+	
+
+	ast::UntypedExpr * addOneExpr = new ast::UntypedExpr( location,
+		new ast::NameExpr( location, "?+?" )
+	);
+	addOneExpr->args.push_back( 
+		new ast::CastExpr( location, 
+			new ast::VariableExpr( location, param ),
+			new ast::BasicType{ ast::BasicType::SignedInt }
+		)
+	);
+	addOneExpr->args.push_back( 
+		ast::ConstantExpr::from_int( location, 1 )
+	);
+
+	ast::UntypedExpr * assignExpr = new ast::UntypedExpr( location,
+		new ast::NameExpr( location, "?=?" )
+	);
+	assignExpr->args.push_back(	
+		new ast::VariableExpr( location, newReturn )
+	);
+	assignExpr->args.push_back(
+		addOneExpr
+	);
+
+	succDecl->stmts = new ast::CompoundStmt( location, 
+		{
+			new ast::DeclStmt( location, newReturn ),
+			new ast::ExprStmt( location, assignExpr ),
+			new ast::ReturnStmt( location, 
+				new ast::VariableExpr( location, newReturn )) 
+		} );
+}
 
 void EnumFuncGenerator::genAttrFuncForward() {	
 	if ( decl->base ) {
-		ast::FunctionDecl *(EnumFuncGenerator::*attrProtos[3])() const = {
+		ast::FunctionDecl *(EnumFuncGenerator::*attrProtos[5])() const = {
 			&EnumFuncGenerator::genPosProto, &EnumFuncGenerator::genLabelProto, 
-			&EnumFuncGenerator::genValueProto
-			// , &EnumFuncGenerator::genValueProto2 
-			};
+			&EnumFuncGenerator::genValueProto, &EnumFuncGenerator::genSuccProto,
+			&EnumFuncGenerator::genPredProto
+		};
 		for ( auto & generator : attrProtos ) {
 			produceForwardDecl( (this->*generator)() );
 		}
 	}
+}
+
+void EnumFuncGenerator::genPosFunctions() {
+	if ( decl->base ) {
+		ast::FunctionDecl * decl = genSuccPosProto();
+		produceForwardDecl( decl );
+		genSuccFunc (decl );
+		produceDecl( decl );
+	}
+
 }