API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 16th, 2019
86
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
R 16.17 KB | None | 0 0
raw download clone embed print report
  1. # Подгрузка пакетов.
  2. library(ggplot2)
  3.  
  4. # Часть 0.
  5. rmvs.sim <- function(N, mu = 0, tau, delta, x0 = 0){
  6.   result <- list()
  7.   result$N <- N
  8.   result$mu <- mu
  9.   result$tau <- tau
  10.   result$delta <- delta
  11.   result$x0 <- x0
  12.   result$e <- rnorm(N)
  13.   result$sigma <- c(rep(1, floor(N*tau)), rep(1/delta, N - floor(N*tau)))
  14.   result$eps <- result$sigma*result$e
  15.   result$y <- mu + cumsum(c(x0, result$eps))
  16.   return(result)
  17. }
  18.  
  19. hm.sim <- function(N, mu = 0, tau, delta, x0 = 0){
  20.   result <- list()
  21.   result$N <- N
  22.   result$mu <- mu
  23.   result$tau <- tau
  24.   result$delta <- delta
  25.   result$x0 <- x0
  26.   result$alpha <- 1 - 7/N
  27.   result$e <- rnorm(N)
  28.   result$sigma <- c(rep(1, floor(N*tau)), rep(1/delta, N - floor(N*tau)))
  29.   result$eps <- result$sigma*result$e
  30.   result$y <- c(x0)
  31.   for(i in 2:(N + 1)){
  32.     result$y[i] <- result$alpha*result$y[i-1] + result$eps[i-1]
  33.   }
  34.   result$y <- result$y + mu
  35.   return(result)
  36. }
  37.  
  38. hbm.sim <- function(N, mu = 0, tau, delta, x0 = 0, tau_b, delta_b){
  39.   result <- list()
  40.   result$N <- N
  41.   result$mu <- mu
  42.   result$tau <- tau
  43.   result$delta <- delta
  44.   result$x0 <- x0
  45.   result$tau_b <- tau_b
  46.   result$delta_b <- delta_b
  47.   result$e <- rnorm(N)
  48.   result$sigma <- c(rep(1, floor(N*tau)), rep(1/delta, N - floor(N*tau)))
  49.   result$eps <- result$sigma*result$e
  50.   result$u <- c(x0)
  51.   for(i in 2:(N + 1)){
  52.     if(i <= floor(tau_b[1]*N)){
  53.       result$u[i] <- result$u[i-1] + result$eps[i-1]
  54.     } else if((i > floor(tau_b[1]*N)) & (i <= floor(tau_b[2]*N))){
  55.       result$u[i] <- (1 + delta_b[1])*result$u[i-1] + result$eps[i-1]
  56.     } else if((i > floor(tau_b[2]*N)) & (i <= floor(tau_b[3]*N))){
  57.       result$u[i] <- (1 - delta_b[2])*result$u[i-1] + result$eps[i-1]
  58.     } else {
  59.       result$u[i] <- result$u[i-1] + result$eps[i-1]
  60.     }
  61.   }
  62.   result$y <- mu + result$u
  63.   if(result$y[floor(tau_b[2]*N)] < result$y[floor(tau_b[1]*N)]){
  64.     result$y <- (-1)*result$y
  65.   }
  66.   return(result)
  67. }
  68.  
  69. simple.adf.test <- function(y, cnst = TRUE){
  70.   result <- list()
  71.   result$y <- y
  72.   result$cnst <- cnst
  73.   if(cnst){
  74.     adf.model <- lm(diff(y) ~ y[1:(length(y) - 1)])
  75.   } else if(cnst == FALSE){
  76.     adf.model <- lm(diff(y) ~ y[1:(length(y) - 1)] - 1)
  77.   }
  78.   result$adf.model <- summary(adf.model)
  79.   result$residuals <- as.numeric(adf.model$residuals)
  80.   if(cnst){
  81.     result$t_value <- as.numeric(result$adf.model[4]$coefficients[,3][2])
  82.   } else if(cnst == FALSE){
  83.     result$t_value <- as.numeric(result$adf.model[4]$coefficients[,3])
  84.   }
  85.   if(length(y)-1 == 100){
  86.     result$cr_value <- -1.95
  87.   } else if(length(y)-1 == 250){
  88.     result$cr_value <- -1.95
  89.   } else if(length(y)-1 == 500){
  90.     result$cr_value <- -1.95
  91.   }
  92.   result$is_stationary <- ifelse(result$t_value < result$cr_value, 1, 0)
  93.   return(result)
  94. }
  95.  
  96. reindex <- function(u){
  97.   u_square <- as.numeric(u^2)
  98.   result <- list()
  99.   result$u <- as.numeric(u)
  100.   result$s <- c(0:length(u))/length(u)
  101.   result$eta_hat <- rep(0, (length(u) + 1))
  102.   for(i in 2:(length(u) + 1)){
  103.     result$eta_hat[i] <- (sum(u_square[1:floor(result$s[i]*length(u))]) +
  104.                             (result$s[i]*length(u) - floor(result$s[i]*length(u)))*
  105.                             u_square[(floor(result$s[i]*length(u)) + 1)])/sum(u_square)
  106.   }
  107.   result$eta_hat[length(result$eta_hat)] <- 1
  108.   result$eta_hat_inv <- rep(0, (length(u) + 1))
  109.   for(i in 2:(length(u) + 1)){
  110.     s <- i/length(u)
  111.     k <- length(result$eta_hat[result$eta_hat < s])
  112.     result$eta_hat_inv[i] <- (k-1)/length(u) +
  113.       1/(length(u)*(result$eta_hat[k+1] - result$eta_hat[k]))*(s - result$eta_hat[k])
  114.   }
  115.   result$eta_hat_inv[length(result$eta_hat_inv)] <- 1
  116.   result$new_index <- floor(result$eta_hat_inv*length(u))
  117.   return(result)
  118. }
  119.  
  120. simple.sadf.test <- function(y, r0 = 0.01 + 1.8/sqrt(length(y)), cnst = TRUE,
  121.                              reindex = FALSE){
  122.   result <- list()
  123.   result$y <- y
  124.   result$r0 <- r0
  125.   result$cnst <- cnst
  126.   result$reindex <- reindex
  127.   result$t_values <- c()
  128.   if(reindex == FALSE){
  129.     for(i in floor(r0*length(y)):length(y)){
  130.       model <- simple.adf.test(y[1:i], cnst = cnst)
  131.       result$t_values[(i - floor(r0*length(y)) + 1)] <- model$t_value
  132.     }
  133.   } else if(reindex == TRUE){
  134.     for(i in floor(r0*length(y)):length(y)){
  135.       model <- simple.adf.test(y[1:i], cnst = cnst)
  136.       new_index <- reindex(model$residuals)
  137.       model_new <- simple.adf.test(y[(new_index$new_index + 1)], cnst = cnst)
  138.       result$t_values[(i - floor(r0*length(y)) + 1)] <- model_new$t_value
  139.     }
  140.   }
  141.   result$sadf_value <- max(result$t_values)
  142.   if(length(y)-1 == 100){
  143.     result$cr_value <- 1.37
  144.   } else if(length(y)-1 == 200){
  145.     result$cr_value <- 1.41
  146.   } else if(length(y)-1 == 400){
  147.     result$cr_value <- 1.49
  148.   } else if(length(y)-1 == 800){
  149.     result$cr_value <- 1.51
  150.   } else if(length(y)-1 == 1600){
  151.     result$cr_value <- 1.51
  152.   }
  153.   result$is_explosive <- ifelse(result$sadf_value > result$cr_value, 1, 0)
  154.   return(result)
  155. }
  156.  
  157. simple.gsadf.test <- function(y, r0 = 0.01 + 1.8/sqrt(length(y)), cnst = TRUE,
  158.                               reindex = FALSE){
  159.   result <- list()
  160.   result$y <- y
  161.   result$r0 <- r0
  162.   result$cnst <- cnst
  163.   result$reindex <- reindex
  164.  
  165.   return(result)
  166. }
  167.  
  168. gstadf.test <- function(y, r0 = 0.01 + 1.8/sqrt(length(y)), cnst = TRUE,
  169.                         test_type = "sadf", omega_est = TRUE){
  170.   result <- list()
  171.   result$y <- y
  172.   result$r0 <- r0
  173.   result$cnst <- cnst
  174.   result$test_type <- test_type
  175.  
  176.   # Часть 1. Оценка NW.
  177.   y_0 <- y - y[1]
  178.   N <- length(y)
  179.   tau_l <- 0.1
  180.   kerU <- function(x){
  181.     result <- c()
  182.     for(i in 1:length(x)){
  183.       if((x[i] < 0) & (x[i] >= -1)){
  184.         result[i] <- 1
  185.       } else {
  186.         result[i] <- 0
  187.       }
  188.     }
  189.     return(result)
  190.   }
  191.   my <- diff(y_0)
  192.   mx <- y_0[1:(length(y_0)-1)]
  193.   HT <- seq(N^(-0.5), N^(-0.1), by=0.01)
  194.   rx <- (1:N)/N
  195.   TSCV <- Inf
  196.   for(hi in 1:length(HT)){
  197.     h1 <- HT[hi]
  198.     rr1 <- rep(0, length(my))
  199.     for(k in floor(tau_l*N):length(my)){
  200.       z1 <- kerU((rx[k]-rx)/h1)
  201.       z1 <- z1[2:length(z1)]
  202.       rr1[k] <- sum(mx*z1*my)/sum(mx*z1*mx)
  203.     }
  204.     u <- my - rr1*mx
  205.     ee <- u[floor(tau_l*N):length(u)]
  206.     TSCV1 <- mean(ee^2)
  207.     if(TSCV1 < TSCV){
  208.       TSCV <- TSCV1
  209.       u_hat <- u
  210.       h <- h1
  211.     }
  212.   }
  213.   result$u_hat <- u_hat
  214.   result$h <- h
  215.   if(omega_est == TRUE){
  216.     result$w_sq <- mean(u_hat^2)
  217.   } else {
  218.     result$w_sq <- 1
  219.   }
  220.  
  221.   # Часть 2. Переиндексация.
  222.   new_index <- reindex(u_hat)
  223.   y_tt <- y[(new_index$new_index + 1)]
  224.  
  225.   # Часть 3. Сам тест.
  226.   result$t_values <- c()
  227.   if(test_type == "sadf"){
  228.     for(i in floor(r0*length(y_tt)):length(y_tt)){
  229.       if(cnst == TRUE){
  230.         y_tt_norm <- y_tt - mean(y_tt[1:i])
  231.       } else {
  232.         y_tt_norm <- y_tt
  233.       }
  234.       result$t_values[(i - floor(r0*length(y_tt)) + 1)] <-
  235.         (y_tt_norm[i]^2 - y_tt_norm[1]^2 -
  236.            result$w_sq*(i-1)/N)/(result$w_sq^0.5*2*sum(y_tt_norm[1:(i-1)]^2)^0.5)
  237.     }
  238.     result$sadf_value <- max(result$t_values)
  239.     if(length(y_tt)-1 == 100){
  240.       result$cr_value <- 1.37
  241.     } else if(length(y_tt)-1 == 200){
  242.       result$cr_value <- 1.41
  243.     } else if(length(y_tt)-1 == 400){
  244.       result$cr_value <- 1.49
  245.     } else if(length(y_tt)-1 == 800){
  246.       result$cr_value <- 1.51
  247.     } else if(length(y_tt)-1 == 1600){
  248.       result$cr_value <- 1.51
  249.     }
  250.     result$is_explosive <- ifelse(result$sadf_value > result$cr_value, 1, 0)
  251.   }
  252.   return(result)
  253. }
  254.  
  255. # Часть 1. Размест теста.
  256. df <- data.frame(matrix(0, 5, 3))
  257. colnames(df) <- c("100", "250", "500")
  258. rownames(df) <- c("constant", "delta = 0.2, tau = 0.1",
  259.                   "delta = 0.2, tau = 0.9", "delta = 5, tau = 0.1",
  260.                   "delta = 5, tau = 0.9")
  261.  
  262. df_new <- data.frame(matrix(0, 5, 3))
  263. colnames(df_new) <- c("100", "250", "500")
  264. rownames(df_new) <- c("constant", "delta = 0.2, tau = 0.1",
  265.                   "delta = 0.2, tau = 0.9", "delta = 5, tau = 0.1",
  266.                   "delta = 5, tau = 0.9")
  267.  
  268. for(i in 1:10000){
  269.   for(j in c(100, 250, 500)){
  270.    
  271.     y0 <- rmvs.sim(j, mu = 0, tau = 0.5, delta = 1, x0 = 0)
  272.     model0 <- simple.adf.test(y0$y)
  273.     new_index0 <- reindex(model0$residuals)
  274.     model0_new <- simple.adf.test(y0$y[(new_index0$new_index + 1)])
  275.    
  276.     y1 <- rmvs.sim(j, mu = 0, tau = 0.1, delta = 0.2, x0 = 0)
  277.     model1 <- simple.adf.test(y1$y)
  278.     new_index1 <- reindex(model1$residuals)
  279.     model1_new <- simple.adf.test(y1$y[(new_index1$new_index + 1)])
  280.    
  281.     y2 <- rmvs.sim(j, mu = 0, tau = 0.9, delta = 0.2, x0 = 0)
  282.     model2 <- simple.adf.test(y2$y)
  283.     new_index2 <- reindex(model2$residuals)
  284.     model2_new <- simple.adf.test(y2$y[(new_index2$new_index + 1)])
  285.    
  286.     y3 <- rmvs.sim(j, mu = 0, tau = 0.1, delta = 5, x0 = 0)
  287.     model3 <- simple.adf.test(y3$y)
  288.     new_index3 <- reindex(model3$residuals)
  289.     model3_new <- simple.adf.test(y3$y[(new_index3$new_index + 1)])
  290.    
  291.     y4 <- rmvs.sim(j, mu = 0, tau = 0.9, delta = 5, x0 = 0)
  292.     model4 <- simple.adf.test(y4$y)
  293.     new_index4 <- reindex(model4$residuals)
  294.     model4_new <- simple.adf.test(y4$y[(new_index4$new_index + 1)])
  295.    
  296.     if(j == 100){
  297.       df[1, 1] <- df[1, 1] + model0$is_stationary
  298.       df[2, 1] <- df[2, 1] + model1$is_stationary
  299.       df[3, 1] <- df[3, 1] + model2$is_stationary
  300.       df[4, 1] <- df[4, 1] + model3$is_stationary
  301.       df[5, 1] <- df[5, 1] + model4$is_stationary
  302.      
  303.       df_new[1, 1] <- df_new[1, 1] + model0_new$is_stationary
  304.       df_new[2, 1] <- df_new[2, 1] + model1_new$is_stationary
  305.       df_new[3, 1] <- df_new[3, 1] + model2_new$is_stationary
  306.       df_new[4, 1] <- df_new[4, 1] + model3_new$is_stationary
  307.       df_new[5, 1] <- df_new[5, 1] + model4_new$is_stationary
  308.     } else if(j == 250){
  309.       df[1, 2] <- df[1, 2] + model0$is_stationary
  310.       df[2, 2] <- df[2, 2] + model1$is_stationary
  311.       df[3, 2] <- df[3, 2] + model2$is_stationary
  312.       df[4, 2] <- df[4, 2] + model3$is_stationary
  313.       df[5, 2] <- df[5, 2] + model4$is_stationary
  314.      
  315.       df_new[1, 2] <- df_new[1, 2] + model0_new$is_stationary
  316.       df_new[2, 2] <- df_new[2, 2] + model1_new$is_stationary
  317.       df_new[3, 2] <- df_new[3, 2] + model2_new$is_stationary
  318.       df_new[4, 2] <- df_new[4, 2] + model3_new$is_stationary
  319.       df_new[5, 2] <- df_new[5, 2] + model4_new$is_stationary
  320.     } else if(j == 500){
  321.       df[1, 3] <- df[1, 3] + model0$is_stationary
  322.       df[2, 3] <- df[2, 3] + model1$is_stationary
  323.       df[3, 3] <- df[3, 3] + model2$is_stationary
  324.       df[4, 3] <- df[4, 3] + model3$is_stationary
  325.       df[5, 3] <- df[5, 3] + model4$is_stationary
  326.      
  327.       df_new[1, 3] <- df_new[1, 3] + model0_new$is_stationary
  328.       df_new[2, 3] <- df_new[2, 3] + model1_new$is_stationary
  329.       df_new[3, 3] <- df_new[3, 3] + model2_new$is_stationary
  330.       df_new[4, 3] <- df_new[4, 3] + model3_new$is_stationary
  331.       df_new[5, 3] <- df_new[5, 3] + model4_new$is_stationary
  332.     }
  333.   }
  334.   if(i %% 1000 == 0){
  335.     print(i)
  336.   }
  337. }
  338.  
  339. df <- round(df/100, 1)
  340. df_new <- round(df_new/100, 1)
  341.  
  342. df
  343. df_new
  344.  
  345. # Часть 2. Мощность теста.
  346. df_power <- data.frame(matrix(10000, 5, 3))
  347. colnames(df_power) <- c("100", "250", "500")
  348. rownames(df_power) <- c("constant", "delta = 0.2, tau = 0.1",
  349.                   "delta = 0.2, tau = 0.9", "delta = 5, tau = 0.1",
  350.                   "delta = 5, tau = 0.9")
  351.  
  352. df_power_new <- data.frame(matrix(10000, 5, 3))
  353. colnames(df_power_new) <- c("100", "250", "500")
  354. rownames(df_power_new) <- c("constant", "delta = 0.2, tau = 0.1",
  355.                       "delta = 0.2, tau = 0.9", "delta = 5, tau = 0.1",
  356.                       "delta = 5, tau = 0.9")
  357.  
  358. for(i in 1:10000){
  359.   for(j in c(100, 250, 500)){
  360.    
  361.     y0 <- hm.sim(j, mu = 0, tau = 0.5, delta = 1, x0 = 0)
  362.     model0 <- simple.adf.test(y0$y)
  363.     new_index0 <- reindex(model0$residuals)
  364.     model0_new <- simple.adf.test(y0$y[(new_index0$new_index + 1)])
  365.    
  366.     y1 <- hm.sim(j, mu = 0, tau = 0.1, delta = 0.2, x0 = 0)
  367.     model1 <- simple.adf.test(y1$y)
  368.     new_index1 <- reindex(model1$residuals)
  369.     model1_new <- simple.adf.test(y1$y[(new_index1$new_index + 1)])
  370.    
  371.     y2 <- hm.sim(j, mu = 0, tau = 0.9, delta = 0.2, x0 = 0)
  372.     model2 <- simple.adf.test(y2$y)
  373.     new_index2 <- reindex(model2$residuals)
  374.     model2_new <- simple.adf.test(y2$y[(new_index2$new_index + 1)])
  375.    
  376.     y3 <- hm.sim(j, mu = 0, tau = 0.1, delta = 5, x0 = 0)
  377.     model3 <- simple.adf.test(y3$y)
  378.     new_index3 <- reindex(model3$residuals)
  379.     model3_new <- simple.adf.test(y3$y[(new_index3$new_index + 1)])
  380.    
  381.     y4 <- hm.sim(j, mu = 0, tau = 0.9, delta = 5, x0 = 0)
  382.     model4 <- simple.adf.test(y4$y)
  383.     new_index4 <- reindex(model4$residuals)
  384.     model4_new <- simple.adf.test(y4$y[(new_index4$new_index + 1)])
  385.    
  386.     if(j == 100){
  387.       df_power[1, 1] <- df_power[1, 1] - model0$is_stationary
  388.       df_power[2, 1] <- df_power[2, 1] - model1$is_stationary
  389.       df_power[3, 1] <- df_power[3, 1] - model2$is_stationary
  390.       df_power[4, 1] <- df_power[4, 1] - model3$is_stationary
  391.       df_power[5, 1] <- df_power[5, 1] - model4$is_stationary
  392.      
  393.       df_power_new[1, 1] <- df_power_new[1, 1] - model0_new$is_stationary
  394.       df_power_new[2, 1] <- df_power_new[2, 1] - model1_new$is_stationary
  395.       df_power_new[3, 1] <- df_power_new[3, 1] - model2_new$is_stationary
  396.       df_power_new[4, 1] <- df_power_new[4, 1] - model3_new$is_stationary
  397.       df_power_new[5, 1] <- df_power_new[5, 1] - model4_new$is_stationary
  398.     } else if(j == 250){
  399.       df_power[1, 2] <- df_power[1, 2] - model0$is_stationary
  400.       df_power[2, 2] <- df_power[2, 2] - model1$is_stationary
  401.       df_power[3, 2] <- df_power[3, 2] - model2$is_stationary
  402.       df_power[4, 2] <- df_power[4, 2] - model3$is_stationary
  403.       df_power[5, 2] <- df_power[5, 2] - model4$is_stationary
  404.      
  405.       df_power_new[1, 2] <- df_power_new[1, 2] - model0_new$is_stationary
  406.       df_power_new[2, 2] <- df_power_new[2, 2] - model1_new$is_stationary
  407.       df_power_new[3, 2] <- df_power_new[3, 2] - model2_new$is_stationary
  408.       df_power_new[4, 2] <- df_power_new[4, 2] - model3_new$is_stationary
  409.       df_power_new[5, 2] <- df_power_new[5, 2] - model4_new$is_stationary
  410.     } else if(j == 500){
  411.       df_power[1, 3] <- df_power[1, 3] - model0$is_stationary
  412.       df_power[2, 3] <- df_power[2, 3] - model1$is_stationary
  413.       df_power[3, 3] <- df_power[3, 3] - model2$is_stationary
  414.       df_power[4, 3] <- df_power[4, 3] - model3$is_stationary
  415.       df_power[5, 3] <- df_power[5, 3] - model4$is_stationary
  416.      
  417.       df_power_new[1, 3] <- df_power_new[1, 3] - model0_new$is_stationary
  418.       df_power_new[2, 3] <- df_power_new[2, 3] - model1_new$is_stationary
  419.       df_power_new[3, 3] <- df_power_new[3, 3] - model2_new$is_stationary
  420.       df_power_new[4, 3] <- df_power_new[4, 3] - model3_new$is_stationary
  421.       df_power_new[5, 3] <- df_power_new[5, 3] - model4_new$is_stationary
  422.     }
  423.   }
  424.   if(i %% 1000 == 0){
  425.     print(i)
  426.   }
  427. }
  428.  
  429. df_power <- round(df_power/100, 1)
  430. df_power_new <- round(df_power_new/100, 1)
  431.  
  432. df_power
  433. df_power_new
  434.  
  435.  
  436. # Часть 3. Первые попытки с SADF.
  437.  
  438. ####
  439. set.seed(301)
  440.  
  441. N_sim = 200
  442. tau_sim = 0.3
  443. delta_sim = 1
  444. delta_b1_sim = c(0, 0.02, 0.04, 0.06, 0.08)
  445. NN_sim = 1000
  446.  
  447. power <- rep(0, 5)
  448. for(j in delta_b1_sim){
  449.   for(i in 1:NN_sim){
  450.     y <- hbm.sim(N = N_sim, mu = 0, tau = tau_sim, delta = delta_sim, x0 = 0,
  451.                  tau_b = c(0.4, 0.6, 1), delta_b = c(j, 0))
  452.     model <- gstadf.test(y$y, omega_est = FALSE)
  453.     power[(j/0.02 + 1)] <- power[(j/0.02 + 1)] + model$is_explosive
  454.     if(i %% 100 == 0){
  455.       print(i)
  456.     }
  457.   }
  458.   print(j)
  459. }
  460.  
  461. round(power/NN_sim, 3)
  462. ####
  463. set.seed(301)
  464.  
  465. N_sim = 200
  466. tau_sim = 0.3
  467. delta_sim = 1
  468. delta_b1_sim = c(0, 0.02, 0.04, 0.06, 0.08)
  469. reindex_sim = FALSE
  470. NN_sim = 1000
  471.  
  472. power <- rep(0, 5)
  473. for(j in delta_b1_sim){
  474.   for(i in 1:NN_sim){
  475.     y <- hbm.sim(N = N_sim, mu = 0, tau = tau_sim, delta = delta_sim, x0 = 0,
  476.                  tau_b = c(0.4, 0.6, 1), delta_b = c(j, 0))
  477.     model <- simple.sadf.test(y = y$y, reindex = reindex_sim)
  478.     power[(j/0.02 + 1)] <- power[(j/0.02 + 1)] + model$is_explosive
  479.     if(i %% 100 == 0){
  480.       print(i)
  481.     }
  482.   }
  483.   print(j)
  484. }
  485.  
  486. round(power/NN_sim, 3)
  487. ####
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!