text:
// cudamatrix/cu-kernels.h

// Copyright 2009-2012  Karel Vesely
//                2013  Ehsan Variani
//                2014  Johns Hopkins University (author: Daniel Povey)
//                2013  Hainan Xu
//                2013  Xiaohui Zhang
//                2013  Johns Hopkins University (author: Guoguo Chen)
//                2015  Yajie Miao

// See ../../COPYING for clarification regarding multiple authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.

#ifndef KALDI_CUDAMATRIX_CU_KERNELS_H_
#define KALDI_CUDAMATRIX_CU_KERNELS_H_

#if HAVE_CUDA == 1

#include "base/kaldi-error.h"
#include "cudamatrix/cu-kernels-ansi.h"

namespace kaldi {

/*
 * CuMatrix
 */

inline void cuda_copy_upp_low(dim3 Gr, dim3 Bl, float* A, MatrixDim dimA) { cudaF_copy_upp_low(Gr, Bl, A, dimA); }
inline void cuda_copy_low_upp(dim3 Gr, dim3 Bl, float* A, MatrixDim dimA) { cudaF_copy_low_upp(Gr, Bl, A, dimA); }
inline void cuda_add_diag_vec_mat(dim3 Gr, dim3 Bl, float alpha, float *mat, MatrixDim mat_dim,
                                  const float *vec, const float *mat2, int mat2_row_stride,
                                  int mat2_col_stride, float beta) {
  cudaF_add_diag_vec_mat(Gr, Bl, alpha, mat, mat_dim, vec, mat2,
                         mat2_row_stride, mat2_col_stride, beta);
}
inline void cuda_copy_from_tp_trans(dim3 Gr, dim3 Bl, float* A, const float* B, MatrixDim dmat) { cudaF_copy_from_tp_trans(Gr,Bl,A,B,dmat); }
inline void cuda_copy_from_tp_trans(dim3 Gr, dim3 Bl, float* A, const double* B, MatrixDim dmat) { cudaFD_copy_from_tp_trans(Gr,Bl,A,B,dmat); }
inline void cuda_copy_from_tp(dim3 Gr, dim3 Bl, float* A, const float* B, MatrixDim dmat) { cudaF_copy_from_tp(Gr,Bl,A,B,dmat); }
inline void cuda_copy_from_tp(dim3 Gr, dim3 Bl, float* A, const double* B, MatrixDim dmat) { cudaFD_copy_from_tp(Gr,Bl,A,B,dmat); }

inline void cuda_copy_from_mat(dim3 Gr, dim3 Bl, float* mat_out, const double* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_fd(Gr, Bl, mat_out, mat_in, d_out, d_in);
}
inline void cuda_copy_from_mat(dim3 Gr, dim3 Bl, float* mat_out, const float* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_ff(Gr, Bl, mat_out, mat_in, d_out, d_in);
}
inline void cuda_copy_from_mat(dim3 Gr, dim3 Bl, double* mat_out, const double* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_dd(Gr, Bl, mat_out, mat_in, d_out, d_in);
}
inline void cuda_copy_from_mat(dim3 Gr, dim3 Bl, double* mat_out, const float* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_df(Gr, Bl, mat_out, mat_in, d_out, d_in);
}

inline void cuda_copy_from_mat_trans(dim3 Gr, dim3 Bl, float* mat_out, const double* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_fd_trans(Gr, Bl, mat_out, mat_in, d_out, d_in);
}
inline void cuda_copy_from_mat_trans(dim3 Gr, dim3 Bl, float* mat_out, const float* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_ff_trans(Gr, Bl, mat_out, mat_in, d_out, d_in);
}
inline void cuda_copy_from_mat_trans(dim3 Gr, dim3 Bl, double* mat_out, const double* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_dd_trans(Gr, Bl, mat_out, mat_in, d_out, d_in);
}
inline void cuda_copy_from_mat_trans(dim3 Gr, dim3 Bl, double* mat_out, const float* mat_in, MatrixDim d_out, MatrixDim d_in) {
  cuda_copy_from_mat_df_trans(Gr, Bl, mat_out, mat_in, d_out, d_in);
}

inline void cuda_copy_col_from_vec(int Gr, int Bl, float* mat, const float* v, int col, MatrixDim d) { cudaF_copy_col_from_vec(Gr,Bl,mat,v,col,d); }
inline void cuda_apply_exp(dim3 Gr, dim3 Bl, float* mat, MatrixDim d) { cudaF_apply_exp(Gr,Bl,mat,d); }
inline void cuda_apply_pow(dim3 Gr, dim3 Bl, float* mat, float power, MatrixDim dim) { cudaF_apply_pow(Gr,Bl,mat,power,dim); }
inline void cuda_apply_pow_abs(dim3 Gr, dim3 Bl, float* mat, float power, bool include_sign, MatrixDim dim) { cudaF_apply_pow_abs(Gr,Bl,mat,power,include_sign, dim); }
inline void cuda_apply_heaviside(dim3 Gr, dim3 Bl, float* mat, MatrixDim dim) { cudaF_apply_heaviside(Gr,Bl,mat,dim); }
inline void cuda_apply_floor(dim3 Gr, dim3 Bl, float* mat, float floor_val, MatrixDim dim) { cudaF_apply_floor(Gr,Bl,mat,floor_val,dim); }
inline void cuda_apply_ceiling(dim3 Gr, dim3 Bl, float* mat, float ceiling_val, MatrixDim dim) { cudaF_apply_ceiling(Gr,Bl,mat,ceiling_val,dim); }
inline void cuda_copy_cols(dim3 Gr, dim3 Bl, float* dst, const float* src, const MatrixIndexT_cuda* reorder, MatrixDim dst_dim, int src_stride) {
  cudaF_copy_cols(Gr, Bl, dst, src, reorder, dst_dim, src_stride);
}
inline void cuda_copy_rows(dim3 Gr, dim3 Bl, float* dst, const float* src, const MatrixIndexT_cuda* reorder, MatrixDim dst_dim, int src_stride) {
  cudaF_copy_rows(Gr, Bl, dst, src, reorder, dst_dim, src_stride);
}
inline void cuda_trace(int Gr, int Bl, float* mat, float* value, int dim) { cudaF_trace(Gr,Bl,mat,value,dim); }
inline void cuda_set_diag(int Gr, int Bl, float* mat, float value, MatrixDim d) { cudaF_set_diag(Gr,Bl,mat,value,d); }
inline void cuda_set_diag_packed(int Gr, int Bl, float* mat, float value, int dim) { cudaF_set_diag_packed(Gr,Bl,mat,value,dim); }
inline void cuda_add_diag_packed(int Gr, int Bl, float* mat, float value, int dim) { cudaF_add_diag_packed(Gr,Bl,mat,value,dim); }
inline void cuda_set_const(dim3 Gr, dim3 Bl, float *mat, float value, MatrixDim d) { cudaF_set_const(Gr,Bl,mat,value,d); }
inline void cuda_set_zero_above_diag(dim3 Gr, dim3 Bl, float* mat, MatrixDim d) { cudaF_set_zero_above_diag(Gr,Bl,mat,d); }
inline void cuda_add(dim3 Gr, dim3 Bl, float *mat, float value, MatrixDim d) { cudaF_add(Gr,Bl,mat,value,d); }
inline void cuda_add_vec2(dim3 Gr, dim3 Bl, float *mat, const float *vec, const float alpha, int dim) { cudaF_add_vec2(Gr,Bl,mat,vec,alpha,dim); }
inline void cuda_scale_diag_packed(int Gr, int Bl, float* mat, float value, int dim) { cudaF_scale_diag_packed(Gr,Bl,mat,value,dim); }
inline void cuda_scale(dim3 Gr, dim3 Bl, float *mat, float value, MatrixDim d) { cudaF_scale(Gr,Bl,mat,value,d); }
inline void cuda_apply_log(dim3 Gr, dim3 Bl, float *mat, MatrixDim d) { cudaF_apply_log(Gr,Bl,mat,d); }
inline void cuda_mul_elements(dim3 Gr, dim3 Bl, float *mat, const float *A, MatrixDim dst_d, int src_stride) {
  cudaF_mul_elements(Gr,Bl,mat,A,dst_d,src_stride);
}
inline void cuda_max(dim3 Gr, dim3 Bl, float *mat, const float *A, MatrixDim dst_d, int src_stride) {
  cudaF_max(Gr,Bl,mat,A,dst_d,src_stride);
}
inline void cuda_mul_cols_vec(dim3 Gr, dim3 Bl, float *mat, const float *scale, MatrixDim d) { cudaF_mul_cols_vec(Gr,Bl,mat,scale,d); }
inline void cuda_mul_rows_vec(dim3 Gr, dim3 Bl, float *mat, const float *scale, MatrixDim d) { cudaF_mul_rows_vec(Gr,Bl,mat,scale,d); }
inline void cuda_mul_rows_group_mat(dim3 Gr, dim3 Bl, float *y, const float *x, MatrixDim d, int src_stride, int group_size) { cudaF_mul_rows_group_mat(Gr, Bl, y, x, d, src_stride, group_size); }
inline void cuda_calc_pnorm_deriv(dim3 Gr, dim3 Bl, float *y, const float *x1, const float *x2,  MatrixDim d, int src_stride, int group_size, float power) {cudaF_calc_pnorm_deriv(Gr, Bl, y, x1, x2, d, src_stride, group_size, power); }
inline void cuda_add_mat(dim3 Gr, dim3 Bl, float alpha, const float *src, float *dst, MatrixDim d, int src_stride, int A_trans) { cudaF_add_mat(Gr,Bl,alpha,src,dst,d,src_stride, A_trans); }
inline void cuda_add_mat_mat_div_mat(dim3 Gr, dim3 Bl, const float *A, const float *B, const float *C, float *dst, MatrixDim d, int stride_a, int stride_b, int stride_c) { cudaF_add_mat_mat_div_mat(Gr,Bl,A,B,C,dst,d,stride_a,stride_b,stride_c); }
inline void cuda_add_vec_to_cols(dim3 Gr, dim3 Bl, float alpha, const float *col, float beta, float *dst, MatrixDim d) { cudaF_add_vec_to_cols(Gr,Bl,alpha,col,beta,dst,d); }
inline void cuda_add_vec_to_rows(dim3 Gr, dim3 Bl, float alpha, const float *row, float beta, float *dst, MatrixDim d) { cudaF_add_vec_to_rows(Gr,Bl,alpha,row,beta,dst,d); }
inline void cuda_transpose_matrix(dim3 Gr, dim3 Bl, float* mat, MatrixDim d) { cudaF_transpose_matrix(Gr, Bl, mat, d); }
inline void cuda_sy_add_tr2(dim3 Gr, dim3 Bl, float alpha, float beta, const float* T, MatrixDim tdim,
                            float *S, MatrixDim sdim) {
  cudaF_sy_add_tr2(Gr, Bl, alpha, beta, T, tdim, S, sdim);
}

/*
 * CuVector
 */
inline void cuda_replace_value(int Gr, int Bl, float *v, int dim, float orig, float changed) {cudaF_replace_value(Gr, Bl, v, dim, orig, changed); }
inline void cuda_div_rows_vec(dim3 Gr, dim3 Bl, float *mat, const float *vec_div, MatrixDim d) { cudaF_div_rows_vec(Gr,Bl,mat,vec_div,d); }
inline void cuda_set_bias_params(int Gr, int Bl, float* v, const float* a, float param_1, float param_2, float param_3, int* flag, int dim) { cudaF_set_bias_params(Gr,Bl,v,a,param_1,param_2,param_3,flag,dim); }
inline void cuda_copy_from_vec_df(int Gr, int Bl, double* v_out, const float* v_in, int dim) { cudaF_copy_from_vec_df(Gr,Bl,v_out,v_in,dim); }
inline void cuda_copy_from_vec_fd(int Gr, int Bl, float* v_out, const float* v_in, int dim) { cudaF_copy_from_vec_fd(Gr,Bl,v_out,v_in,dim); }
inline void cuda_vec_mul_elements(int Gr, int Bl, float* v, const float* a, int dim) { cudaF_vec_mul_elements(Gr,Bl,v,a,dim); }
inline void cuda_vec_soft_max(int Gr, int Bl, float* v, int dim) { cudaF_vec_soft_max(Gr,Bl,v,dim); }
inline void cuda_vec_min(const float* v, float* value, int dim) { cudaF_vec_min(v,value,dim); }
inline void cuda_vec_max(const float* v, float* value, int dim) { cudaF_vec_max(v,value,dim); }
inline void cuda_trace_mat_mat_trans(const float* A, const float* B, MatrixDim dA, int B_stride, float* value) { cudaF_trace_mat_mat_trans(A,B,dA,B_stride,value); }
inline void cuda_trace_mat_mat(const float* A, const float* B, MatrixDim dA, int B_stride, float* value) { cudaF_trace_mat_mat(A,B,dA,B_stride,value); }
inline void cuda_add_diag_mat_mat(int Gr, int Bl, float alpha, float* v, int v_dim, const float* M,
                                  int M_cols, int M_row_stride, int M_col_stride, const float *N, int N_row_stride,
                                  int N_col_stride, int threads_per_element, float beta) {
  cudaF_add_diag_mat_mat(Gr, Bl, alpha, v, v_dim, M, M_cols, M_row_stride, M_col_stride, N, N_row_stride,
                         N_col_stride, threads_per_element, beta);
}
inline void cuda_add_vec_vec(int Gr, int Bl, float alpha, float* v, const float* x, const float* y, float beta, int dim) { cudaF_add_vec_vec(Gr,Bl,alpha,v,x,y,beta,dim); }
inline void cuda_copy_col_from_mat(int Gr, int Bl, float* v, int col, const float* mat, MatrixDim dmat, int dim) { cudaF_copy_col_from_mat(Gr,Bl,v,col,mat,dmat,dim); }
inline void cuda_copy_col_from_mat_df(int Gr, int Bl, double* v, int col, const float* mat, MatrixDim dmat, int dim) { cudaF_copy_col_from_mat_df(Gr,Bl,v,col,mat,dmat,dim); }
inline void cuda_copy_col_from_mat_fd(int Gr, int Bl, float* v, int col, const float* mat, MatrixDim dmat, int dim) { cudaF_copy_col_from_mat_fd(Gr,Bl,v,col,mat,dmat,dim); }
inline void cuda_vec_sum(int Gr, int Bl, float* v, float* value, int dim, int inc) { cudaF_vec_sum(Gr,Bl,v,value,dim,inc); }
inline void cuda_pvec_sum(int Gr, int Bl, float* vec, float* pvec_sum, int dim, int size) { cudaF_pvec_sum(Gr, Bl, vec, pvec_sum, dim, size); }
inline void cuda_vec_copy_diag_from_packed(int Gr, int Bl, float *dst, const float *src, int dim) { cudaF_vec_copy_diag_from_packed(Gr,Bl,dst,src,dim); }
inline void cuda_vec_apply_floor(int Gr, int Bl, float* v, float floor_val, float* num, int dim) { cudaF_vec_apply_floor(Gr,Bl,v,floor_val,num,dim); }
inline void cuda_vec_apply_exp(int Gr, int Bl, float* v, int dim) { cudaF_vec_apply_exp(Gr,Bl,v,dim); }
inline void cuda_vec_apply_log(int Gr, int Bl, float* v, float* flag, int dim) { cudaF_vec_apply_log(Gr,Bl,v,flag,dim); }
inline void cuda_add_row_sum_mat(dim3 Gr, dim3 Bl, const float *mat, float *vec_sum, MatrixDim d) { cudaF_add_row_sum_mat(Gr,Bl,mat,vec_sum,d); }
inline void cuda_add_col_sum_mat(dim3 Gr, dim3 Bl, const float *mat, float *vec_sum, MatrixDim d) { cudaF_add_col_sum_mat(Gr,Bl,mat,vec_sum,d); }
inline void cuda_invert_elements(dim3 Gr, dim3 Bl, float *data, MatrixDim d) { cudaF_invert_elements(Gr,Bl,data,d); }
// B_trans nonzero if B transposed.
inline void cuda_add_mat_blockmat(dim3 Gr, dim3 Bl, float *data, MatrixDim d, const float *Adata,
                                  int A_num_rows, int A_num_cols, int A_row_stride, int A_col_stride,
                                  const CuBlockMatrixData *B_cu_data, int B_num_blocks,
                                  float alpha, float beta, int B_trans) {
  cudaF_add_mat_blockmat(Gr, Bl, data, d, Adata, A_num_rows, A_num_cols, A_row_stride, A_col_stride,
                         B_cu_data, B_num_blocks, alpha, beta, B_trans);
}
inline void cuda_block_add_mat_mat(dim3 Gr, dim3 Bl, CuBlockMatrixData *B_cu_data, int num_blocks,
                                   const float *C_data, int C_num_cols, int C_row_stride, int C_col_stride,
                                   const float *D_data, int D_row_stride, int D_col_stride,
                                   float alpha, float beta) {
  cudaF_block_add_mat_mat(Gr, Bl, B_cu_data, num_blocks, C_data, C_num_cols,
                          C_row_stride, C_col_stride, D_data, D_row_stride,
                          D_col_stride, alpha, beta);
}

/*
 * cu::
 */
inline void cuda_soft_hinge(dim3 Gr, dim3 Bl, float *y, const float *x, MatrixDim d, int src_stride) { cudaF_soft_hinge(Gr,Bl,y,x,d,src_stride); }
inline void cuda_group_pnorm(dim3 Gr, dim3 Bl, float *y, const float *x, MatrixDim d, int src_stride, int group_size, float power) { cudaF_group_pnorm(Gr, Bl, y, x, d, src_stride, group_size, power);}
inline void cuda_sigmoid(dim3 Gr, dim3 Bl, float *y, const float *x, MatrixDim d, int src_stride) { cudaF_sigmoid(Gr,Bl,y,x,d,src_stride); }
inline void cuda_diff_sigmoid(dim3 Gr, dim3 Bl, float *eout, const float *e, const float *y, MatrixDim d, int e_stride, int y_stride) { cudaF_diff_sigmoid(Gr,Bl,eout,e,y,d,e_stride,y_stride); }
inline void cuda_tanh(dim3 Gr, dim3 Bl, float *y, const float *x, MatrixDim d, int src_stride) { cudaF_tanh(Gr,Bl,y,x,d,src_stride); }
inline void cuda_diff_tanh(dim3 Gr, dim3 Bl, float *eout, const float *e, const float *y, MatrixDim d, int e_stride, int y_stride) { cudaF_diff_tanh(Gr,Bl,eout,e,y,d,e_stride,y_stride); }
/*
Bl: dimBlock value is fixed min(d.col, CU1DBLOCK), represent CU1DBLOCK threads reduce a row at the same time.
Gr: the number of rows
*/
inline void cuda_softmax_reduce(size_t Gr, size_t Bl, float *y, const float *x, MatrixDim d, int src_stride) { cudaF_softmax_reduce(Gr,Bl,y,x,d,src_stride); }

inline void cuda_regularize_l1(dim3 Gr, dim3 Bl, float *wei, float *grad, float l1, float lr, MatrixDim d, int stride_grad) { cudaF_regularize_l1(Gr,Bl,wei,grad,l1,lr,d,stride_grad); }
inline void cuda_find_row_max_id(dim3 Gr, dim3 Bl, const float *mat, float *vec_val, int32_cuda *vec_id, int32_cuda voff, MatrixDim d) { cudaF_find_row_max_id(Gr,Bl,mat,vec_val,vec_id,voff,d); }
inline void cuda_diff_xent(dim3 Gr, dim3 Bl, const int32_cuda *vec_tgt, float *mat_net_out, float *vec_log_post, MatrixDim d) { cudaF_diff_xent(Gr,Bl,vec_tgt,mat_net_out,vec_log_post,d); }
inline void cuda_copy_rows_from_vec(dim3 Gr, dim3 Bl, float *mat_out, MatrixDim d_out, const float *v_in) {
  cudaF_copy_rows_from_vec(Gr, Bl, mat_out, d_out, v_in);
}

inline void cuda_randomize(dim3 Gr, dim3 Bl, float *y, const float *x, const int32_cuda *copy_from, MatrixDim d_out, MatrixDim d_in) { cudaF_randomize(Gr,Bl,y,x,copy_from,d_out,d_in); }

inline void cuda_splice(dim3 Gr, dim3 Bl, float *y, const float *x, const int32_cuda *off, MatrixDim d_out, MatrixDim d_in) { cudaF_splice(Gr,Bl,y,x,off,d_out,d_in); }
inline void cuda_one(int Gr,int Bl,float* x,int dim) { cudaF_one(Gr,Bl,x,dim); }
inline void cuda_copy(dim3 Gr, dim3 Bl, float *y, const float *x, const int32_cuda *copy_from, MatrixDim d_out, MatrixDim d_in) { cudaF_copy(Gr,Bl,y,x,copy_from,d_out,d_in); }
inline void cuda_copy_from_sp(dim3 Gr, dim3 Bl, const float* x, float* y, MatrixDim d_out) { cudaF_copy_from_sp(Gr,Bl,x,y,d_out); }
inline void cuda_take_lower(dim3 Gr, dim3 Bl, const float* x, float* y, MatrixDim d_in) { cudaF_take_lower(Gr,Bl,x,y,d_in); }
inline void cuda_take_upper(dim3 Gr, dim3 Bl, const float* x, float* y, MatrixDim d_in) { cudaF_take_upper(Gr,Bl,x,y,d_in); }
inline void cuda_take_mean(dim3 Gr, dim3 Bl, const float* x, float* y, MatrixDim d_in) { cudaF_take_mean(Gr,Bl,x,y,d_in); }
inline void cuda_matrix_add_elements(dim3 Gr, dim3 Bl, float *data, MatrixDim dim, float alpha, MatrixElement<float>* x, int s) { cudaF_matrix_add_elements(Gr, Bl, data, dim, alpha, x, s); }
inline void cuda_comp_obj_deriv(dim3 Gr, dim3 Bl, MatrixElement<float>* x, int32 size, const float* z, MatrixDim d, float* z2, MatrixDim d2, float* t) {cudaF_comp_obj_deriv(Gr,Bl,x,size,z,d,z2,d2,t); }
inline void cuda_sum_column_ranges(dim3 Gr, dim3 Bl, float *data, MatrixDim dim,
                                   const float *src_data, MatrixDim src_dim,
                                   const Int32Pair *indices) {
  cudaF_sum_column_ranges(Gr, Bl, data, dim, src_data, src_dim, indices);
}
inline void cuda_matrix_lookup(dim3 Gr, dim3 Bl, const float *data,
                               MatrixDim dim, const Int32Pair *indices,
                               int indices_size, float *output) {
  cudaF_matrix_lookup(Gr, Bl, data, dim, indices, indices_size, output);
}

inline void cuda_equal_element_mask(dim3 Gr, dim3 Bl, const float *mat1, const float *mat2, float *mask,
                               MatrixDim mat1_dim, int mat2_stride, int mask_stride) {
  cudaF_equal_element_mask(Gr, Bl, mat1, mat2, mask, mat1_dim, mat2_stride, mask_stride);
}

// double versions

/*
 * CuMatrix
 */
inline void cuda_copy_upp_low(dim3 Gr, dim3 Bl, double* A, MatrixDim dimA) { cudaD_copy_upp_low(Gr, Bl, A, dimA); }
inline void cuda_copy_low_upp(dim3 Gr, dim3 Bl, double* A, MatrixDim dimA) { cudaD_copy_low_upp(Gr, Bl, A, dimA); }
inline void cuda_add_diag_vec_mat(dim3 Gr, dim3 Bl, double alpha, double *mat, MatrixDim mat_dim,
                                  const double *vec, const double *mat2, int mat2_row_stride,
                                  int mat2_col_stride, double beta) {
  cudaD_add_diag_vec_mat(Gr, Bl, alpha, mat, mat_dim, vec, mat2,
                         mat2_row_stride, mat2_col_stride, beta);
}
inline void cuda_copy_from_tp_trans(dim3 Gr, dim3 Bl, double* A, const double* B, MatrixDim dmat) { cudaD_copy_from_tp_trans(Gr,Bl,A,B,dmat); }
inline void cuda_copy_from_tp_trans(dim3 Gr, dim3 Bl, double* A, const float* B, MatrixDim dmat) { cudaDF_copy_from_tp_trans(Gr,Bl,A,B,dmat); }
inline void cuda_copy_from_tp(dim3 Gr, dim3 Bl, double* A, const double* B, MatrixDim dmat) { cudaD_copy_from_tp(Gr,Bl,A,B,dmat); }
inline void cuda_copy_from_tp(dim3 Gr, dim3 Bl, double* A, const float* B, MatrixDim dmat) { cudaDF_copy_from_tp(Gr,Bl,A,B,dmat); }
inline void cuda_copy_col_from_vec(int Gr, int Bl, double* mat, const double* v, int col, MatrixDim d) { cudaD_copy_col_from_vec(Gr,Bl,mat,v,col,d); }
inline void cuda_apply_exp(dim3 Gr, dim3 Bl, double* mat, MatrixDim d) { cudaD_apply_exp(Gr,Bl,mat,d); }
inline void cuda_apply_pow(dim3 Gr, dim3 Bl, double* mat, double power, MatrixDim dim) { cudaD_apply_pow(Gr,Bl,mat,power,dim); }
inline void cuda_apply_pow_abs(dim3 Gr, dim3 Bl, double* mat, double power, bool include_sign, MatrixDim dim) { cudaD_apply_pow_abs(Gr,Bl,mat,power,include_sign,dim); }
inline void cuda_apply_heaviside(dim3 Gr, dim3 Bl, double* mat, MatrixDim dim) { cudaD_apply_heaviside(Gr,Bl,mat,dim); }
inline void cuda_apply_floor(dim3 Gr, dim3 Bl, double* mat, double floor_val, MatrixDim dim) { cudaD_apply_floor(Gr,Bl,mat,floor_val,dim); }
inline void cuda_apply_ceiling(dim3 Gr, dim3 Bl, double* mat, double ceiling_val, MatrixDim dim) { cudaD_apply_ceiling(Gr,Bl,mat,ceiling_val,dim); }
inline void cuda_copy_cols(dim3 Gr, dim3 Bl, double* dst, const double* src, const MatrixIndexT_cuda* reorder, MatrixDim dst_dim, int src_stride) {
  cudaD_copy_cols(Gr, Bl, dst, src, reorder, dst_dim, src_stride);
}
inline void cuda_copy_rows(dim3 Gr, dim3 Bl, double* dst, const double* src, const MatrixIndexT_cuda* reorder, MatrixDim dst_dim, int src_stride) {
  cudaD_copy_rows(Gr, Bl, dst, src, reorder, dst_dim, src_stride);
}
inline void cuda_trace(int Gr, int Bl, double* mat, double* value, int dim) { cudaD_trace(Gr,Bl,mat,value,dim); }
inline void cuda_set_diag(int Gr, int Bl, double* mat, double value, MatrixDim d) { cudaD_set_diag(Gr,Bl,mat,value,d); }
inline void cuda_set_diag_packed(int Gr, int Bl, double* mat, double value, int dim) { cudaD_set_diag_packed(Gr,Bl,mat,value,dim); }
inline void cuda_add_diag_packed(int Gr, int Bl, double* mat, double value, int dim) { cudaD_add_diag_packed(Gr,Bl,mat,value,dim); }
inline void cuda_set_const(dim3 Gr, dim3 Bl, double *mat, double value, MatrixDim d) { cudaD_set_const(Gr,Bl,mat,value,d); }
inline void cuda_set_zero_above_diag(dim3 Gr, dim3 Bl, double* mat, MatrixDim d) { cudaD_set_zero_above_diag(Gr,Bl,mat,d); }
inline void cuda_add(dim3 Gr, dim3 Bl, double *mat, double value, MatrixDim d) { cudaD_add(Gr,Bl,mat,value,d); }
inline void cuda_add_vec2(dim3 Gr, dim3 Bl, double *mat, const double *vec, const double alpha, int dim) { cudaD_add_vec2(Gr,Bl,mat,vec,alpha,dim); }
inline void cuda_scale_diag_packed(int Gr, int Bl, double* mat, double value, int dim) { cudaD_scale_diag_packed(Gr,Bl,mat,value,dim); }
inline void cuda_scale(dim3 Gr, dim3 Bl, double *mat, double value, MatrixDim d) { cudaD_scale(Gr,Bl,mat,value,d); }
inline void cuda_apply_log(dim3 Gr, dim3 Bl, double *mat, MatrixDim d) { cudaD_apply_log(Gr,Bl,mat,d); }
inline void cuda_mul_elements(dim3 Gr, dim3 Bl, double *mat, const double *A, MatrixDim dst_d, int src_stride) {
  cudaD_mul_elements(Gr,Bl,mat,A,dst_d,src_stride);
}
inline void cuda_max(dim3 Gr, dim3 Bl, double *mat, const double *A, MatrixDim dst_d, int src_stride) {
  cudaD_max(Gr,Bl,mat,A,dst_d,src_stride);
}
inline void cuda_mul_cols_vec(dim3 Gr, dim3 Bl, double *mat, const double *scale, MatrixDim d) { cudaD_mul_cols_vec(Gr,Bl,mat,scale,d); }
inline void cuda_mul_rows_vec(dim3 Gr, dim3 Bl, double *mat, const double *scale, MatrixDim d) { cudaD_mul_rows_vec(Gr,Bl,mat,scale,d); }
inline void cuda_mul_rows_group_mat(dim3 Gr, dim3 Bl, double *y, const double *x, MatrixDim d, int src_stride, int group_size) { cudaD_mul_rows_group_mat(Gr, Bl, y, x, d, src_stride, group_size); }
inline void cuda_calc_pnorm_deriv(dim3 Gr, dim3 Bl, double *y, const double *x1, const double *x2,  MatrixDim d, int src_stride, int group_size, double power) {cudaD_calc_pnorm_deriv(Gr, Bl, y, x1, x2, d, src_stride, group_size, power); }
inline void cuda_add_mat(dim3 Gr, dim3 Bl, double alpha, const double *src, double *dst, MatrixDim d, int src_stride, int A_trans) { cudaD_add_mat(Gr,Bl,alpha,src,dst,d,src_stride, A_trans); }
inline void cuda_add_mat_mat_div_mat(dim3 Gr, dim3 Bl, const double *A, const double *B, const double *C, double *dst, MatrixDim d, int stride_a, int stride_b, int stride_c) { cudaD_add_mat_mat_div_mat(Gr,Bl,A,B,C,dst,d,stride_a,stride_b,stride_c); }
inline void cuda_add_vec_to_cols(dim3 Gr, dim3 Bl, double alpha, const double *col, double beta, double *dst, MatrixDim d) { cudaD_add_vec_to_cols(Gr,Bl,alpha,col,beta,dst,d); }
inline void cuda_add_vec_to_rows(dim3 Gr, dim3 Bl, double alpha, const double *row, double beta, double *dst, MatrixDim d) { cudaD_add_vec_to_rows(Gr,Bl,alpha,row,beta,dst,d); }
inline void cuda_transpose_matrix(dim3 Gr, dim3 Bl, double *mat, MatrixDim d) { cudaD_transpose_matrix(Gr, Bl, mat, d); }
inline void cuda_sy_add_tr2(dim3 Gr, dim3 Bl, double alpha, double beta, const double* T, MatrixDim tdim,
                            double *S, MatrixDim sdim) {
  cudaD_sy_add_tr2(Gr, Bl, alpha, beta, T, tdim, S, sdim);
}

/*
 * CuVector
 */
inline void cuda_replace_value(int Gr, int Bl, double *v, int dim, double orig, double changed) {cudaD_replace_value(Gr, Bl, v, dim, orig, changed); }
inline void cuda_div_rows_vec(dim3 Gr, dim3 Bl, double *mat, const double *vec_div, MatrixDim d) { cudaD_div_rows_vec(Gr,Bl,mat,vec_div,d); }
inline void cuda_set_bias_params(int Gr, int Bl, double* v, const double* a, double param_1, double param_2, double param_3, int* flag, int dim) { cudaD_set_bias_params(Gr,Bl,v,a,param_1,param_2,param_3,flag,dim); }
inline void cuda_copy_from_vec_df(int Gr, int Bl, double* v_out, const double* v_in, int dim) { cudaD_copy_from_vec_df(Gr,Bl,v_out,v_in,dim); }
inline void cuda_copy_from_vec_fd(int Gr, int Bl, float* v_out, const double* v_in, int dim) { cudaD_copy_from_vec_fd(Gr,Bl,v_out,v_in,dim); }
inline void cuda_vec_mul_elements(int Gr, int Bl, double* v, const double* a, int dim) { cudaD_vec_mul_elements(Gr,Bl,v,a,dim); }
inline void cuda_vec_soft_max(int Gr, int Bl, double* v, int dim) { cudaD_vec_soft_max(Gr,Bl,v,dim); }
inline void cuda_vec_min(const double* v, double* value, int dim) { cudaD_vec_min(v,value,dim); }
inline void cuda_vec_max(const double* v, double* value, int dim) { cudaD_vec_max(v,value,dim); }
inline void cuda_trace_mat_mat_trans(const double* A, const double* B, MatrixDim dA, int B_stride, double* value) { cudaD_trace_mat_mat_trans(A,B,dA,B_stride,value); }
inline void cuda_trace_mat_mat(const double* A, const double* B, MatrixDim dA, int B_stride, double* value) { cudaD_trace_mat_mat(A,B,dA,B_stride,value); }
inline void cuda_add_diag_mat_mat(int Gr, int Bl, double alpha, double* v, int v_dim, const double* M,
                                  int M_cols, int M_row_stride, int M_col_stride, const double *N, int N_row_stride,
                                  int N_col_stride, int threads_per_element, double beta) {
  cudaD_add_diag_mat_mat(Gr, Bl, alpha, v, v_dim, M, M_cols, M_row_stride, M_col_stride, N, N_row_stride,
                         N_col_stride, threads_per_element, beta);
}
inline void cuda_add_vec_vec(int Gr, int Bl, double alpha, double* v, const double* x, const double* y, double beta, int dim) { cudaD_add_vec_vec(Gr,Bl,alpha,v,x,y,beta,dim); }
inline void cuda_copy_col_from_mat(int Gr, int Bl, double* v, int col, const double* mat, MatrixDim dmat, int dim) { cudaD_copy_col_from_mat(Gr,Bl,v,col,mat,dmat,dim); }
inline void cuda_copy_col_from_mat_df(int Gr, int Bl, double* v, int col, const double* mat, MatrixDim dmat, int dim) { cudaD_copy_col_from_mat_df(Gr,Bl,v,col,mat,dmat,dim); }
inline void cuda_copy_col_from_mat_fd(int Gr, int Bl, float* v, int col, const double* mat, MatrixDim dmat, int dim) { cudaD_copy_col_from_mat_fd(Gr,Bl,v,col,mat,dmat,dim); }
inline void cuda_vec_sum(int Gr, int Bl, double* v, double* value, int dim, int inc) { cudaD_vec_sum(Gr,Bl,v,value,dim,inc); }
inline void cuda_pvec_sum(int Gr, int Bl, double* vec, double* pvec_sum, int dim, int size) { cudaD_pvec_sum(Gr,Bl,vec,pvec_sum,dim,size); }
inline void cuda_vec_copy_diag_from_packed(int Gr, int Bl, double *dst, const double *src, int dim) { cudaD_vec_copy_diag_from_packed(Gr,Bl,dst,src,dim); }
inline void cuda_vec_apply_floor(int Gr, int Bl, double* v, double floor_val, float* num, int dim) { cudaD_vec_apply_floor(Gr,Bl,v,floor_val,num,dim); }
inline void cuda_vec_apply_exp(int Gr, int Bl, double* v, int dim) { cudaD_vec_apply_exp(Gr,Bl,v,dim); }
inline void cuda_vec_apply_log(int Gr, int Bl, double* v, double* flag, int dim) { cudaD_vec_apply_log(Gr,Bl,v,flag,dim); }
inline void cuda_add_row_sum_mat(dim3 Gr, dim3 Bl, const double *mat, double *vec_sum, MatrixDim d) { cudaD_add_row_sum_mat(Gr,Bl,mat,vec_sum,d); }
inline void cuda_add_col_sum_mat(dim3 Gr, dim3 Bl, const double *mat, double *vec_sum, MatrixDim d) { cudaD_add_col_sum_mat(Gr,Bl,mat,vec_sum,d); }
inline void cuda_invert_elements(dim3 Gr, dim3 Bl, double *data, MatrixDim d) { cudaD_invert_elements(Gr,Bl,data,d); }
// B_trans nonzero if B transposed.
inline void cuda_add_mat_blockmat(dim3 Gr, dim3 Bl, double *data, MatrixDim d, const double *Adata,
                                  int A_num_rows, int A_num_cols, int A_row_stride, int A_col_stride,
                                  const CuBlockMatrixData *B_cu_data, int B_num_blocks,
                                  double alpha, double beta, int B_trans) {
  cudaD_add_mat_blockmat(Gr, Bl, data, d, Adata, A_num_rows, A_num_cols, A_row_stride, A_col_stride,
                         B_cu_data, B_num_blocks, alpha, beta, B_trans);
}
inline void cuda_block_add_mat_mat(dim3 Gr, dim3 Bl, CuBlockMatrixData *B_cu_data, int num_blocks,
                                   const double *C_data, int C_num_cols, int C_row_stride, int C_col_stride,
                                   const double *D_data, int D_row_stride, int D_col_stride,
                                   double alpha, double beta) {
  cudaD_block_add_mat_mat(Gr, Bl, B_cu_data, num_blocks, C_data, C_num_cols,
                          C_row_stride, C_col_stride, D_data, D_row_stride,
                          D_col_stride, alpha, beta);
}

/*
 * cu::
 */
inline void cuda_soft_hinge(dim3 Gr, dim3 Bl, double *y, const double *x, MatrixDim d, int src_stride) { cudaD_soft_hinge(Gr,Bl,y,x,d,src_stride); }
inline void cuda_group_pnorm(dim3 Gr, dim3 Bl, double *y, const double *x, MatrixDim d, int src_stride, int group_size, double power) { cudaD_group_pnorm(Gr, Bl, y, x, d, src_stride, group_size, power); }
inline void cuda_sigmoid(dim3 Gr, dim3 Bl, double *y, const double *x, MatrixDim d, int src_stride) { cudaD_sigmoid(Gr,Bl,y,x,d,src_stride); }
inline void cuda_diff_sigmoid(dim3 Gr, dim3 Bl, double *eout, const double *e, const double *y, MatrixDim d, int e_stride, int y_stride) { cudaD_diff_sigmoid(Gr,Bl,eout,e,y,d,e_stride,y_stride); }
inline void cuda_tanh(dim3 Gr, dim3 Bl, double *y, const double *x, MatrixDim d, int src_stride) { cudaD_tanh(Gr,Bl,y,x,d,src_stride); }
inline void cuda_diff_tanh(dim3 Gr, dim3 Bl, double *eout, const double *e, const double *y, MatrixDim d, int e_stride, int y_stride) { cudaD_diff_tanh(Gr,Bl,eout,e,y,d,e_stride,y_stride); }
inline void cuda_softmax_reduce(size_t Gr, size_t Bl, double *y, const double *x, MatrixDim d, int src_stride) { cudaD_softmax_reduce(Gr,Bl,y,x,d,src_stride); }

inline void cuda_regularize_l1(dim3 Gr, dim3 Bl, double *wei, double *grad, double l1, double lr, MatrixDim d, int stride_grad) { cudaD_regularize_l1(Gr,Bl,wei,grad,l1,lr,d,stride_grad); }
inline void cuda_find_row_max_id(dim3 Gr, dim3 Bl, const double *mat, double *vec_val, int32_cuda *vec_id, int32_cuda voff, MatrixDim d) { cudaD_find_row_max_id(Gr,Bl,mat,vec_val,vec_id,voff,d); }
inline void cuda_diff_xent(dim3 Gr, dim3 Bl, const int32_cuda *vec_tgt, double *mat_net_out, double *vec_log_post, MatrixDim d) {
  cudaD_diff_xent(Gr,Bl,vec_tgt,mat_net_out,vec_log_post,d);
}
inline void cuda_copy_rows_from_vec(dim3 Gr, dim3 Bl, double *mat_out, MatrixDim d_out, const double *v_in) {
  cudaD_copy_rows_from_vec(Gr, Bl, mat_out, d_out, v_in);
}

inline void cuda_randomize(dim3 Gr, dim3 Bl, double *y, const double *x, const int32_cuda *copy_from, MatrixDim d_out, MatrixDim d_in) { cudaD_randomize(Gr,Bl,y,x,copy_from,d_out,d_in); }
inline void cuda_splice(dim3 Gr, dim3 Bl, double *y, const double *x, const int32_cuda *off, MatrixDim d_out, MatrixDim d_in) { cudaD_splice(Gr,Bl,y,x,off,d_out,d_in); }
inline void cuda_one(int Gr,int Bl,double* x,int dim) { cudaD_one(Gr,Bl,x,dim); }
inline void cuda_copy(dim3 Gr, dim3 Bl, double *y, const double *x, const int32_cuda *copy_from, MatrixDim d_out, MatrixDim d_in) { cudaD_copy(Gr,Bl,y,x,copy_from,d_out,d_in); }
inline void cuda_copy_from_sp(dim3 Gr, dim3 Bl, const double* x, double* y, MatrixDim d_out) { cudaD_copy_from_sp(Gr,Bl,x,y,d_out); }
inline void cuda_take_lower(dim3 Gr, dim3 Bl, const double* x, double* y, MatrixDim d_in) { cudaD_take_lower(Gr,Bl,x,y,d_in); }
inline void cuda_take_upper(dim3 Gr, dim3 Bl, const double* x, double* y, MatrixDim d_in) { cudaD_take_upper(Gr,Bl,x,y,d_in); }
inline void cuda_take_mean(dim3 Gr, dim3 Bl, const double* x, double* y, MatrixDim d_in) { cudaD_take_mean(Gr,Bl,x,y,d_in); }
inline void cuda_matrix_add_elements(dim3 Gr, dim3 Bl, double *data, MatrixDim dim, double alpha, MatrixElement<double>* x, int s) { cudaD_matrix_add_elements(Gr, Bl, data, dim, alpha, x, s); }
inline void cuda_comp_obj_deriv(dim3 Gr, dim3 Bl, MatrixElement<double>* x, int32 size, const double* z, MatrixDim d, double* z2, MatrixDim d2, double* t) {cudaD_comp_obj_deriv(Gr,Bl,x,size,z,d,z2,d2,t); }
inline void cuda_sum_column_ranges(dim3 Gr, dim3 Bl, double *data, MatrixDim dim,
                                   const double *src_data, MatrixDim src_dim, const Int32Pair *indices) {
  cudaD_sum_column_ranges(Gr, Bl, data, dim, src_data, src_dim, indices);
}
inline void cuda_matrix_lookup(dim3 Gr, dim3 Bl, const double *data,
                               MatrixDim dim, const Int32Pair *indices,
                               int indices_size, double *output) {
  cudaD_matrix_lookup(Gr, Bl, data, dim, indices, indices_size, output);
}

inline void cuda_equal_element_mask(dim3 Gr, dim3 Bl, const double *mat1, const double *mat2, double *mask,
                                    MatrixDim mat1_dim, int mat2_stride, int mask_stride) {
  cudaD_equal_element_mask(Gr, Bl, mat1, mat2, mask, mat1_dim, mat2_stride, mask_stride);
}

// Also include some template-friendly wrappers of cublas functions:
inline void cuda_axpy(int n, float alpha, const float *x, int incx, float *y, int incy) {
  cublasSaxpy(n, alpha, x, incx, y, incy);
}
inline void cuda_axpy(int n, double alpha, const double *x, int incx, double *y, int incy) {
  cublasDaxpy(n, alpha, x, incx, y, incy);
}
inline void cuda_scal(int n, float alpha, float *x, int incx) {
  cublasSscal(n, alpha, x, incx);
}
inline void cuda_scal(int n, double alpha, double *x, int incx) {
  cublasDscal(n, alpha, x, incx);
}

inline void cuda_add_mat_diag_vec(dim3 Gr, dim3 Bl, float alpha, float *mat, MatrixDim mat_dim,
                                  const float *mat2, int mat2_row_stride, int mat2_col_stride,
                                  const float *vec,  float beta) {
    cudaF_add_mat_diag_vec(Gr, Bl, alpha, mat, mat_dim, mat2,
                           mat2_row_stride, mat2_col_stride, vec, beta);
}
inline void cuda_add_mat_diag_vec(dim3 Gr, dim3 Bl, double alpha, double *mat, MatrixDim mat_dim,
                                  const double *mat2, int mat2_row_stride, int mat2_col_stride,
                                  const double *vec,  double beta) {
    cudaD_add_mat_diag_vec(Gr, Bl, alpha, mat, mat_dim, mat2,
                           mat2_row_stride, mat2_col_stride, vec, beta);
}

inline void cuda_add_mat_dot_mat(dim3 Gr, dim3 Bl, float *data, const float *srcA_data, const float *srcB_data, int transA,
        int transB, MatrixDim dim, int srcA_stride, int srcB_stride, float alpha, float beta) {
    cudaF_add_mat_dot_mat(Gr, Bl, data, srcA_data, srcB_data, transA, transB, dim, srcA_stride, srcB_stride, alpha, beta);
}
inline void cuda_add_mat_dot_mat(dim3 Gr, dim3 Bl, double *data, const double *srcA_data, const double *srcB_data, int transA,
        int transB, MatrixDim dim, int srcA_stride, int srcB_stride, double alpha, double beta) {
    cudaD_add_mat_dot_mat(Gr, Bl, data, srcA_data, srcB_data, transA, transB, dim, srcA_stride, srcB_stride, alpha, beta);
}

inline void cuda_compute_ctc_alpha(dim3 Gr, dim3 Bl, float *alpha, int row_idx, MatrixDim dim_alpha, const float *prob, MatrixDim dim_prob, const int *labels) {
  cudaF_compute_ctc_alpha(Gr, Bl, alpha, row_idx, dim_alpha, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_beta(dim3 Gr, dim3 Bl, float *beta, int row_idx, MatrixDim dim_beta, const float *prob, MatrixDim dim_prob, const int *labels) {
  cudaF_compute_ctc_beta(Gr, Bl, beta, row_idx, dim_beta, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_error(dim3 Gr, dim3 Bl, float *error, MatrixDim dim_error, const float *alpha, const float *beta, MatrixDim dim_alpha, const float *prob, const int *labels, float pzx) {
  cudaF_compute_ctc_error(Gr, Bl, error, dim_error, alpha, beta, dim_alpha, prob, labels, pzx);
}
inline void cuda_compute_ctc_alpha_rescale(dim3 Gr, dim3 Bl, float *alpha, int row_idx, MatrixDim dim_alpha, const float *prob, MatrixDim dim_prob, const int *labels) {
  cudaF_compute_ctc_alpha_rescale(Gr, Bl, alpha, row_idx, dim_alpha, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_beta_rescale(dim3 Gr, dim3 Bl, float *beta, int row_idx, MatrixDim dim_beta, const float *prob, MatrixDim dim_prob, const int *labels) {
  cudaF_compute_ctc_beta_rescale(Gr, Bl, beta, row_idx, dim_beta, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_error_rescale(dim3 Gr, dim3 Bl, float *error, MatrixDim dim_error, const float *alpha, const float *beta, MatrixDim dim_alpha, const float *prob, const int *labels, float *zt) {
  cudaF_compute_ctc_error_rescale(Gr, Bl, error, dim_error, alpha, beta, dim_alpha, prob, labels, zt);
}
inline void cuda_distribute_prob_by_label(dim3 Gr, dim3 Bl, float *prob_dist, MatrixDim dim_prob_dist, const float *prob, MatrixDim dim_prob, const int *labels) {
  cudaF_distribute_prob_by_label(Gr, Bl, prob_dist, dim_prob_dist, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_alpha_multiple_sequence(dim3 Gr, dim3 Bl, float *alpha, int seq_num, int row_idx, MatrixDim dim_alpha, const float *prob, MatrixDim dim_prob, const int *labels, int dim_label_stride, const int *seq_lengths) {
  cudaF_compute_ctc_alpha_multiple_sequence(Gr, Bl, alpha, seq_num, row_idx, dim_alpha, prob, dim_prob, labels, dim_label_stride, seq_lengths);
}
inline void cuda_compute_ctc_beta_multiple_sequence(dim3 Gr, dim3 Bl, float *beta, int seq_num, int row_idx, MatrixDim dim_beta, const float *prob, MatrixDim dim_prob, const int *labels, int dim_label_stride, const int *seq_lengths, const int *label_lengths) {
  cudaF_compute_ctc_beta_multiple_sequence(Gr, Bl, beta, seq_num, row_idx, dim_beta, prob, dim_prob, labels, dim_label_stride, seq_lengths, label_lengths);
}
inline void cuda_compute_ctc_error_multiple_sequence(dim3 Gr, dim3 Bl, float *error, int seq_num, MatrixDim dim_error, const float *alpha, const float *beta, MatrixDim dim_alpha, const float *prob, const int *labels, int dim_label_stride, const int *seq_lengths, const float *pzx) {
  cudaF_compute_ctc_error_multiple_sequence(Gr, Bl, error, seq_num, dim_error, alpha, beta, dim_alpha, prob, labels, dim_label_stride, seq_lengths, pzx);
}

inline void cuda_compute_ctc_alpha(dim3 Gr, dim3 Bl, double *alpha, int row_idx, MatrixDim dim_alpha, const double *prob, MatrixDim dim_prob, const int *labels) {
  cudaD_compute_ctc_alpha(Gr, Bl, alpha, row_idx, dim_alpha, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_beta(dim3 Gr, dim3 Bl, double *beta, int row_idx, MatrixDim dim_beta, const double *prob, MatrixDim dim_prob, const int *labels) {
  cudaD_compute_ctc_beta(Gr, Bl, beta, row_idx, dim_beta, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_error(dim3 Gr, dim3 Bl, double *error, MatrixDim dim_error, const double *alpha, const double *beta, MatrixDim dim_alpha, const double *prob, const int *labels, double pzx) {
  cudaD_compute_ctc_error(Gr, Bl, error, dim_error, alpha, beta, dim_alpha, prob, labels, pzx);
}
inline void cuda_compute_ctc_alpha_rescale(dim3 Gr, dim3 Bl, double *alpha, int row_idx, MatrixDim dim_alpha, const double *prob, MatrixDim dim_prob, const int *labels) {
  cudaD_compute_ctc_alpha_rescale(Gr, Bl, alpha, row_idx, dim_alpha, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_beta_rescale(dim3 Gr, dim3 Bl, double *beta, int row_idx, MatrixDim dim_beta, const double *prob, MatrixDim dim_prob, const int *labels) {
  cudaD_compute_ctc_beta_rescale(Gr, Bl, beta, row_idx, dim_beta, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_error_rescale(dim3 Gr, dim3 Bl, double *error, MatrixDim dim_error, const double *alpha, const double *beta, MatrixDim dim_alpha, const double *prob, const int *labels, double *zt) {
  cudaD_compute_ctc_error_rescale(Gr, Bl, error, dim_error, alpha, beta, dim_alpha, prob, labels, zt);
}
inline void cuda_distribute_prob_by_label(dim3 Gr, dim3 Bl, double *prob_dist, MatrixDim dim_prob_dist, const double *prob, MatrixDim dim_prob, const int *labels) {
  cudaD_distribute_prob_by_label(Gr, Bl, prob_dist, dim_prob_dist, prob, dim_prob, labels);
}
inline void cuda_compute_ctc_alpha_multiple_sequence(dim3 Gr, dim3 Bl, double *alpha, int seq_num, int row_idx, MatrixDim dim_alpha, const double *prob, MatrixDim dim_prob, const int *labels, int dim_label_stride, const int *seq_lengths) {
  cudaD_compute_ctc_alpha_multiple_sequence(Gr, Bl, alpha, seq_num, row_idx, dim_alpha, prob, dim_prob, labels, dim_label_stride, seq_lengths);
}
inline void cuda_compute_ctc_beta_multiple_sequence(dim3 Gr, dim3 Bl, double *beta, int seq_num, int row_idx, MatrixDim dim_beta, const double *prob, MatrixDim dim_prob, const int *labels, int dim_label_stride, const int *seq_lengths, const int *label_lengths) {
  cudaD_compute_ctc_beta_multiple_sequence(Gr, Bl, beta, seq_num, row_idx, dim_beta, prob, dim_prob, labels, dim_label_stride, seq_lengths, label_lengths);
}
inline void cuda_compute_ctc_error_multiple_sequence(dim3 Gr, dim3 Bl, double *error, int seq_num, MatrixDim dim_error, const double *alpha, const double *beta, MatrixDim dim_alpha, const double *prob, const int *labels, int dim_label_stride, const int *seq_lengths, const double *pzx) {
  cudaD_compute_ctc_error_multiple_sequence(Gr, Bl, error, seq_num, dim_error, alpha, beta, dim_alpha, prob, labels, dim_label_stride, seq_lengths, pzx);
}

} // namespace kaldi

#endif // HAVE_CUDA

#endif

redpajama_set_name: RedPajamaGithub


Important Disclosure: Mascia Development LLC This website is for informational and discussion purposes only and is not intended to be an offer to buy or sell an interest in any entity or project or Mascia Development LLC ("Company"). Any such offer or solicitation may be made only by delivery of the applicable confidential offering documents to qualified eligible investors. You should not rely in any way on this website or any summary contained therein. This website and associated summaries are not intended to be, nor shall it be construed as, legal, tax or financial advice.
The information contained herein is not complete, is subject to change and is subject to and qualified in its entirety by the more complete disclosures, risk factors, and other terms and conditions that are contained in the Company's confidential offering documents (namely its Private Placement Memorandum and agreements governing the rights among Company investors). No representation or warranty is made as to the information presented herein (including, without limitation, portions of the information which rely on third party sources).
Investment in the Company will involve significant investment risks, including significant restrictions on transferability and risk of loss of the entire investment. Prior to making an investment, prospective investors should consult with their advisors.
Any performance results or projections discussed herein are for illustration purposes only. Past performance is not indicative of future results. No representation is made that the Company will or is likely to achieve its objectives, that the investment process or risk management for the Company will be successful, or that an investor in the Company will or is likely to achieve results comparable to those shown or will make any profit or will not suffer losses. Certain information contained herein constitutes "forward-looking statements" which can be identified by the use of words such as "may", "will", "expect", "anticipate", "potential", "estimate", "ensure", "intend", "continues", "hope", or "believe" or variations thereof. Due to various risks and uncertainties, actual events or performance results of the Company may differ materially from those reflected or contemplated in such forward-looking statements.
The Company will not be registered under the Investment Company Act of 1940, as amended, and accordingly the interest in the Company will not be subject to the protections of the Act. Any securities in the Company may be sold only to "accredited investors," which for natural persons are investors who meet certain minimum annual income or net worth thresholds. Neither the Securities and Exchange Commission nor any state securities authority has passed upon the merits of or given its approval to the securities, the terms of the offering, or the accuracy or completeness of any offering materials.
The securities of the Company are subject to restrictions on transferability and resale and may not be transferred or resold unless registered under applicable laws or pursuant to exceptions from registration thereunder. In addition, transfers of securities in the Company will be further restricted by the Company's limited liability company agreement. Accordingly, investors should be able to bear the financial risks of an investment in the Company for an indefinite period of time.
© 2017 Mascia Development LLC, All Rights Reserved.


text:
Hobart Rowland , Gerard Choucroun , Robin Myrick and Jim Sherman October 17, 1996 4:00AM
Lemonheads
Car Button Cloth
Tag/Atlantic
No matter how hard he tries to convince us otherwise, head Lemonhead Evan Dando rarely sounds as if he's lifting a finger. Through two phases of development (from yesterday's sloppy junk-punk to today's sloppy junk-pop) as distinct as they are alike, Dando has blazed a trail littered with partially realized potential. Forget lo-fi jack-offs Sebadoh and Pavement; the Lemonheads are the true embodiment of slackerdom.
A few of us were foolish enough to think Dando's half-assed antics had come to an end with 1992's It's a Shame About Ray, a richly textured, relentlessly catchy release that remains the Lemonheads' best and most consistent work. Then a year later he blurted out a defiant "fuck that" in the form of Come on Feel the Lemonheads, another part good, part lousy affair that contained both Dando's most effortless pop masterpiece ("The Great Big NO") and his most embarrassing misfire (the ludicrous two-part noisefest "Style"/"Rick James Style").
Car Button Cloth continues Dando's obsession with indolence. In his infamous hung-over delivery, the reluctant alt-rock sex symbol mumbles about being a drug-taking screwup ("It's All True," "If I Could Talk I'd Tell You"), confesses to being a homebody ("The Outdoor Type"), cheerily documents a mysterious epidemic ("Hospital") and rambles for two and half minutes about a disturbing scene from the morbid psycho-thriller Seven ("6ix"). "Purple Parallelogram," Dando's much-talked-about collaboration with Oasis guitarist Noel Gallagher, is missing, the victim of a last-minute excision after Gallagher decided the tune wasn't finished. As for the rest of the CD's 13 tracks, they're essentially table scraps -- at times interesting, at times inane. Cloth dips to its lowest points on two shrill, overextended "conceptual" pieces ("Losing Your Mind" and "Secular Rockulidge") in which the principal concept seems to revolve around filling space.
And therein, oddly, lies Dando's charm: he's at his most interesting simply killing time. His mind isn't programmed to break a sweat. Take him or leave him, Evan is Evan, the bane of many a "serious" music critic, and for more than a few of us, an engaging guilty pleasure. (***)
-- Hobart Rowland
Cowboy Mouth
A few years back, Cowboy Mouth made a pact with another then-fledgling band, agreeing that if either group ever made it big, they would try to take their tourmates along with them. Too many nights playing to packed fraternity haunts is enough to lead anyone to make such a deal -- but when you consider the fact that the other band was Hootie and the Blowfish, that deal takes on a new significance.
Now, thanks in part to exposure received from gigs opening for old friends Hootie, Cowboy Mouth has its crack at the brass ring with its major-label debut, Are You with Me? All of the tracks stick to the ears, and all of them are impossibly dorky, with the overall effect approximating that of Mojo Nixon crooning "My Love" by Paul McCartney and Wings. The group plays with a macho "we're gonna rock you" swagger and yet emotes with an overtly sensitive, swooning sentimentality that, at its most corny, makes the Pet Shop Boys sound tough. Are You with Me? makes the case that the group should dump the bravado altogether and shoot straight for schmaltz. And when Cowboy Mouth figures that out, there's a good chance they won't need their pals to carry them anymore. (**)
-- Gerard Choucroun
Cowboy Mouth performs Wednesday, October 23, at the Fabulous Satellite Lounge.
In her early days with the Bangles, Susanna Hoffs crafted many of the Beatlesque gems that brought the girl group to the front of the paisley underground pack. Then came the band's cash cow era, and the immense popularity of sex-pot mush such as "Eternal Flame," which made getting off the Top 40 gravy train a pricey withdrawal. This second solo stab may well reclaim Hoffs' career, but she's still wavering too much between rock and lip-gloss pop to demonstrate an honest sound of her own.
Part of the problem lies with Hoffs' reliance on others -- people such as David Baerwald, late of David and David and Sheryl Crow's Tuesday Night Music Club, who has writing credits on six of the 13 tracks. His contributions overshadow a terrific lineup of alterna-guests who could have helped Hoffs take the CD in a more interesting direction. Roger Manning (former Jellyfish, now Imperial Drag), Charlotte Caffey (Go-Go's), Mark Linkous (Sparklehorse), David Lowery and Davey Faragher (Cracker), Linda Perry (former 4 Non Blondes) and Matthew Sweet are among the many talents who pitch ideas into Susanna Hoffs.
Take Baerwald out of the picture, and we see a different release emerge. Hoffs' collaboration with Linkous yields the crumpled guitar figures and transcendent appeal of "Enormous Wings," and when they're joined by Lowery and Faragher we get another great surprise, the drowsy goodnight kiss "Darling One." But the best of the bunch is "Falling," a Hoffs/Manning/Caffey composition that hums like a GTO chugging up a sandy beach, with creamy harmonies and good vibrations to burn. These tracks -- plus the two unlisted covers at the end, Lulu's '60s smash "To Sir with Love" and Stealers Wheel's "Stuck in the Middle with You" -- make a strong case for what could have been. But instead, like the4 a.m.-smudged-eye-shadow glamour that Hoffs adopts for the CD's artwork, much of Susanna Hoffs leaves us with little more than a teasing image. (** 1/2)
-- Robin Myrick
Floyd Dixon
Wake Up and Live!
Boogie-woogie piano legend Floyd Dixon's return from obscurity marks a welcome addition to the ranks of artiss who shaped post-World War II American music and who, decades later, are finally receiving the recognition they deserve. There's not a rock fan alive who can't, purely on reflex, shout the chorus to "Hey, Bartender," and who has more right to the song than the guy who wrote the thing in the first place? For that matter, Dixon still does the tune better than anyone else.
Wake Up and Live! -- happily recorded using vintage tube pre-amps, since jump blues don't need no transistors -- has nary a wrong note on it. If there's a glitch to this CD, it's that the sequencing is unsettling. Dixon, like his contemporaries Charles Brown and Amos Milburn, is a master of both slow blues and jump blues. Unfortunately, Wake Up exhibits this by jerkily rotating from jump to slow to jump for 15 of the CD's 16 tracks, until finally settling down for the jazzy instrumental "Gettin' Ready," which features as pretty an upright bass line as you'll ever hear. Given that there's not a clue that Dixon and baritone sax behemoth Charlie Owens, who adds his sound to half the tracks, were in any danger of running out of magic, Alligator should have cut enough tracks for a two-CD set -- one for jitterbugging and one for blues therapy. After all, who needs a slow, viscous, whiskey-drunk "Mean and Jealous Man" right next to a good-timing "450 Pound Woman?" (****)
-- Jim Sherman
Floyd Dixon performs Thursday, October 17, at Billy Blues Bar & Grill.
CDs are rated on a one to five star scale.
Gerard Choucroun
Robin Myrick
Hobart Rowland
Jim Sherman
After Illness and Loss, Blues Guitarist Ana Popović Emerges with Power
Top 10 Butt-Rock Bands of All Time
The Five Most Repellent Things Ted Nugent Has Ever Done
Monday Is the New Friday at Debonair Lounge
By Angelica Leicht
In the Flesh: Houston Musicians Talk Tattoos
Nightfly: Cheap Beers and Questionable Music Choices at Alice's Tall Texan

redpajama_set_name: RedPajamaCommonCrawl


Self-employment entrepreneur or running your own business can be an attractive alternative when you live abroad. Especially in the Netherlands, there is a very supportive climate for starting your own business. You certainly have to bear in mind that "Being prepared is the key to success." You want to be sure that you didn't miss anything? Entrepreneurship by lifestyle is designed to assist accompanying partners in their search of starting their own business in The Netherlands.


We all want to work with GREAT people.
I mean, really…who wants to surround themselves with anything less?
The truth is, your prospective interns are competing against each other to get a position within your company, but keep in mind, you too are competing against hundreds (if not thousands) of other companies to get the top picks in your city, both inside and outside the events industry.
How do you make sure that you get the best applicants competing for a place at your firm? Click below and learn our top 4 tips to attracting superhero candidates to your internship program.


Are you making a plan to travel Uttarakhand or any other desired destination in Uttarakhand like Nainital, Bhimtal, Ramnagar, Delhi, etc . For such journey car rental plays the major role in traveling sources. They provide rental services along with online booking of cabs and taxis. You can easily book a cab whether looking for local visit or outstation visit. But, the main thought that must be kept in mind is the steps of hiring a cab from car rentals on affordable price and best deals. Here we are providing the important facts to be kept in mind while booking a taxi or a cab.
The foremost thing one must kept in mind is the number of persons who are traveling with you. It can create a barrier in your enjoyment as if you are choosing a cab for less space and having more than members then you have to face many difficulties and increase your stress and problems.
When you confirmed about the number of members and the best car rental company according to your choice and next step is to confirmation of the extra charges as most of the time some extra charges increase your expenses and leads to spoil your enjoyment. Therefore make sure and aware about the extra charges like service tax, parking charges, toll charges and various other charges.
The next step is to get familiar with the drivers and the cabs, you must have details about the driver to make your journey much secure and satisfied. You can confirm about the car type as per your choice and also about the drivers for his behavior, experience and his knowledge about the destinations. If you are aware about these things then you will feel safe secure stress free and enjoyable experience of journey.
The last thing is to know about the terms and conditions of the car rental company if any. You can ask about the services like extra hours, extra kilometer and any other terms and conditions about the service provided during travel. Also be sure about the policies of company and facilities provided if any accident occur during the trip.These are the procedure followed while choosing the car rental company for hiring taxi or cabs.


text:
Meal Pickup Prior to Mid-Winter Recess
SANY in collaboration with Chartwells has developed a [contactless drive through] meal service that will allow students greater access to food while at home.
Please see below for pickup times and locations prior to Mid-Winter Recess.
Any questions about pick ups, please email This email address is being protected from spambots. You need JavaScript enabled to view it.
All children 18 or younger are eligible to participate.
Children do not need to be enrolled in SANY Schools to participate.
Pick-up Locations and times:
There will be no meal pick up during mid-winter recess!
On 2/9 meal pickup will be available at all schools and participants will receive three days worth of meals.
On 2/11 meal pickup will ONLY be available at UAS Middle School. Participants will receive SEVEN days of meals to cover the entire winter recess.
Please sign up in advance by emailing your school pick up location and number of children you are picking up meals for to: This email address is being protected from spambots. You need JavaScript enabled to view it.
UAS Elementary/High: 2/9/2021 9am-11 am
UAS Middle School: 2/9/2021 and 2/11/2021 10am–12pm
Meals are free for all children up to 18 years old.
➡Remote Learning will continue in Middle School until Friday, February 5th, 2021
Dear Utica Academy of Science Middle School parents and guardians,
We are writing to share an important announcement, our middle school will continue remote learning until Friday, February 5th, 2021. We are planning to resume in-person instruction on Monday, February 8th, 2021.
If you have any questions or concerns, please reach out to the middle school administration.
Utica Academy of Science Middle School Administration
➡Hybrid Learning will resume in Elementary School on Monday, February 1st, 2021
Dear Utica Academy of Science Elementary School parents and guardians,
We are writing to share an important announcement, our elementary school will resume hybrid learning on Monday, February 1st, 2021.
Governor Andrew Cuomo lifted the yellow zone in Oneida County on Wednesday, January 27th, 2021. Cuomo is leaving five yellow zones in place. Four are in New York City and one is in Newburgh. The other zones are being lifted because the situation has improved, Cuomo said.
We ask that all families who were previously assigned to hybrid learning to send their student(s) completed a health screening survey at https://www.uascs.org/healthscreening prior to sending the student(s) to schools. In addition, we ask that everyone follow safety guidelines to ensure our staff, students, and families well being.
Utica Academy of Science Elementary School Administration
➡ Remote Learning until Friday, January 29th, 2021
Dear Utica Academy of Science parents and guardians,
As a district, we have closely monitored the percentage of COVID-19 cases in our geographic area. It is clear that the number of COVID-19 cases are still on the rise.
Due to the increase of COVID-19 cases in our area, we will temporarily suspend in-person instruction and continue to hold remote learning. At this time, we will continue teaching all students remotely through Friday, January 29th, 2021.
This decision was made as a safety precaution and is to ensure the wellbeing of our students and families during this difficult time. We are planning to resume in-person instruction on Monday, February 1st, 2021 as we continue to monitor the progression, and number of COVID-19 cases in our area.
Meal pickup this week will be on Tuesday, January 26th and Thursday, January 28th at the Utica Academy of Science middle school from 10AM-12PM.
Please take this notice and our actions as a representation that we prioritize the health and safety of students, staff, and all members of our community to the fullest extent.
Utica Academy of Science Administration
Remote Learning until January 22nd, 2021
Due to the increase of COVID-19 cases in our area, we will temporarily suspend in-person instruction and continue to hold remote learning. At this time, we will continue teaching all students remotely through Friday, January 22nd, 2021.
This decision was made as a safety precaution and is to ensure the wellbeing of our students and families during this difficult time. We are planning to resume in-person instruction on Monday, January 25th, 2021 as we continue to monitor the progression, and number of COVID-19 cases in our area.
Meal pickup this week will be on Tuesday, January 19th and Thursday, January 21st at the Utica Academy of Science middle school from 10AM-12PM.
Remote Learning until January 15th, 2021
With the holiday season ending and due to the increase of COVID-19 cases in our area, we will temporarily suspend in-person instruction and continue to hold remote learning. At this time, we will continue teaching all students remotely through Friday, January 15, 2021.
This decision was made as a safety precaution and is to ensure the wellbeing of our students and families during this difficult time. We are planning to resume in-person instruction on Tuesday, January 19, 2021 as we continue to monitor the progression, and number of COVID-19 cases in our area.
Remote Meals Pick Up Announcement
Please see below for pickup times and locations for 12/14/2020-1/7/2021.
Registration and Pickup
Pre-ordering is not necessary but is helpful to ensure enough meals are ready! If the hours listed are not convenient for you, please call the school's main office to arrange alternate pickup times between 8am-4pm.
Tuesdays and Thursdays
UAS Middle School – 12/15, 12/17, 12/22, 12/29, 1/5, 1/7
Meal pickups on 12/22 and 12/29 will be a box of food with 5 days worth of food.
Remote Learning will continue until January 8th, 2021
Dear Utica Academy parent(s) and guardian(s),
As a district, we closely monitor the percentage of COVID-19 cases in our geographic area. Currently, the 7-day rolling average infection rate is 8.5%. The 14-day rolling average is 6.9%. It is clear that the number of COVID-19 cases continues to rise in Oneida County.
Due to the increase of COVID-19 cases in our area, we will continue to temporarily suspend in-person instruction. Utica Academy of Science Charter School will extend full-time online learning through January 8th, 2021.
All students will continue to meet daily with their classroom teachers for online instruction via Zoom and engage in online instruction through the school's platform. Winter Recess remains scheduled for December 23rd, 2020 to January 1st, 2021, during which time school is closed and classes will not be in session. Classroom teachers will communicate with families in order to arrange a time to pick up learning materials.
We made this decision as a safety precaution to ensure the wellbeing of our students and families during this difficult time. We plan to resume in-person instruction on Monday, January 11th, 2021 depending on updates from the Oneida County Health Department and regional development of COVID cases. Please see the calendar below for an updated tentative schedule.
Science Academies of New York Administration
Please see below for pickup times and locations for the week of December 7.
SAS High – 12/8 and 12/10
UAS Middle School – 12/8 and 12/10
Remote Learning before and after Thanksgiving Break
Dear SANY parent(s) and guardian(s),
As a district, we have closely monitored the percentage of COVID-19 cases in our geographic area. It is clear that the number of COVID-19 cases are on the rise.
Due to the increase of COVID-19 cases in our area, we will temporarily suspend in-person instruction and hold remote learning. At this time, hybrid instruction will continue through Friday, November 20th, 2020. We will begin teaching all students remotely Monday, November 23rd, 2020 and Tuesday, November 24th, 2020 before Thanksgiving break. We will continue to teach remotely the week after Thanksgiving Recess, starting from Monday, November 30th, 2020 through Friday, December 4th, 2020.
This decision was made as a safety precaution and is to ensure the wellbeing of our students and families during this difficult time. We are planning to resume in-person instruction on Monday, December 7th, 2020 as we continue to monitor the number of COVID-19 cases in our area.
Updated Calendar:
Thanksgiving Recess (No School)
Flu cases are being diagnosed across NY
Dear Parents and Guardians,
Influenza, or flu, cases are being diagnosed across New York state as flu season has officially started.
Flu spreads easily and can make people very sick, especially children. Flu symptoms include:
Runny or stuffy nose
Some people, especially children, may have stomach problems and diarrhea. Unlike a cold, the flu comes on very suddenly.
Flu symptoms are very similar to COVID-19 symptoms. It's important for families to know that the Science Academies of New York (SANY) is required to follow the guidance in the New York State Department of Health Pre-K to Grade 12 COVID-19 Toolkit when determining if a student can attend school and when staff can go to work.
Please refer to the toolkit for help in determining if your child can attend school, return to school after an illness and whether your child needs a COVID-19 test to return to school.
"There is a large overlap between flu and COVID-19 symptoms," said Diane Montgomery, a local physician who is supporting the district as its COVID-19 Medical Supervisor. "Our school nurses are required to follow the state Department of Health protocols, and families should know that a COVID-19 test may be required for their children to return to school after an illness or symptoms of an illness."
If your child does need a COVID-19 test, please check the New York State COVID-19 Testing website for testing information.
Fight Flu at Home and School (New York State Department of Health)
The Flu: A Guide for Parents (U.S. Centers for Disease Control and Prevention)
Everyday Preventive Actions Can Help Fight Germs, Like Flu (U.S. Centers for Disease Control and Prevention)
Similarities and Differences Between Flu and COVID-19
We are writing to share an important health announcement.
On Monday, October 12, 2020, the Oneida County Health Department notified us that one UAS elementary school student has tested positive for COVID. The last day that this student attended school was September 29. The student was put in quarantine due to possible exposure to COVID-19 by an individual in the community who does not attend UAS but had interaction with the child's family. The UAS student tested negative while in quarantine since September 29. However, the student was tested again last week and the result received on October 12 was positive.
According to the health department, since the student has already been out of school for more than two weeks, UAS does not need to take any action other than the regular COVID-19-related cleaning and disinfection performed daily.
We wish everyone to stay safe, healthy, and informed.
Elementary School Administration
Utica Academy of Science Charter School
Dear High School Parents and Guardians,
We are writing to you this afternoon in order to share an important announcement.
On Thursday, October 8, 2020, Oneida County Department of Health officials directed the school to temporarily halt all Utica Academy of Science High School athletic activities, including practices, games, and all in-person tutoring sessions for high school students until Tuesday, October 13, 2020, due to a student who tested positive for COVID-19. The student who tested positive was never in the school building, but was part of our soccer team. The high school has been following an online education model since the school started on September 8, 2020.
All team members and coaches have been placed in quarantine due to possible exposure to the virus until October 17, 2020, by the Oneida County Health Department.
School officials will update families via AP Notify and the school website if an extended halt is necessary. Tutoring and mentorship sessions will resume in person for high school students on Tuesday, October 13.
We have been working with Oneida County and Herkimer County Health Departments to take the steps necessary to ensure that the safety of our school community remains our first priority.
High School Administration
UASCS Fall Reopening Plan
Dear Science Academies of New York Community:
Thank you to our Reopen SANY Task Force, our administrative team, staff members, parents, and board members who contributed to our draft reopening plan for the 2020-2021 school year. A copy of the plan is available via the following link: http://reopening.sany.org Please be sure to review this draft plan.
Once you have read our reopening plan, please complete a survey for each student in your home indicating your preference for instruction this fall by Friday, August 14th. The link to the survey follows: https://sites.google.com/sany.org/reopening/select-your-model
In accordance with the Governor's directive, the district has created a draft of two different opening plans:
Full-time Online Education Model
Hybrid In-Person/Online Education Model
The district developed this reopening plan in accordance with guidance from the New York State Health Department and New York State Education Department. Our number one priority is the safety and security of our students and staff. We are fortunate to have small class sizes, large classrooms, and technology resources that are readily available so that students can benefit from instruction whether they are inside of our schools or learning from home.
All students in grades K-7 in Syracuse and grades K-8 in Utica will have both hybrid and full-time online education options. Parents need to take the survey to indicate their preference for either 1) Full-time Online Education Model or 2) Hybrid In-Person/Online Education Model.
Students in grades 8-12 in Syracuse and grades 9-12 in Utica will have only full-time online education opportunities.
SANY will offer to all ELL and Special Education students in grades K-12 to attend hybrid learning 4-days per week. We will periodically reassess the effectiveness of online instruction for all students in order to maximize learning. We may make adjustments to students' learning model (online or hybrid) by reassigning students to increase in-person learning opportunities based on their individual learning needs and CDC guidelines.
In order to encourage social distancing on school vehicles, we are asking families to consider transporting their own students to reduce capacity on school buses. If you are planning to send your child to school for hybrid in-person instruction, please be sure to review all of the safety precautions that you and your child will need to take, some of which include:
Completing a health screening each morning and not coming to school when you are sick. Please be aware that minor symptoms such as repeated coughing or sneezing, or a fever will result in children not being allowed to attend school.
Wearing a mask to prevent the spread of germs.
Practicing social distancing at all times (staying 6 feet away from others).
Washing your hands and practicing appropriate respiratory hygiene.
If you are indicating a preference for full-time online education for safety or other reasons, please also be aware of the following:
Attendance will be taken and your child will be expected to attend classes during normal school hours
Your child will be expected to follow the school schedule
Live interaction with teachers and assistance will occur during school hours
Again, please be sure to review the draft reopening plan prior to completing the survey. The draft plan has been submitted to the New York State Health Department and New York State Education Department. Governor Andrew Cuomo will make a determination during the first week of August regarding the ability of schools to reopen. Once the Governor has made a decision and the district has reviewed survey results from families, we will make a final decision regarding our ability to reopen and follow up with additional information. Please also be aware that as circumstances relative to infection rates and hospitalization rates change in our community throughout the year, we may need to adapt and adjust which may require a return to online education for all students.
This reopening will require some heavy lifting and we will need everyone to work together. I realize that parents, students, and staff members have questions, concerns, hopes, and fears relative to reopening schools during this challenging time. It is going to take everyone working together in a positive and cooperative manner to develop solutions that meet the needs of our students and staff.
Please be sure to read our draft plan, complete the survey by Friday, August 14th, and stay tuned in August for additional information. We believe that by each of us doing our part that we can reopen schools in a safe manner.
Dr. Tolga Hayali
Science Academies of New York
Family Survey: Reopening School
Thursday, July 16, 2020—The COVID-19 pandemic and the closing of school buildings resulted in significant changes to our traditional face-to-face model of instruction as we transitioned to distance learning. We recognize that these changes impacted our students, families, teachers, and staff in many different ways. As a result, Science Academies of New York has created a brief survey to gain feedback from our families regarding the fall and potential reopening of school buildings.
This survey is critical, and we value the feedback from all our community members. Please fill this out by Friday, July 24th.
Click Here to Submit Survey
Summer Chromebook Announcement
Friday, June 26, 2020—SANY Chromebooks were lent to families at the start of distance learning to ensure all students had access to a computer. In order to continue to serve our students over the summer months and ensure every family has access to technology, SANY will wait until Governor Cuomo announces that schools can reopen to coordinate the pick up of the SANY Chromebooks.
If you are not planning on returning to a SANY school in the fall, please reach out to This email address is being protected from spambots. You need JavaScript enabled to view it. to coordinate a time to drop-off your SANY Chromebook. We ask that all students treat their Chromebooks with respect, and ensure the device stays in proper working condition. Thank you, all, and have a great summer.
Last Day of School
Tuesday, June 9, 2020—SANY Families, Governor Cuomo announced that all summer school programs in New York State will be moved online. If your child is required to attend summer school, you will be notified directly. Additionally, all SANY schools will continue to follow their original calendar for the end of school. The last day of school for Utica Academy of Science students is Friday, June 26. We ask that all our SANY Atoms continue to follow social-distancing best practices. If you have any questions or concerns, you can reach out to your building dean.
Schools Closed for Remainder of Academic Year
Friday, May 1, 2020—Today, Governor Cuomo announced that all schools in New York State will be closed for the rest of the academic year. This decision was made to help slow the spread of the coronavirus pandemic in the state.
What this means for your Atom
We will continue to offer meals at our Grab & Go Meal Locations
We will continue to utilize our distance learning strategy to keep your scholar engaged with their academics during this uncertain time
In addition, due to the coronavirus pandemic, the New York State Board of Regents has canceled the August Regents. In the interim, we ask that all our SANY Atoms follow social-distancing best practices. If you have any questions or concerns, you can reach out to your building dean.
School Closure Extended to May 15
Thursday, April 16, 2020—Governor Cuomo has announced that NY Pause will remain in effect until May 15. The Science Academies of New York will remain closed until May 15, 2020. This includes all extra-curricular activities. Stay safe and healthy, Atoms.
State Announces Updated Graduation Guidelines
Thursday, April 9, 2020—The State Education Department announced the cancellation of the June 2020 administration of Regents Exams and released guidance on modifications to requirements for students to graduate and earn their high school diplomas, credentials, and endorsements.
Regents Exams and Diploma Requirements
The COVID-19 emergency has evolved rapidly, leading to uncertainty as to when regular in-school classroom instruction will be able to resume throughout the state and whether students will be adequately prepared to take the Regents examinations. As a result, the Board of Regents and Department have cancelled the June 2020 administration of the NYS High School Regents Examination Program.
Because of this, the Department has modified the requirements that students must meet in order to earn high school diplomas, credentials, and endorsements. These modifications apply to all students enrolled in grades 7-12 during the 2019-20 school year who were intending to participate in one or more of the June 2020 Regents Examinations.
Students who, during the June 2020 examination period would have taken one or more Regents examinations, will be exempted from passing the assessments in order to be issued a diploma. To qualify for the exemption, students must meet one of the following eligibility requirements:
The student is currently enrolled in a course of study culminating in a Regents examination and will have earned credit in such course of study by the end of the 2019-20 school year; or
The student is in grade 7, is enrolled in a course of study culminating in a Regents examination and will have passed such course of study by the end of the 2019-20 school year; or
The student is currently enrolled in a course of study culminating in a Regents examination and has failed to earn credit by the end of the school year. Such student returns for summer instruction to make up the failed course and earn the course credit and is subsequently granted diploma credit in August 2020; or
The student was previously enrolled in the course of study leading to an applicable Regents examination, has achieved course credit, and has not yet passed the associated Regents examination but intended to take the test in June 2020 to achieve a passing score.
New York State of Health Announcement
School Closure Extended to April 29
Important Update Regarding Extended School Closure
New York State Cancels Elementary & Intermediate State Assessments
Grab & Go Meals Distribution Location Update
SANY Action Plan for COVID-19 School Closure
Internet and Device Access Survey
Spectrum Offers Free High-Speed Internet
Important School Closure Message
False Claim COVID-19
Since this virus is very new, health authorities continue to carefully watch how this virus spreads. The Centers for Disease Control and Prevention (CDC) is working hard to learn as much as possible about this new virus, so that we can better understand how it spreads and causes illness. The CDC considers this virus to be a serious public health concern.
U.S. Centers for Disease Control and Prevention: Coronavirus Disease 2019 (COVID-19)
New York State Department of Health: Novel Coronavirus (COVID-19)
Oneida County Health Department: Coronavirus Disease 2019 (COVID-19)
Talking with children about Coronavirus Disease 2019 (CDC)
When and how to wash your hands (CDC)
COVID-19 Frequently Asked Questions and Answers (CDC)
In addition, New York state has established a Novel Coronavirus Hotline, which can provide additional information. Call 1-888-364-3065 with questions or concerns about travel and symptoms.
HANDS: Wash them often
ELBOW: Cough into it
FACE: Don't touch it
FEET: Stay more than 3ft apart
FEEL: sick? Stay home


text:
Names in the News: PTI's Tom Brady recognized by SPE blowmolding group
Thomas Brady, founder of Plastic Technologies Inc. (PTI; Holland, OH), was recently awarded the 2009 Lifetime Achievement Award by the Society of Plastic Engineers' (SPE) Blow Molding Division in recognition of achievements large and larger over the past decades.
PlasticsToday Staff | Oct 29, 2009
Brady's work at PTI may well have merited the recognition on its own. Formed in 1985, PTI has grown to be recognized as one of the plastics packaging industry's leading technical development services for companies interested in starting or expanding their use of polyethylene terephthalate (PET) packaging, especially blowmolded bottles. The companies he started employ 200 from locations in Holland and Bowling Green, OH, as well as Yverdon, Switzerland. A spin-off company has become one of the country's leaders in PET recycling.
Thomas Brady
Prior to founding PTI, Brady was vice president of plastics technology for Owen-Illinois, Inc. (O-I), where he led the development of the first PET soft drink containers. His team was critical in study of molecular orientation in PET during stretch blowmolding. The culmination of this pioneering work was the introduction of the first continuous rotary reheat stretch blowmolding machine in the U.S., which effectively cleared a path for PET to replace metal cans and glass jars and bottles.
"I thank SPE for this prestigious honor. I also would like to thank all of the employees at PTI who have made the company the plastics packaging thought leader it is today. My family also has played an important contribution. Their continued support throughout my career encouraged me to forge new paths," Brady said.
Phoenix Technologies was formed in 1992 and is now one of the largest global recyclers of PET for bottle and blowmolding applications.
Brady, who earned his Ph. D. in plastic materials engineering from the University of Michigan and his master's and bachelor's engineering science degrees from Dartmouth College, is now serving as interim dean of the University of Toledo's Judith Herb College of Education. —[email protected]


text:
You have searched for "hari raya open house"
Analysis 07 Jul 2019 | 12:00 AM
Video casts a shadow over Azmin
The beleaguered Datuk Seri Azmin Ali seems to have the support of the most influential man behind the Prime Minister but the burning question is why the police investigation into the sex video is taking so long.
Business 04 Jul 2019 | 12:00 AM
Nestle to absorb sugar tax
KUALA LUMPUR: Nestle (M) Bhd says most of its products will not be hit by the sugar tax imposed by the government effective July 1.
Tensions to rise between PM, Umno
HE had dropped off the radar screen the last six months but Datuk Seri Dr Ahmad Zahid Hamidi has returned with a bang.
Business 25 Jun 2019 | 6:32 AM
Guan Eng: 10% special penalty rate ending June 30
CYBERJAYA: The Finance Minister has reminded taxpayers who have any previously undeclared income to take advantage of the special reduced penalty rate of 10% before it ends on June 30.
Economy 28 Jun 2018 | 3:46 AM
Azmin Ali expects investor confidence to be restored
KUALA LUMPUR:? The government is optimistic that investors' confidence will be restored, thus putting a stop to the continuous foreign selling on Bursa Malaysia, Minister of Economic Affairs Datuk Seri Mohamed Azmin Ali said.
Property 21 Jul 2017 | 12:00 AM
Bina Darulaman unveils RM2.6bil township projects in Kedah
KUALA LUMPUR: Kedah-based developer Bina Darulaman Bhd (BDB) has launched two integrated township projects with a combined gross development value (GDV) estimated at RM2.6bil.
Property 20 Jul 2017 | 8:20 AM
Bina Darulaman launches RM2.6bil GDV worth of developments
KUALA LUMPUR: Two integrated township developments with a combined gross development value (GDV) estimated at RM2.6bil have been launched by Kedah-based developer Bina Darulaman Bhd (BDB).
Markets 19 Jul 2017 | 2:00 PM
Life insurance industry to chart high single-digit growth this year
KUALA LUMPUR: Malaysia's life insurance industry is poised to record high single-digit growth in terms of new business premiums in 2017, said the Life Insurance Association of Malaysia (LIAM).
Plantations 18 Jul 2017 | 12:00 AM
Lost revenue due to labour shortage
KUALA LUMPUR: The shortage of farm labour at Felda Global Ventures Holdings Bhd (FGV) is costing the oil palm planter millions of ringgit in lost revenue, contributing to its cash-flow problems.
Corporate News 17 Jul 2017 | 9:43 AM
Probe on FGV group CEO to be completed by Aug 14
KUALA LUMPUR: Newly appointed acting chairman of the Felda Global Ventures Holdings Bhd (FGV) Tan Sri Sulaiman Mahbob said the investigation on the group president and CEO Datuk Zakaria Arshad, who has been told to go on leave, is expected to be completed by Aug 14.


Mattresses are similar to a duvet cover since you will be paying for what you are getting most of the time and both comes in a lot of different varieties. And that is why it is important for you to consider looking for a bed with a good quality. There are now different types of beds available in the market and that is because of the great improvement of technology in the modern age of today. Your mother might have told you a lot of times to always stand up or sit straight and they were not telling you in order for you to only look good. A bad posture will only lead you to have a bad back and other chronic pains in the future, and these are a result of using a mattress that does not provide a good support on the arch of the back.
If you have an injury on your leg, neck, or back, then you should consider talking to a posturepedic dealer in order for you to get a mattress that will help you recover from your injury fast. In order to see if the mattress will meet your needs, you should consider trying out the samples from the posturepedic dealer that you will be in contact with. One more tip when it comes to the mattresses that you will be using is to have a rotations every now and then. The mattress will breather properly and it will be keeping its shape when you do this.
It is very important that your mattress should always have a protective underlay in order for it to be always clean but there are now famous underlays that are magnetic and are made of wool. You should also be aware of wooden underlays that would be adding insulation to the mattresses that you are using and will surely provide you with a more comfortable sleep. You will not longer have to use some heaters and hot water bottles during the winter since the insulation on your bed that is provided by the wooden underlay will provide a warm and comfortable feeling in your home even on the cold days. The magnetic blankets are the news addition to the types of underlays and it is now starting to gain a lot of interest from many people. Magnetism is believed to provide a lot of benefits on the body of a person and there are a lot of studies and researches that would back this up. The magnetic fields on these underlays will help a person improve his or her blood circulation and provide a relief to those who are having some injuries. Because of the good effects provided by these underlays to the body, it would be considered to be a great gift to old people in order for them to have a relief on some of the pains and aches on their body.


text:
Home Dr Hazel Wallace
Dr Hazel Wallace is the founder of The Food Medic, an NHS medical doctor, registered nutritionist (ANutR), and best-selling author.
Hazel started 'The Food Medic' blog in 2012, as a medical student, in a bid to bridge the gap between conventional medical advice and the latest thoughts and developments in nutrition and other areas of lifestyle. The blog has now extended to various other platforms and publications including social media, two books, The Food Medic and The Food Medic for life, and a podcast where she interviews leading experts on how we can live healthier lives. Dr. Hazel is also a qualified personal trainer and is passionate in the use of exercise as medicine, which was the topic of her TEDX talk.
Hazel is currently working as a COVID doctor during this pandemic, treating patients acutely unwell with COVID and seeing patients in follow-up clinic with Post COVID syndrome (aka. Long COVID).
Dr Hazel Wallace was last modified: February 23rd, 2021 by hazel


text:
Ramping up: Wystrach seeing an increase in hydrogen projects
With more than 30 years of experience in its field, Germany-based Wystrach has built a strong portfolio of projects and collaborations.
Earlier this year, the manufacturer of storage and transportation solutions for hydrogen and other gases announced it had been chosen by rail transport company Alstom to provide its tank systems for the world's first hydrogen-powered train, the Coradia iLint, marking a major milestone for both the companies and the hydrogen economy.
Wystrach's CEO Wolfgang Wolter highlighted to H2 View that usually projects much like the hydrogen train pose challenges with the availability of space in the tank systems, but the company prides itself in its flexible compatibility with technology, meaning it can integrate cylinders from any manufacturer and find the best solution for the available space.
For the project, Wystrach supplied two fuel tank compositions, each consisting of four modules plus a control system, which were specifically developed for installation on the roof of the trains.


Choosing a concept in a dwelling is extremely important along with there is certainly no misstep, this particular Big Lots Table Big Lots Dining Room Sets Heather Bates Design image are going to be amongst your best sources of ideas given it illustrates a lovely style and design. That concept exhibited by Big Lots Table Big Lots Dining Room Sets Heather Bates Design photograph can be a unique role brand. You can find a lot of creative ideas with Big Lots Table Big Lots Dining Room Sets Heather Bates Design snapshot to help decorate your existing residence. That appealing information on Big Lots Table Big Lots Dining Room Sets Heather Bates Design picture will bring an awfully pleased surroundings to your home. A fittings Big Lots Table Big Lots Dining Room Sets Heather Bates Design photo displays definitely will assist you in creating a home with a wonderful display. An elegant come to feel as well be radiated with a house influenced as a result of Big Lots Table Big Lots Dining Room Sets Heather Bates Design photo. The following marvelous Big Lots Table Big Lots Dining Room Sets Heather Bates Design graphic is mostly a snapshot with 800 x 610 from resolution whilst the size: 89 KB.
Fortunately you can actually download all the graphics around Big Lots Table image stock unhampered. For this Big Lots Table Big Lots Dining Room Sets Heather Bates Design photo, you may push this link to build the application. If perhaps you want by using Big Lots Table Big Lots Dining Room Sets Heather Bates Design photo as an element of your own posting upon your weblog, then you definitely will incorporate a link . This particular Big Lots Table Big Lots Dining Room Sets Heather Bates Design snapshot containing shared at October 7, 2017 at 6:20 am is just meant for very own employ, remember to do not apply it designed for store-bought motive. Until recently, Big Lots Table Big Lots Dining Room Sets Heather Bates Design graphic been noticed by way of 1 people. Please preserve studying Big Lots Table photograph collection and this kw with regard to a lot more suggestions.


Title: How Far Can a Radar See?
Concept: The further away a thunderstorm, the higher the beam scans through the cloud.
Detail: The answer to this question is somewhat arbitrary. It must be kept in mind that the radar beam gradually rises above the earth's surface as it moves further from its source. Typically, the center of the beam at 100 miles is about 10,000 or 12,000 feet. By the time the beam is 250 miles from the radar, however, the center is above 40,000 feet. Thus, a thunderstorm with a top of 35,000 feet would be intersected by the beam at 120 miles but would be below the beam at the 250 mile range marker. Since much precipitation (especially during the wintertime), originates at heights below 15,000 feet, the radar beam is simply too high to detect precipitation at distances much greater than 125 to 150 miles. Thus, the somewhat generalized rule that the useful service range of most radars for day to day operations is about 125-150 miles.


LESLIE: Stuart in Georgia wants to know how to seal cracks and repaint stucco home. How can we help you today?
STUART: Hey. Well, I was calling to ask you about, though – I've got the stucco house.
STUART: One of a kind here in East Atlanta, (inaudible at 0:02:15).
STUART: But I'm noticing the small cracks and (inaudible at 0:02:21), nothing really serious. And it's specifically in the paint.
And so we had it painted. About six years ago, they pressure-washed it. Did a really nice prime coat and then two top coats. It's about time to repaint it, I think, so question is: is about six years right on repainting? So the – every six years or is there a better strategy so it'd be more complete and protect my stucco?
TOM: It feels a little light. Six years for an outside paint job seems like it – I'd rather see you try to get eight to ten years out of it. But if it needs paint, it needs paint.
Now, in terms of the cracks, is the stucco cracking or is it just the paint that's cracking?
STUART: Oh, yeah, they're small, very small. In width, in terms of width, like 1/8-, 1/16-inch.
TOM: OK. So you can use a crack sealant. And QUIKRETE makes one that's designed for stucco repair, that has kind of like a sanded sort of feel to it.
TOM: And it blends in with the stucco and it's paintable; it's an acrylic formula.
TOM: So get some of the QUIKRETE Stucco Repair. It looks like caulk; it comes in a caulk-like tube. Designed specifically for stucco repair, though, because then you get that sanded formula and it'll, texture-wise, kind of fit in with the rest of the stucco.
But make sure you seal up all those cracks before you repaint stucco home because otherwise, if you get water in there, then it expands and causes additional havoc. So just make sure you seal them up first and then repaint the place.
STUART: Alright. Well, thanks a whole lot. I appreciate your help.
TOM: You're welcome, Stuart. Thanks so much for calling us at 888-MONEY-PIT.


text:
You are at:Home»Posts Tagged "Guam"
Browsing: Guam
Ex-airman loses UFC contract over past assault charges
By Oriana Pawlyk on	 March 24, 2014 Air Force, Sports, UCMJ, Uncategorized
If you're a mixed martial arts fan, you may have noticed that Will Chope, a former airman, was pulled from last night's UFC Fight Night 38 in Natal, Brazil. His UFC contract was also terminated. Chope (19-6 MMA, 0-1 UFC) was scheduled to fight Diego Brandao (18-9 MMA, 4-2 UFC) televised on Fox Sports 1 until allegations surfaced on Saturday that Chope was kicked out of the Air Force after assaulting his wife on more than one occasion, according to Bleacher Report. The Air Force court of appeals documents, obtained by Bleacher Report, detail the assault: "The appellant [Airman Basic…
AF reserve captain becomes part of the McCain family
By Oriana Pawlyk on	 June 5, 2013 Air Force Reserve
Sen. John McCain has a new daughter-in-law. And she's an Air Force reserve captain. People Magazine reports that the senator's son, Jack, married Renee Swift over the weekend in San Francisco. Swift, 29, met Lt. McCain, 27, in Guam, where he serves as a helicopter pilot in the Navy. According to Swift's LinkedIn, she is the chief financial officer in the 36th Medical Group at Andersen Air Force Base, Guam. All the McCain children were in attendance and former presidential candidate Mitt Romney also stopped by. The ceremony was held at San Francisco's Grace Cathedral, with a reception following at…


New York (ANI): Rap star Eminem's mother Debbie Nelson has rubbished her son"s claims in his songs that he had a very difficult childhood. She writes in her tell-all book 'My Son Marshall, My Son Eminem" that her son resorted to all that crap only to become famous as a rap star.
"After his first album, Infinite, flopped, he reinvented himself as white trailer trash with a crazy welfare mom. I was shocked when I first heard the lyrics... but he constantly reassured me it was all a big joke... I went along with it for Marshall's sake," the New York Post quotes her as writing in the book"s introduction.
She also says by way of the book that years of verbal and physical attacks by her son"s fans have now got her through pretending. "This book is my way of setting the record straight," she writes. The book also reveals that as a child, Eminem was a shy boy who was so jealous of his mother's new man that he would not let him sleep with her on their wedding night.
Written through ghost-scribe and top British author Annette Witheridge, the book further reveals that the singer beat his mother up on his 23rd birthday, and that he does not remember 1999 when he first married his childhood sweetheart Kim Mathers. However, despite all these sufferings, Nelson does not condemn her son. "My son never intended for me to become an object of hatred," she writes in the book. Representatives for Eminem were unavailable for comment.


The Sesame project aims to understand and model the impacts of flooding on the UK's small businesses and the knock-on effects on the wider economy – and to find ways of encouraging businesses to be better prepared in future.
Assessments of flooding impacts have traditionally focused on the direct, local impacts on people and assets. This part of the SESAME project will improve understanding of the economic impacts of floods on SMEs and the knock-on effects of these on the wider economy. Taken together, we term these the flood footprint – the total direct and indirect socio-economic impact of a flood on both the flooded area and wider economic and social systems. We have adapted the city-scale Adaptive Regional Input-Output (ARIO) model to measure the flood footprint for a flood in the Lower Don area of Sheffield and the macroeconomic costs and benefits of implementing adaptation measures. Preliminary estimates suggest that it would have taken at least 20 months for Sheffield's economy to fully recover from the 2007 flood, which had a flood footprint of £571m (6.8% of the city's Gross Value Added). Direct and indirect losses account for £295m and £276m respectively.


As a coach I am passionate about the human mind and its potential. Did you know we have up to 50,000 thoughts a day and approximately 70% are negative? Absolutely shocking!
Decluttering your home can have a positive impact on other areas of your life. So why not stop to reflect on your thoughts and declutter the beliefs that no longer serve you?
Need a helping hand to do this? Contact coach Karin (www.karinweiser.com) for support.