//阶乘 连续因子
from std import console.*
from std import convert.*
from std import collection.*
from std import math.*
from std import format.*

// import std.format.*
// import std.math.sqrt
// import std.collection.*
 //import std.console.*
 //import std.convert.*


func getOrThrow(p: ?String): String{
    match (p) {
        case Some(x) => x
        case None => "none"
    }
}


func isNumber(number_string :String):Bool{
    var number_rune :Array<Rune>=number_string.toRuneArray()
    for(number in number_rune){
        if(!number.isAsciiNumber()&&number.toString() !=" "){
            return false
        }
    }
    return true
}

func getInputNumber():String{
    var input=Console.stdIn.readln()
    var rr = input.getOrThrow()
    let input_to_strig: Option<String> = input
    var input_to_strig_to :String=getOrThrow(input_to_strig)
    if(isNumber(input_to_strig_to)){
        return input_to_strig_to
    }
    return ""
    }

func getLongestContinuityFactor(number :Int64): (Int64,Int64){
   var max_count =0;
   var start_number =0
   var temp_n=sqrt(Float32.parse(number.toString())).format(".0")
   println("temp_n = ${temp_n}")
   var n:Int64=Int64.parse(temp_n.toString())
    for( i in 2..=n){
        var count :Int64=0
        var temp_number:Int64= number
        var j:Int64=i
        while(temp_number%j==0){
          //  println("i = ${i}  temp_number = ${temp_number} j = ${j} t/j = ${temp_number/j}")
            temp_number=temp_number/j
            j++
            count++

        }
        if(count>max_count){
        max_count=count
        start_number=i

        }
    }
    return (start_number,max_count)
}
func printlnLongestContinuityFactor(start_number :Int64,max_count :Int64,max_number :Int64){
    if(max_count>0){
        println("${max_count}")
        for(i in 0..max_count){
            print("${start_number+i}")
            if(i<max_count-1){
                print("${"*"}")
            }
        }
    }else{
        
        println("${max_number}")
    }
}

main(){
    var max_number:String=getInputNumber()
   // println("max_number 1= ${max_number}")
    if(!max_number.isEmpty()&&max_number.size>0){
        var max_number_to :Int64=Int64.parse(max_number)
        var pow :Int64 =2**31
       // println("pow 0= ${pow}")
        if(1<max_number_to&&max_number_to<pow){
           // println("max_number = ${max_number}")
         var group=   getLongestContinuityFactor(max_number_to)
         printlnLongestContinuityFactor(group[0],group[1],max_number_to)
        }
    }

}