CF Code

user-knn

import numpy
import csv
from numpy import *

'''
data from (1,1)->(user, item)
(user, 0) mean the mean rating of user u
(0, item) mean the mean rating of item i 
'''

def toInt(arr):
    print('toInt() startting...')
    arr = mat(arr)
    m, n = shape(arr)
    nArr = zeros((m, n))
    for i in range(m):
        for j in range(n):
            nArr[i, j] = int(arr[i, j])
    print('toInt() ending...')
    return nArr

def loadTrainData(path):
    print('loadTrainData startting...')
    l = []
    with open(path, 'r') as file:
        lines = csv.reader(file)
        for line in lines:
            l.append(line)
    l = array(l)
    print('loadTrainData ending...')
    return toInt(l)

def loadTestData(path):
    print('loadTestData startting...')
    l = []
    with open(path) as file:
        lines = csv.reader(file)
        for line in lines:
            l.append(line)
    l = array(l)
    print('loadTestData ending...')
    return toInt(l)

def fillUIMatrix(uimatrix, train_data):
    print('fillUIMatrix startting...')
    train_data = mat(train_data)
    m, n = shape(train_data)
    for i in range(m):
        uimatrix[train_data[i, 0], train_data[i, 1]] = train_data[i, 2]
    print('fillUIMatrix ending...')

def calAverageRating(uimatrix):
    print('calAverageRating starting...')
    uimatrix = mat(uimatrix)
    m, n = shape(uimatrix)
    for i in range(1, m):
        rating = 0
        cnt = 0
        for j in range(1, n):
            rating += uimatrix[i, j]
            if uimatrix[i, j] != 0:
                cnt += 1
        uimatrix[i, 0] = rating / cnt
    
    for i in range(1, n):
        rating = 0
        cnt = 0
        for j in range(1, m):
            rating += uimatrix[j, i]
            if uimatrix[j, i] != 0:
                cnt += 1
        if cnt == 0: uimatrix[0, i] = 0
        else: uimatrix[0, i] = rating / cnt
    print('calAverageRating ending...')

def calPerson(l1, l2, rating1, rating2):
    print('calPerson startting...')
    r1 = 0.0; r2 = 0.0; r3 = 0.0;
    for i in range(len(l1)):
        r1 += (l1[i]-rating1)*(l2[i]-rating2)
        r2 += (l1[i]-rating1)*(l1[i]-rating1)
        r3 += (l2[i]-rating2)*(l2[i]-rating2)
    r = r1 / (sqrt(r2)*sqrt(r3))
    print('calPerson ending...')
    return abs(r)
    
def rSort(r_list, index_list):
    print('rSort startting...')
    for i in range(len(r_list)-1):
        for j in range(len(r_list)-1-i):
            if r_list[j] < r_list[j+1]:
                tmp = r_list[j]
                r_list[j] = r_list[j+1]
                r_list[j+1] = tmp
                tmp = index_list[j]
                index_list[j] = index_list[j+1]
                index_list[j+1] = tmp
    for i in range(len(r_list)):
        print(i, ':', r_list[i])
    print('rSort ending...')
    
def calSim(uimatrix, index):
    print('calSim startting...')
    uimatrix = mat(uimatrix)
    m, n = shape(uimatrix)
    r_list = [];         # sim list
    index_list = [];     # mapping sim and index
    for i in range(1, m):
        l1 = []; l2 = [];
        if i == index: continue
        for j in range(1, n):
            if uimatrix[i, j] != 0 and uimatrix[index, j] != 0:
                l1.append(uimatrix[index, j]);
                l2.append(uimatrix[i, j])
        if l1 != []:
            rating1 = 0; rating2 = 0;
            for j in range(len(l1)):
                rating1 += l1[j]
            for j in range(len(l2)):
                rating2 += l2[j]
            rating1 /= len(l1); rating2 /= len(l2);
            r = calPerson(l1, l2, rating1, rating2)
            if math.isnan(r) == True: r = 0.0
            r_list.append(r)
            index_list.append(i)
    rSort(r_list, index_list)
    print('calSim ending...')
    return r_list, index_list

def calRMSE(uimatrix, test_data, users):
    print('calRMSE startting...')
    test_data = mat(test_data)
    m, n = shape(test_data)
    tmp1 = 0
    tmp2 = 0
    for k in range(1, users+1):
        for i in range(m):
            if test_data[i, 0] == k:
                if uimatrix[k, test_data[i, 1]] == 0.0: 
                    uimatrix[k, test_data[i, 1]] = uimatrix[k, 0]
                uimatrix[k, test_data[i, 1]] = round(uimatrix[k, test_data[i, 1]])
                tmp1 += (test_data[i, 2]-uimatrix[k, test_data[i, 1]])**2
                tmp2 += 1
                print(test_data[i, 1], ' real rating:', test_data[i, 2], ' predict:', uimatrix[k, test_data[i, 1]])
    print('calRMSE ending...')
    return sqrt(tmp1/tmp2)

select_top = 30
users = 943
items = 1682
user_item_matrix = zeros((users+1, items+1))
train_path = 'C:\Users\think\Desktop\data\u2.base'
test_path = 'C:\Users\think\Desktop\data\u2.test'

train_data = loadTrainData(train_path)
test_data = loadTestData(test_path)

fillUIMatrix(user_item_matrix, train_data)
calAverageRating(user_item_matrix)
uimatrix = user_item_matrix
uimatrix = mat(uimatrix)

for i in range(1,users):
    r_list, index_list = calSim(uimatrix, i)
    for j in range(1, items):
        if uimatrix[i, j] == 0:
            tmp1 = 0.0; tmp2 = 0.0;
            for k in range(select_top):
                if math.isnan(r_list[k]) == False and uimatrix[index_list[k], j] != 0:
                    tmp1 += r_list[k]*(uimatrix[index_list[k], j]-uimatrix[index_list[k], 0])
                    tmp2 += r_list[k]
            print(j, tmp1, tmp2)
            if tmp2 == 0: uimatrix[i, j] = uimatrix[i, 0]
            else: uimatrix[i, j] = uimatrix[i, 0] + tmp1/tmp2
    
RMSE = calRMSE(uimatrix, test_data, users)
print(RMSE)

lfm1

from numpy import *
import csv
import time

def RMSE(estimation, truth):
    num = len(estimation)
    
    sse = sum(square(truth - estimation))
    return sqrt(divide(sse, num-1.0))

class matrixFactorization():
    def __init__(self, num_user, num_item, num_feature, train_data, test_data, **params):
        self._num_user = num_user
        self._num_item = num_item
        self._num_featrue = num_feature
        self._train_data = train_data
        self._test_data = test_data
        
        self.batch_size = int(params.get('batch_size', 1000000))
        
        self.epsilon = float(params.get('epsilon', 100.0))
        self.lam = float(params.get('lam', 0.00001))
        
        self.max_rating = params.get('max_rating')
        self.min_rating = params.get('min_rating')
        
        if self.max_rating:
            self.max_rating = float(self.max_rating)
        if self.min_rating:
            self.min_rating = float(self.min_rating)
        
        self._mean_rating = mean(self._train_data[:, 2])
        
        self._user_feature = 0.3 * random.rand(num_user, num_feature)
        self._item_feature = 0.3 * random.rand(num_item, num_feature)
        
        self.train_errors = []
        self.test_errors = []
        
    def estimate(self, iterations = 50, converge = 1e-4):
        last_rmse = None
        for iteration in range(iterations):
            data = self._train_data
            #compute gradient
            u_features = (self._user_feature)[data[:, 0], :]
            i_features = (self._item_feature)[data[:, 1], :]
            ratings = data[:, 2] - self._mean_rating
            preds = sum(u_features*i_features, 1)
            errs = preds - ratings
            err_mat = tile(errs, (self._num_featrue, 1)).T
            
            u_grads = u_features * err_mat + self.lam * i_features
            i_grads = i_features * err_mat + self.lam * u_features
            
            u_feature_grads = zeros((self._num_user, self._num_featrue))
            i_feature_grads = zeros((self._num_item, self._num_featrue))
            
            for i in range(shape(data)[0]):
                user = data[i, 0]
                item = data[i, 1]
                u_feature_grads[user, :] += u_grads[i, :]
                i_feature_grads[item, :] += i_grads[i, :]
            
            self._user_feature = self._user_feature - (self.epsilon / self.batch_size) * u_feature_grads
            self._item_feature = self._item_feature - (self.epsilon / self.batch_size) * i_feature_grads
        
            train_preds = self.predict(self._train_data)
            train_rmse = RMSE(train_preds, float16(self._train_data[:, 2]))
            
            test_preds = self.predict(self._test_data)
            test_rmse = RMSE(test_preds, float16(self._test_data[:, 2]))
            
            self.train_errors.append(train_rmse)
            self.test_errors.append(test_rmse)
            
            print('iterations: %3d, train RMSE: %.6f, test RMSE: %.6f') % (iteration+1, train_rmse, test_rmse)
            
            if last_rmse:
                if abs(train_rmse - last_rmse) < converge:
                    break
            last_rmse = train_rmse
    
    def predict(self, data):
        u_features = self._user_feature[data[:, 0], :]
        i_features = self._item_feature[data[:, 1], :]
        preds = sum(u_features*i_features, 1) + self._mean_rating
        
        if self.max_rating:
            preds[preds > self.max_rating] = self.max_rating
        if self.min_rating:
            preds[preds < self.min_rating] = self.min_rating
        return preds

def toInt(arr):
    print('toInt() startting...')
    arr = mat(arr)
    m, n = shape(arr)
    nArr = zeros((m, n), dtype='int8')
    for i in range(m):
        for j in range(n):
            nArr[i, j] = int(arr[i, j])
    print('toInt() ending...')
    return nArr

def loadTrainData(path):
    print('loadTrainData startting...')
    l = []
    with open(path, 'r') as file:
        lines = csv.reader(file)
        for line in lines:
            l.append(line)
    l = array(l)
    print('loadTrainData ending...')
    return toInt(l)

def loadTestData(path):
    print('loadTestData startting...')
    l = []
    with open(path) as file:
        lines = csv.reader(file)
        for line in lines:
            l.append(line)
    l = array(l)
    print('loadTestData ending...')
    return toInt(l)

train_path = 'C:\Users\think\Desktop\data\u1.base'
test_path = 'C:\Users\think\Desktop\data\u1.test'

train_data = loadTrainData(train_path)
test_data = loadTestData(test_path)
num_feature = 15
max_iter = 20000
num_user = 943
num_item = 1682
rec = matrixFactorization(num_user, num_item, num_feature, train_data, test_data, max_rating=5, min_rating=1)
rec.estimate(max_iter)

lfm2

from __future__ import division
import numpy as np
import scipy as sp
from numpy import *
from numpy.random import random
import csv

class  SVD_C:
    def __init__(self,X,k=20):
        '''
            k  is the length of vector
        '''
        self.X=np.array(X)
        self.k=k
        self.ave=np.mean(self.X[:,2])
        print "the input data size is ",self.X.shape
        self.bi={}
        self.bu={}
        self.qi={}
        self.pu={}
        self.movie_user={}
        self.user_movie={}
        for i in range(self.X.shape[0]):
            uid=self.X[i][0]
            mid=self.X[i][1]
            rat=self.X[i][2]
            self.movie_user.setdefault(mid,{})
            self.user_movie.setdefault(uid,{})
            self.movie_user[mid][uid]=rat
            self.user_movie[uid][mid]=rat
            self.bi.setdefault(mid,0)
            self.bu.setdefault(uid,0)
            self.qi.setdefault(mid,random((self.k,1))/10*(np.sqrt(self.k)))
            self.pu.setdefault(uid,random((self.k,1))/10*(np.sqrt(self.k)))
    def pred(self,uid,mid):
        self.bi.setdefault(mid,0)
        self.bu.setdefault(uid,0)
        self.qi.setdefault(mid,np.zeros((self.k,1)))
        self.pu.setdefault(uid,np.zeros((self.k,1)))
        if (self.qi[mid]==None):
            self.qi[mid]=np.zeros((self.k,1))
        if (self.pu[uid]==None):
            self.pu[uid]=np.zeros((self.k,1))
        ans=self.ave+self.bi[mid]+self.bu[uid]+np.sum(self.qi[mid]*self.pu[uid])
        if ans>5:
            return 5
        elif ans<1:
            return 1
        return ans
    def train(self,steps=50,gamma=0.04,Lambda=0.15):
        for step in range(steps):
            print 'the ',step,'-th  step is running'
            rmse_sum=0.0
            kk=np.random.permutation(self.X.shape[0])
            for j in range(self.X.shape[0]):
                i=kk[j]
                uid=self.X[i][0]
                mid=self.X[i][1]
                rat=self.X[i][2]
                eui=rat-self.pred(uid,mid)
                rmse_sum+=eui**2
                self.bu[uid]+=gamma*(eui-Lambda*self.bu[uid])
                self.bi[mid]+=gamma*(eui-Lambda*self.bi[mid])
                temp=self.qi[mid]
                self.qi[mid]+=gamma*(eui*self.pu[uid]-Lambda*self.qi[mid])
                self.pu[uid]+=gamma*(eui*temp-Lambda*self.pu[uid])
            gamma=gamma*0.93
            print "the rmse of this step on train data is ",np.sqrt(rmse_sum/self.X.shape[0])
            #self.test(test_data)
    def test(self,test_X):
        output=[]
        sums=0
        test_X=np.array(test_X)
        #print "the test data size is ",test_X.shape
        for i in range(test_X.shape[0]):
            pre=self.pred(test_X[i][0],test_X[i][1])
            output.append(pre)
            #print pre,test_X[i][2]
            sums+=(pre-test_X[i][2])**2
        rmse=np.sqrt(sums/test_X.shape[0])
        print "the rmse on test data is ",rmse
        return output

    
def toInt(arr):
    print('toInt() startting...')
    arr = mat(arr)
    m, n = shape(arr)
    nArr = zeros((m, n), dtype='int8')
    for i in range(m):
        for j in range(n):
            nArr[i, j] = int(arr[i, j])
    print('toInt() ending...')
    return nArr

def loadTrainData(path):
    print('loadTrainData startting...')
    l = []
    with open(path, 'r') as file:
        lines = csv.reader(file)
        for line in lines:
            l.append(line)
    l = array(l)
    print('loadTrainData ending...')
    return toInt(l)

def loadTestData(path):
    print('loadTestData startting...')
    l = []
    with open(path) as file:
        lines = csv.reader(file)
        for line in lines:
            l.append(line)
    l = array(l)
    print('loadTestData ending...')
    return toInt(l)

train_path = 'C:\Users\think\Desktop\data\u1.base'
test_path = 'C:\Users\think\Desktop\data\u1.test'

train_data = loadTrainData(train_path)
test_data = loadTestData(test_path)

a = SVD_C(train_data, 30)
a.train()
a.test(test_data)

 rbm //rmse有点高啊，1.1多，不知道哪儿的问题Orz

#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <utility>
#include <cstdio>
#include <cstring>

using namespace std;

const int num_of_user = 943;
const int num_of_movies = 1682;
const int num_of_rating = 5;
const int num_of_hidden = 200;
const int num_of_visible = 1682;

double uniform(double, double);
int binomial(double);

class RBM
{
public:
    int N;
    int n_visible;
    int n_hidden;
    int rating;
    double W[num_of_hidden][num_of_visible][num_of_rating];
    double hbias[num_of_hidden];
    double vbias[num_of_rating][num_of_visible];

    RBM(int, int, int, int);
    void contrastiveDivergence(int[][1682], double, int);
    void sample_h_given_v(int[][1682], double*, int*);
    double sigmoid(double);
    double Vtoh_sigm(int [][1682], double [][5], double);
    void gibbs_hvh(int*, double[][1682], int[][1682], double*, int*);
    double HtoV_sigm(int*, int, int, int);
    void sample_v_given_h(int* , double [][1682], int [][1682]);
    void reconstruct(int[][1682], double[][1682]);
};

void RBM::contrastiveDivergence(int train_data[][1682], double learning_rate, int k)
{
    //train_data 5 * 1682
    double ph_sigm_out[num_of_hidden]; // 10
    int ph_sample[num_of_hidden]; // 10
    double nv_sigm_outs[num_of_rating][num_of_visible]; // 5 * 1682
    int nv_samples[num_of_rating][num_of_visible]; // 5 * 1692
    double nh_sigm_outs[num_of_hidden]; // 10
    int nh_samples[num_of_hidden]; // 10

    sample_h_given_v(train_data, ph_sigm_out, ph_sample);

    for (int i = 0; i < k; ++i)
    {
        if (i == 0)
            gibbs_hvh(ph_sample, nv_sigm_outs, nv_samples, nh_sigm_outs, nh_samples);
        else
            gibbs_hvh(nh_samples, nv_sigm_outs, nv_samples, nh_sigm_outs, nh_samples);
    }

    for (int i = 0; i < n_hidden; ++i)
    {
        for (int j = 0; j < n_visible; ++j)
        {
            for (int kk = 0; kk < rating; ++kk)
            {
                W[i][j][kk] += learning_rate * (ph_sigm_out[i] * train_data[kk][j] - nh_sigm_outs[i] * nv_samples[kk][j]);
            }
        }
        hbias[i] += learning_rate * (ph_sigm_out[i] - nh_sigm_outs[i]) ;
    }

    for (int i = 0; i < rating; ++i)
    {
        for (int j = 0; j < n_visible; ++j)
        {
            vbias[i][j] += learning_rate * (train_data[i][j] - nv_samples[i][j]) ;
        }
    }
}

void RBM::gibbs_hvh(int* ph_sample, double nv_sigm_outs[][1682], int nv_samples[][1682], double* nh_sigm_outs, int* nh_samples)
{
    sample_v_given_h(ph_sample, nv_sigm_outs, nv_samples);
    sample_h_given_v(nv_samples, nh_sigm_outs, nh_samples);
}

void RBM::sample_h_given_v(int train_data[][1682], double* ph_sigm_out, int* ph_sample)
{
    for (int i = 0; i < n_hidden; ++i)
    {
        ph_sigm_out[i] = Vtoh_sigm(train_data, W[i], hbias[i]);
        ph_sample[i] = binomial(ph_sigm_out[i]);
    }
}

void RBM::sample_v_given_h(int* h0_sample, double nv_sigm_outs[][1682], int nv_samples[][1682])
{
    for (int i = 0; i < rating; ++i)
    {
        for (int j = 0; j < n_visible; ++j)
        {
            nv_sigm_outs[i][j] = HtoV_sigm(h0_sample, j, vbias[i][j], i);
            nv_samples[i][j] = binomial(nv_sigm_outs[i][j]);
        }
    }
}

double RBM::HtoV_sigm(int* h0_sample, int i, int vbias, int kk)
{
    double temp = 0;
    for (int j = 0; j < n_hidden; ++j)
    {
        temp += W[j][i][kk] * h0_sample[j];
    }
    temp += vbias;
    return sigmoid(temp);
}

double RBM::Vtoh_sigm(int train_data[][1682], double W[][5], double hbias)
{
    double temp = 0.0;
    for (int i = 0; i < rating; ++i)
    {
        for (int j = 0; j < n_visible; ++j)
            temp += W[j][i] * train_data[i][j];
    }
    temp += hbias;
    return sigmoid(temp);
}

double RBM::sigmoid(double x)
{
    return 1.0 / (1.0 + exp(-x));
}

RBM::RBM(int train_N, int n_v, int n_h, int rt)
{
    N = train_N;
    n_visible = num_of_visible;
    n_hidden = num_of_hidden;
    rating = num_of_rating;

    double a = 1.0 / n_visible;
    for (int i = 0; i < n_hidden; ++i)
        for (int j = 0; j < n_visible; ++j)
            for (int k = 0; k < rating; ++k)
                W[i][j][k] = uniform(-a, a);


    for (int i = 0; i < n_hidden; ++i)
        hbias[i] = 0.0;

    for (int i = 0; i < rating; ++i)
        for (int j = 0; j < n_visible; ++j)
            vbias[i][j] = 0.0;
}

void RBM::reconstruct(int test_data[][1682], double reconstruct_data[][1682])
{
    double h[num_of_hidden];
    double temp = 0;

    for (int i = 0; i < n_hidden; ++i)
    {
        h[i] = Vtoh_sigm(test_data, W[i], hbias[i]);
    }

    for (int i = 0; i < rating; ++i)
    {
        for (int j = 0; j < n_visible; ++j)
        {
            temp = 0;
            for (int kk = 0; kk < n_hidden; ++kk)
            {
                temp += W[kk][j][i] * h[kk];
            }
            temp += vbias[i][j];
            reconstruct_data[i][j] = sigmoid(temp);
        }
    }
}

double uniform(double min, double max)
{
    return rand() / (RAND_MAX + 1.0) * (max - min) + min;
}

int binomial(double p)
{
    if (p < 0 || p > 1) return 0;
    double r = rand() / (RAND_MAX + 1.0);
    if (r < p) return 1;
    else return 0;
}

double make_predict(RBM rbm, int train_data[][1682], int u, vector<pair<int, int> >& v)
{
    double hidden[num_of_hidden];
    for (int i = 0; i < num_of_hidden; ++i)
    {
        double temp = 0.0;
        for (int j = 0; j < num_of_rating; ++j)
        {
            for (int kk = 0; kk < num_of_movies; ++kk)
            {
                temp += train_data[j][kk] * rbm.W[i][kk][j];
            }
        }
        temp += rbm.hbias[i];
        hidden[i] = rbm.sigmoid(temp);
    }
    int size = v.size();
    double ret = 0;
    for (int i = 0; i < size; ++i)
    {
        double vp[num_of_rating];
        int item = v[i].first;
        int real_rating = v[i].second;

        for (int j = 0; j < num_of_rating; ++j)
        {
            double temp = 0;
            for (int kk = 0; kk < num_of_hidden; ++kk)
            {
                temp += hidden[kk]*rbm.W[kk][item][j];
            }
            temp += rbm.vbias[j][item];
            temp = exp(temp);
            vp[j] = temp;
        }
        double mx = 0, mxi = 0;
        for (int j = 0; j < num_of_rating; ++j)
        {
            if (vp[j] > mx) mx = vp[j], mxi = j;
        }
        ret += (mxi - real_rating) * (mxi - real_rating);
    }
    return ret;
}

void get_train_data(int train_data[][5][1682])
{
    FILE *fp;
    freopen("E:\DL\MovieLens\ml-100k\u1.base", "r", stdin);
    int u, m, r;
    long long t;
    printf("a
");
    long long int cnt = 0;
    while (~scanf("%d %d %d %lld", &u, &m, &r, &t))
    {
        u--, m--, r--;
        train_data[u][r][m] = 1;
    }
    fclose(stdin);
}

void get_test_data(vector<pair<int, int> > td[])
{
    FILE* fp;
    freopen("E:\DL\MovieLens\ml-100k\u1.test", "r", stdin);
    int u, m, r;
    long long t;
    while (~scanf("%d %d %d %lld", &u, &m, &r, &t))
    {
        u--, m--, r--;
        td[u].push_back(make_pair(m, r));
    }
    fclose(stdin);
}

void train()
{
    srand(0);
    int train_N = 100;
    int n_visible = num_of_visible;
    int n_hidden = num_of_hidden;
    int rating = num_of_rating;
    int train_iter = 1000;
    double learning_rate = 0.0001;
    int training_num = 1000;
    int k = 1;
    int train_data[943][5][1682];
    memset(train_data, 0, sizeof(train_data));
    get_train_data(train_data);

    double hbias[num_of_user][num_of_hidden];
    memset(hbias, 0, sizeof(hbias));

    vector<pair<int, int> > test_data[num_of_user];
    get_test_data(test_data);


    RBM rbm = RBM(train_N, n_visible, n_hidden, rating);

    for (int iter = 0; iter < train_iter; ++iter)
    {
        for (int i = 0; i < num_of_user; ++i)
        {
            rbm.contrastiveDivergence(train_data[i], learning_rate, 1);
        }
        int cnt = 0;
        double error = 0;
        for (int i = 0; i < num_of_user; ++i)
        {
            error += make_predict(rbm, train_data[i], i, test_data[i]);
            cnt += test_data[i].size();
        }
        double rmse = sqrt(error / cnt);
        printf("epoch: %d, rmse: %f
",iter, rmse);
        learning_rate *= 0.9;
    }

    for (int i = 0; i < num_of_hidden; ++i)
        printf("%lf ", rbm.hbias[i]);
    printf("-----------------------------");

    int cnt = 0;
    double error = 0;
    for (int i = 0; i < num_of_user; ++i)
    {
        error += make_predict(rbm, train_data[i], i, test_data[i]);
        cnt += test_data[i].size();
    }
    double rmse = sqrt(error / cnt);
    printf("rmse: %f
", rmse);

}

// 943 users
// 1682 items
// 100000 ratings

int main()
{
    train();

    return 0;
}