text:
using namespace angle;

namespace gl
{
void CaptureClearBufferfv_value(const State &glState,
                                bool isCallValid,
                                GLenum buffer,
                                GLint drawbuffer,
                                const GLfloat *value,
                                ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureClearBufferiv_value(const State &glState,
                                bool isCallValid,
                                GLenum buffer,
                                GLint drawbuffer,
                                const GLint *value,
                                ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureClearBufferuiv_value(const State &glState,
                                 bool isCallValid,
                                 GLenum buffer,
                                 GLint drawbuffer,
                                 const GLuint *value,
                                 ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureCompressedTexImage3D_data(const State &glState,
                                      bool isCallValid,
                                      TextureTarget targetPacked,
                                      GLint level,
                                      GLenum internalformat,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth,
                                      GLint border,
                                      GLsizei imageSize,
                                      const void *data,
                                      ParamCapture *paramCapture)
{
    if (glState.getTargetBuffer(gl::BufferBinding::PixelUnpack))
    {
        return;
    }

    if (!data)
    {
        return;
    }

    CaptureMemory(data, imageSize, paramCapture);
}

void CaptureCompressedTexSubImage3D_data(const State &glState,
                                         bool isCallValid,
                                         TextureTarget targetPacked,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth,
                                         GLenum format,
                                         GLsizei imageSize,
                                         const void *data,
                                         ParamCapture *paramCapture)
{
    CaptureCompressedTexImage3D_data(glState, isCallValid, targetPacked, level, 0, width, height,
                                     depth, 0, imageSize, data, paramCapture);
}

void CaptureDeleteQueries_idsPacked(const State &glState,
                                    bool isCallValid,
                                    GLsizei n,
                                    const QueryID *ids,
                                    ParamCapture *paramCapture)
{
    CaptureMemory(ids, sizeof(QueryID) * n, paramCapture);
}

void CaptureDeleteSamplers_samplersPacked(const State &glState,
                                          bool isCallValid,
                                          GLsizei count,
                                          const SamplerID *samplers,
                                          ParamCapture *paramCapture)
{
    CaptureMemory(samplers, sizeof(SamplerID) * count, paramCapture);
}

void CaptureDeleteTransformFeedbacks_idsPacked(const State &glState,
                                               bool isCallValid,
                                               GLsizei n,
                                               const TransformFeedbackID *ids,
                                               ParamCapture *paramCapture)
{
    CaptureMemory(ids, sizeof(TransformFeedbackID) * n, paramCapture);
}

void CaptureDeleteVertexArrays_arraysPacked(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            const VertexArrayID *arrays,
                                            ParamCapture *paramCapture)
{
    CaptureMemory(arrays, sizeof(VertexArrayID) * n, paramCapture);
}

void CaptureDrawBuffers_bufs(const State &glState,
                             bool isCallValid,
                             GLsizei n,
                             const GLenum *bufs,
                             ParamCapture *paramCapture)
{
    CaptureMemory(bufs, sizeof(GLenum) * n, paramCapture);
}

void CaptureDrawElementsInstanced_indices(const State &glState,
                                          bool isCallValid,
                                          PrimitiveMode modePacked,
                                          GLsizei count,
                                          DrawElementsType typePacked,
                                          const void *indices,
                                          GLsizei instancecount,
                                          ParamCapture *paramCapture)
{
    CaptureDrawElements_indices(glState, isCallValid, modePacked, count, typePacked, indices,
                                paramCapture);
}

void CaptureDrawRangeElements_indices(const State &glState,
                                      bool isCallValid,
                                      PrimitiveMode modePacked,
                                      GLuint start,
                                      GLuint end,
                                      GLsizei count,
                                      DrawElementsType typePacked,
                                      const void *indices,
                                      ParamCapture *paramCapture)
{
    CaptureDrawElements_indices(glState, isCallValid, modePacked, count, typePacked, indices,
                                paramCapture);
}

void CaptureGenQueries_idsPacked(const State &glState,
                                 bool isCallValid,
                                 GLsizei n,
                                 QueryID *ids,
                                 ParamCapture *paramCapture)
{
    CaptureGenHandles(n, ids, paramCapture);
}

void CaptureGenSamplers_samplersPacked(const State &glState,
                                       bool isCallValid,
                                       GLsizei count,
                                       SamplerID *samplers,
                                       ParamCapture *paramCapture)
{
    CaptureGenHandles(count, samplers, paramCapture);
}

void CaptureGenTransformFeedbacks_idsPacked(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            TransformFeedbackID *ids,
                                            ParamCapture *paramCapture)
{
    CaptureGenHandles(n, ids, paramCapture);
}

void CaptureGenVertexArrays_arraysPacked(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         VertexArrayID *arrays,
                                         ParamCapture *paramCapture)
{
    CaptureGenHandles(n, arrays, paramCapture);
}

void CaptureGetActiveUniformBlockName_length(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
                                             GLuint uniformBlockIndex,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLchar *uniformBlockName,
                                             ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState,
                                                       bool isCallValid,
                                                       ShaderProgramID program,
                                                       GLuint uniformBlockIndex,
                                                       GLsizei bufSize,
                                                       GLsizei *length,
                                                       GLchar *uniformBlockName,
                                                       ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetActiveUniformBlockiv_params(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID program,
                                           GLuint uniformBlockIndex,
                                           GLenum pname,
                                           GLint *params,
                                           ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetActiveUniformsiv_uniformIndices(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID program,
                                               GLsizei uniformCount,
                                               const GLuint *uniformIndices,
                                               GLenum pname,
                                               GLint *params,
                                               ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetActiveUniformsiv_params(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID program,
                                       GLsizei uniformCount,
                                       const GLuint *uniformIndices,
                                       GLenum pname,
                                       GLint *params,
                                       ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetBufferParameteri64v_params(const State &glState,
                                          bool isCallValid,
                                          BufferBinding targetPacked,
                                          GLenum pname,
                                          GLint64 *params,
                                          ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetBufferPointerv_params(const State &glState,
                                     bool isCallValid,
                                     BufferBinding targetPacked,
                                     GLenum pname,
                                     void **params,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetFragDataLocation_name(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID program,
                                     const GLchar *name,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetInteger64i_v_data(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLuint index,
                                 GLint64 *data,
                                 ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetInteger64v_data(const State &glState,
                               bool isCallValid,
                               GLenum pname,
                               GLint64 *data,
                               ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetIntegeri_v_data(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               GLuint index,
                               GLint *data,
                               ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetInternalformativ_params(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLenum internalformat,
                                       GLenum pname,
                                       GLsizei bufSize,
                                       GLint *params,
                                       ParamCapture *paramCapture)
{
    // From the OpenGL ES 3.0 spec:
    //
    // The information retrieved will be written to memory addressed by the pointer specified in
    // params.
    //
    // No more than bufSize integers will be written to this memory.
    //
    // If pname is GL_NUM_SAMPLE_COUNTS, the number of sample counts that would be returned by
    // querying GL_SAMPLES will be returned in params.
    //
    // If pname is GL_SAMPLES, the sample counts supported for internalformat and target are written
    // into params in descending numeric order. Only positive values are returned.
    //
    // Querying GL_SAMPLES with bufSize of one will return just the maximum supported number of
    // samples for this format.

    if (bufSize == 0)
        return;

    if (params)
    {
        // For GL_NUM_SAMPLE_COUNTS, only one value is returned
        // For GL_SAMPLES, two values will be returned, unless bufSize limits it to one
        uint32_t paramCount = (pname == GL_SAMPLES && bufSize > 1) ? 2 : 1;

        paramCapture->readBufferSizeBytes = sizeof(GLint) * paramCount;
    }
}

void CaptureGetProgramBinary_length(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID program,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLenum *binaryFormat,
                                    void *binary,
                                    ParamCapture *paramCapture)
{
    if (length)
    {
        paramCapture->readBufferSizeBytes = sizeof(GLsizei);
    }
}

void CaptureGetProgramBinary_binaryFormat(const State &glState,
                                          bool isCallValid,
                                          ShaderProgramID program,
                                          GLsizei bufSize,
                                          GLsizei *length,
                                          GLenum *binaryFormat,
                                          void *binary,
                                          ParamCapture *paramCapture)
{
    paramCapture->readBufferSizeBytes = sizeof(GLenum);
}

void CaptureGetProgramBinary_binary(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID program,
                                    GLsizei bufSize,
                                    GLsizei *length,
                                    GLenum *binaryFormat,
                                    void *binary,
                                    ParamCapture *paramCapture)
{
    // If we have length, then actual binarySize was written there
    // Otherwise, we don't know how many bytes were written
    if (!length)
    {
        UNIMPLEMENTED();
        return;
    }

    GLsizei binarySize = *length;
    if (binarySize > bufSize)
    {
        // This is a GL error, but clamp it anyway
        binarySize = bufSize;
    }

    paramCapture->readBufferSizeBytes = binarySize;
}

void CaptureGetQueryObjectuiv_params(const State &glState,
                                     bool isCallValid,
                                     QueryID id,
                                     GLenum pname,
                                     GLuint *params,
                                     ParamCapture *paramCapture)
{
    // This only returns one value
    paramCapture->readBufferSizeBytes = sizeof(GLint);
}

void CaptureGetQueryiv_params(const State &glState,
                              bool isCallValid,
                              QueryType targetPacked,
                              GLenum pname,
                              GLint *params,
                              ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetSamplerParameterfv_params(const State &glState,
                                         bool isCallValid,
                                         SamplerID sampler,
                                         GLenum pname,
                                         GLfloat *params,
                                         ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetSamplerParameteriv_params(const State &glState,
                                         bool isCallValid,
                                         SamplerID sampler,
                                         GLenum pname,
                                         GLint *params,
                                         ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetSynciv_length(const State &glState,
                             bool isCallValid,
                             GLsync sync,
                             GLenum pname,
                             GLsizei bufSize,
                             GLsizei *length,
                             GLint *values,
                             ParamCapture *paramCapture)
{
    if (length)
    {
        paramCapture->readBufferSizeBytes = sizeof(GLsizei);
    }
}

void CaptureGetSynciv_values(const State &glState,
                             bool isCallValid,
                             GLsync sync,
                             GLenum pname,
                             GLsizei bufSize,
                             GLsizei *length,
                             GLint *values,
                             ParamCapture *paramCapture)
{
    // Spec: On success, GetSynciv replaces up to bufSize integers in values with the corresponding
    // property values of the object being queried. The actual number of integers replaced is
    // returned in *length.If length is NULL, no length is returned.
    if (bufSize == 0)
        return;

    if (values)
    {
        paramCapture->readBufferSizeBytes = sizeof(GLint) * bufSize;
    }
}

void CaptureGetTransformFeedbackVarying_length(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID program,
                                               GLuint index,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLsizei *size,
                                               GLenum *type,
                                               GLchar *name,
                                               ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetTransformFeedbackVarying_size(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLsizei *size,
                                             GLenum *type,
                                             GLchar *name,
                                             ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetTransformFeedbackVarying_type(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLsizei *size,
                                             GLenum *type,
                                             GLchar *name,
                                             ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetTransformFeedbackVarying_name(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLsizei *size,
                                             GLenum *type,
                                             GLchar *name,
                                             ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetUniformBlockIndex_uniformBlockName(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID program,
                                                  const GLchar *uniformBlockName,
                                                  ParamCapture *paramCapture)
{
    CaptureString(uniformBlockName, paramCapture);
}

void CaptureGetUniformIndices_uniformNames(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID program,
                                           GLsizei uniformCount,
                                           const GLchar *const *uniformNames,
                                           GLuint *uniformIndices,
                                           ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetUniformIndices_uniformIndices(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID program,
                                             GLsizei uniformCount,
                                             const GLchar *const *uniformNames,
                                             GLuint *uniformIndices,
                                             ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetUniformuiv_params(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID program,
                                 UniformLocation location,
                                 GLuint *params,
                                 ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetVertexAttribIiv_params(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      GLenum pname,
                                      GLint *params,
                                      ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureGetVertexAttribIuiv_params(const State &glState,
                                       bool isCallValid,
                                       GLuint index,
                                       GLenum pname,
                                       GLuint *params,
                                       ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureInvalidateFramebuffer_attachments(const State &glState,
                                              bool isCallValid,
                                              GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum *attachments,
                                              ParamCapture *paramCapture)
{
    CaptureMemory(attachments, sizeof(GLenum) * numAttachments, paramCapture);
    paramCapture->value.voidConstPointerVal = paramCapture->data[0].data();
}

void CaptureInvalidateSubFramebuffer_attachments(const State &glState,
                                                 bool isCallValid,
                                                 GLenum target,
                                                 GLsizei numAttachments,
                                                 const GLenum *attachments,
                                                 GLint x,
                                                 GLint y,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureProgramBinary_binary(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID program,
                                 GLenum binaryFormat,
                                 const void *binary,
                                 GLsizei length,
                                 ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureSamplerParameterfv_param(const State &glState,
                                     bool isCallValid,
                                     SamplerID sampler,
                                     GLenum pname,
                                     const GLfloat *param,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureSamplerParameteriv_param(const State &glState,
                                     bool isCallValid,
                                     SamplerID sampler,
                                     GLenum pname,
                                     const GLint *param,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureTexImage3D_pixels(const State &glState,
                              bool isCallValid,
                              TextureTarget targetPacked,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLsizei height,
                              GLsizei depth,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels,
                              ParamCapture *paramCapture)
{
    if (glState.getTargetBuffer(gl::BufferBinding::PixelUnpack))
    {
        return;
    }

    if (!pixels)
    {
        return;
    }

    const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(format, type);
    const gl::PixelUnpackState &unpack           = glState.getUnpackState();

    const Extents size(width, height, depth);

    GLuint endByte = 0;
    bool unpackSize =
        internalFormatInfo.computePackUnpackEndByte(type, size, unpack, true, &endByte);
    ASSERT(unpackSize);

    CaptureMemory(pixels, static_cast<size_t>(endByte), paramCapture);
}

void CaptureTexSubImage3D_pixels(const State &glState,
                                 bool isCallValid,
                                 TextureTarget targetPacked,
                                 GLint level,
                                 GLint xoffset,
                                 GLint yoffset,
                                 GLint zoffset,
                                 GLsizei width,
                                 GLsizei height,
                                 GLsizei depth,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels,
                                 ParamCapture *paramCapture)
{
    CaptureTexImage3D_pixels(glState, isCallValid, targetPacked, level, 0, width, height, depth, 0,
                             format, type, pixels, paramCapture);
}

void CaptureTransformFeedbackVaryings_varyings(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID program,
                                               GLsizei count,
                                               const GLchar *const *varyings,
                                               GLenum bufferMode,
                                               ParamCapture *paramCapture)
{
    for (GLsizei index = 0; index < count; ++index)
    {
        CaptureString(varyings[index], paramCapture);
    }
}

void CaptureUniform1uiv_value(const State &glState,
                              bool isCallValid,
                              UniformLocation location,
                              GLsizei count,
                              const GLuint *value,
                              ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniform2uiv_value(const State &glState,
                              bool isCallValid,
                              UniformLocation location,
                              GLsizei count,
                              const GLuint *value,
                              ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniform3uiv_value(const State &glState,
                              bool isCallValid,
                              UniformLocation location,
                              GLsizei count,
                              const GLuint *value,
                              ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniform4uiv_value(const State &glState,
                              bool isCallValid,
                              UniformLocation location,
                              GLsizei count,
                              const GLuint *value,
                              ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniformMatrix2x3fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniformMatrix2x4fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniformMatrix3x2fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniformMatrix3x4fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniformMatrix4x2fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureUniformMatrix4x3fv_value(const State &glState,
                                     bool isCallValid,
                                     UniformLocation location,
                                     GLsizei count,
                                     GLboolean transpose,
                                     const GLfloat *value,
                                     ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureVertexAttribI4iv_v(const State &glState,
                               bool isCallValid,
                               GLuint index,
                               const GLint *v,
                               ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureVertexAttribI4uiv_v(const State &glState,
                                bool isCallValid,
                                GLuint index,
                                const GLuint *v,
                                ParamCapture *paramCapture)
{
    UNIMPLEMENTED();
}

void CaptureVertexAttribIPointer_pointer(const State &glState,
                                         bool isCallValid,
                                         GLuint index,
                                         GLint size,
                                         VertexAttribType typePacked,
                                         GLsizei stride,
                                         const void *pointer,
                                         ParamCapture *paramCapture)
{
    CaptureVertexAttribPointer_pointer(glState, isCallValid, index, size, typePacked, false, stride,
                                       pointer, paramCapture);
}

}  // namespace gl


Hyderabad, March 18: Jawaharlal Nehru Technological University, Kakinada announced B.Tech and B.Pharmacy first semester examination results, which were held in the month of January. The results were available on the JNTUK official website.
According to University, the last date for recounting or revaluation or Challenge the results is 5th April 2011.


This lovely square personalised apple crate is perfect for holding a small Christmas tree and is a great alternative to the traditional stand.
Whether it's a family gift, for your own tree at home or in the office, our personalised Christmas tree planter crate is a great way to present your Christmas tree. You can even add wheels to make it easier to move your tree around.
Plantabox makes the highest quality personalised crates available anywhere in the UK. We offer the greatest product range and the fastest delivery.
Choose from a range of eight crate colours, and personalise with two lines of 18 characters on one side.
Made of sustainable FSC pine, professionally treated and coloured.


Our Philosophy: Providing inventors the opportunity to protect their inventions with a quality patent application drafted by a registered patent attorney at a reasonable cost. More.
Keep that 'next BIG idea,' safe.
Our proprietary process will guide you through the steps of patenting your invention. Plus, no fees are required to receive a quote for the preparation of your patent application, so let's get started!
ThePatentOffice.com is not affiliated with the United States Patent and Trademark Office or any other government entity. ThePatentOffice.com is a website owned and operated by Italia IP, Inc., a professional law corporation. Italia IP, Inc. is owned by James A. Italia, a registered patent attorney with more than 10 years of experience. The purpose of ThePatentOffice.com website is to educate visitors about patent law and provide a legal services platform for clients and prospective clients of Italia IP, Inc.
We will conduct a Patent Search to determine if your invention is "new" and help you determine the right patent application for you, whether that's a Design Patent Application, Provisional Utility Patent Application, or Non-Provisional Utility Patent Application. We will then prepare a professionally drafted patent application and drawings, and file the patent application with the United States Patent Office, which gets you "Patent Pending". The information on this website is for general information purposes only. Nothing on this site should be taken as legal advice for any individual case or situation. This information is not intended to create, and receipt or viewing does not constitute, an attorney-client relationship.


The meeting considered how stability data is produced and what data is currently available across UK labs. The meeting was organised via the Standing Committee of Analysts (SCA) with the intention that UK data is collated into a new Bluebook that can not only be used as a new national reference but also be taken forward to help improve the integrity of the data within the International standard ISO 5667-3.
The majority of water laboratories sent a representative and the meeting was positive with all being willing to participate in collating data. The next step is to produce a reporting template to capture all of the existing sample stability data across laboratories and to assess any significant differences. A second meeting is planned for September 2016.


text:
WANDERING IN A RUNNING WORLD
~ Toni Reavis ~
BISIA & ISHAM: The Countess & The P.O.W.
October 20, 2016 October 24, 2016 by Toni Reavis
A TIME FOR HEROES
The marathon is an event designed for heroes, as the long grind strips away all our defenses, leaving only the nub of a person by its end. It's why feelings are so raw, because the carefully constructed artifice that we've erected, that we've come to believe is the real us, like a chrysalis, has been shed, even as a glistening new me emerges in the bonhomie of the chutes.
That stripping away and revelation is part of what attracts people to the event. And for those who watch the final stretch from the sidelines, it isn't the pain that inspires, it's the feelings they see on display, those looks of inner satisfaction that transcend place and time, looks that plant the seeds for their own subsequent entry.
The long internal battle from first training days to final exultant step is also why grace and humility seem like an integral part of every marathon champion. It is also why every competitor, regardless of their time, can relive their journey with any other finisher with appreciation and empathy.
These qualities of persistence, humility, and empathy are ones we would like to see in our leaders, as well. And perhaps it's why the American electoral process has evolved as it has. No six-week Westminster style parliamentary sprint for us like our British cousins. Instead, through the long grinding process of an American political campaign we become witness to the stripping down of the candidates' facades, until the real person is revealed.
That is when a decision feels right, when we are given a chance to see beyond the image, beyond the handlers and ad men. What's left is raw, it's real, and we can believe it.
Sometimes, though, you actually hope for a little ambiguity so both sides can feel some common, if not ground, then affinity. Because, just like in a marathon, it is through affinity that the sides can be drawn together in the aftermath, which, after all, was the goal of the founders.
But after the third and final presidential debate of the 2016 campaign it doesn't seem headed in that direction at all. Rancor remains hard and brittle with less than three weeks left till Election Day.
People take cues from their leaders, as leaders are the ones who can ostensibly see farther ahead, and thus can plot a course that steers us all to a safer destination.
So it is as simple as this, if we allow the current political rancor to split us too widely apart, it will only leave us more vulnerable to outside forces. The vitriol and intransigence we saw displayed in Las Vegas is way more than unseemly at this point, it is dangerous. Not only could it foment internal strife – and we have already heard stirrings of that – but it could invite even more outside ambition.
The happiest politician after the third debate must have been Vladimir Putin. Russia's unwelcomed hand can already be seen all over the electoral process with the hacked document dump coming from WikiLeaks. So no matter which of the two party candidates now wins, Putin is already a joint victor, for his seeds of uncertainty and doubt in the integrity of the process have been sown.
So this come-together call is nothing more than a reminder that, personal ambition aside, Stronger Together is much more than the campaign slogan of one of this year's candidates. But in order to be strong we have to be unified across some formulation of E Pluribus Unum. That's what de Tocqueville saw that made America great. That's what will keep America great.
So let's recognize that we are all members of a flawed species, not a flawed people. We can't be blamed for our nature, but we can be blamed for turning on one another by giving into these all-too-human tendencies to succumb to our baser instincts.
Instead, like athletes in training, we must acknowledge our shortcomings, work on strengthening our deficits, even as we understand that our tendency is to give in when times get tough.
What we are left with, then, is the understanding that political campaigns, like marathons, bring emotions to the surface where feelings can be rubbed raw. And humans, after all, are God's creatures. But please note the possessive. Not by our choice are we this way. No, this was gifted us, and while there are many gifts, so, too, are there many sins. And so we try to see it from that vantage point.
The child's eye, a mother's touch, the safe harbor of love that develops in the womb then breathes softly from above as we suckle for nourishment, these are only the first of many false promises that life presents. For how quickly do such comforts give way to the waves of cruel injustice that break upon our waking days?
Grace under pressure, wasn't that what Hemingway called courage? The final stretch of this marathon is upon us. What will history have to say of our response?
Posted in Opinion, PoliticsTagged Alexis de Tocqueville, Ernest Hemingway, Marathon, Mel Fechter, presidential debate, Vladimir Putin, WikiLeaks
Previous WALLS OF INTOLERANCE, BRIDGES WITHOUT SPANS
Next CUBS WIN!!!
HELP KEEP INDEPENDENT THOUGHT FLOWING
Follow WANDERING IN A RUNNING WORLD on WordPress.com
ADDING UP BOSTON 2023
DAMAR HAMLIN EMERGES WHOLE, HOW ABOUT US?
2022 MARATHON YEAR
BOOK INTERVIEW ON ST. LOUIS RADIO
Bring Back the Mile
Entoto Foundation
Flotrack
MarathonGuide.com
Olympic Road Race Petition
RunBlogRun
RunnerSpace
Running Times
Running USA
Track & Field News
TReavis Fitness (Team Toya)
rTechnews
Specks In a Jaundiced Eye
Latest Gadget News and Articles
Politics, Media, Culture

redpajama_set_name: RedPajamaCommonCrawl


text:
Explore Norfolk
Royal Norfolk Coast
East Norfolk Coast
Countryside and Villages
Norwich City Breaks
Holkham Lodges
Coastal gems
Big gatherings
Cottages together
Flexilet
Small group discount
Area visitor guides
What's on in Norfolk
Norfolk on film
Star grading scheme
Getting to Norfolk
Norfolk Cottages blog
July's hidden gem - Reepham
Published: Thursday 26th Jul 2018
Written by: Georgia Dawson
Our hidden gem for July is Reepham.
Just 14 miles from Norwich and 17 miles from the coast, the wonderful market town of Reepham is nestled within the gorgeous Norfolk countryside. Perfect for walking and cycling, Reepham is a designated conservation area. Reepham is ideally located for exploring the beautiful Norfolk countryside and the breath-taking Norfolk coast, with both within a short drive.
Birthplace of Norfolk Cottages, Reepham has been a market town since 1277 when Sir John de Vaux obtained a charter from King Edward I. Today, Reepham market is a conservation area and holds a country market every Wednesday morning, as well as regular antiques fairs. Beautiful 18th Century buildings border the market and line the streets of the town. Reepham is surrounded by gorgeous countryside and the town is home to cute shops, a 16th Century pub and delicious places to eat.
Situated just behind the Reepham market place stand three churches who share one churchyard. The three sisters in the town sign allegedly represent the ladies who built the churches. The three churches of Reepham are St Mary's, which is still used for worship on a regular basis, St Michael's, Whitwell, which is currently used as a community hall and also for worship, and the remains of All Saints, Hackford. All Saints, Hackford was burnt down on 18th April 1543 in the great fire of Reepham. It is thought to have been an accident, however at the time of the fire the Church of England was breaking away from the Roman Catholic Church.
Reepham lies between section 3 and 4 of the Marriott's Way trail. Marriott's Way is a 26 mile footpath and cycle path which follows the beautiful route of two retired train lines. The path runs between the market town of Aylsham and the city of Norwich.
Section 3 of Marriott's Way guides you around Whitwell, Reepham and The Themelthorpe Loop. This walk is 5.5 miles around the loop, however can shortened by taking the Reepham Link Path which takes you through the market town. This route is 1.5 miles. This section is the muddiest of the Marriott's Way, taking you through gorgeous open farmland, rich in plants and wildlife. Places of interest on this section of the journey is the old Reepham Station, which is now a café, and the Whitwell Station, which is a station museum.
Section 4 takes you from Reepham to Aylsham. The path follows the old Great Eastern line, which ran from Wroxham to near Dereham, passing through Reepham and Aylsham. The train line closed to passengers in 1952. With vast fields and open skies, Section 4 of Marriott's Way is a wonderful route to take on a summer's afternoon..
Reepham properties
Sleeping three, this comfortable, cosy cottage is situated in the heart of Reepham, nestled just behind the old churches of Reepham market square. 3 Church Street is a well-equipped bolt hole, perfect for exploring the countryside.
View property here.
Old Oaks Cottage
Old Oaks Cottage is a beautifully renovated Victorian farm cottage, sleeping three. With daily access to the owner's outdoor heated pool and hot tub, this holiday home offers an elegant retreat from a busy world.
Eades Mill
This unusual 200-year-old rustic mill is located directly over the mill stream and boasts beautiful views over the surrounding Reepham countryside. Sleeping eight, this holiday home is perfect for a large family or group of friends.
Georgia Dawson
https://www.facebook.com/sharer/sharer.php?u=http://www.norfolkcottages.co.uk/blog/2018/07/julys-hidden-gem-reepham
https://twitter.com/intent/tweet?url=http://www.norfolkcottages.co.uk/blog/2018/07/julys-hidden-gem-reepham&text=July's hidden gem - Reepham
https://www.linkedin.com/shareArticle?mini=true&url=http://www.norfolkcottages.co.uk/blog/2018/07/julys-hidden-gem-reepham&title=July's hidden gem - Reepham
http://pinterest.com/pin/create/button/?url=http://www.norfolkcottages.co.uk/blog/2018/07/julys-hidden-gem-reepham
whatsapp://send?text=http://www.norfolkcottages.co.uk/blog/2018/07/julys-hidden-gem-reepham
fb-messenger://share/?link=http://www.norfolkcottages.co.uk/blog/2018/07/julys-hidden-gem-reepham
Return to blog article index
https://www.facebook.com/NorfolkCottagesUK
https://twitter.com/NorfolkCottage
https://www.instagram.com/norfolkcottages/
https://www.pinterest.co.uk/norfolkcottagesuk/
https://www.youtube.com/user/CottagesinNorfolk
© Norfolk Cottages
6 High Street, Holt, Norfolk, NR25 6BQ
Norfolk Cottages is a trading name of The Original Cottage Company Limited, which is a family-owned private limited company incorporated in England (registered number 06951692). Registered address at Bank House, Market Place, Reepham, Norwich, NR10 4JJ. VAT No. 595 2110 44.


2 École Supérieure des Mines de Saint-Étienne, Centre « Science des Matériaux et des Structures » UMR CNRS 5176 PECM, 158 cours Fauriel, 42023 Saint-Etienne cedex 2, France.
The objective of this study is to observe the thermoelastic coupling effect in a monocrystalline Cu-Al-Be shape-memory alloy. The orientation of the austenite crystal is measured by Microfocus X-ray texture analysis. Uniaxial cyclic loading is applied to the specimen at room temperature. Infrared thermography is used to capture temperature fields on the specimen surface. The approach consists in analysing the cyclic temperature oscillation of points located on the surface of the specimen. The study highlights first the significant difference between the thermoelastic couplings in austenite and martensite. Second the anisotropy of both phases, especially the martensite, is evidenced.


Are iTunes downloads actually "licenses" rather than "sales"?
I have been arguing this point for years as anyone taking one of my classes at Berklee can testify. This past week, rapper Eminem and his former production company F.B.T Productions won a significant digital royalties lawsuit granting the artist and production company a 50% split of revenue from digital downloads and ringtones. Universal Music Group will be required to pay a higher share of royalties for downloaded music or on ringtone sales according to a recent ruling by a federal appeals court.
This is a potentially HUGE change from how the recorded music industry's business model works. This new ruling may now mean that digital copies of music are digital "masters," which command a much higher royalty share than single or album "sales" do.
When consumers purchase a download from iTunes, they are actually "licensing" the song for playback within certain boundaries. According to many label contracts, licenses are to be treated as splits, perhaps split 50/50 between artist and label. To date, that has not been the case as downloads via iTunes and other sites have been treated as "sales" of copies of the song, rather than a license of the "master recording". Eminem and company challenged that assumption.
The labels have been accounting as if a download was the same as the sale of a single, using the existing contract language to define the payments.
Publishing and licensing may turn out to be of great benefit to artists and writers for digital music. If songwriters and artists band together, they can leverage the licensing provisions in their existing contracts to extract their fair share of digital revenue. New contracts and constructs can approach the transaction from a licensing point of view. Artists and writer have the upper hand when it comes to new music and new deals.
This ruling could truly be revolutionary for the creators of content if it holds up. Think of it this way. If an artist can directly license their music to iTunes and keep approximately 70% of the proceeds from each transaction, then why should they be paid 8-12% for music that their label licenses to iTunes? Shouldn't the money paid to the label at least be split 50/50? If this ruling stands up to appeal and becomes more broadly interpreted, artists and writers will benefit greatly, and deservedly.
http://newartistmodel.com/wp-content/uploads/2017/06/logo_transparent-copy.png 0 0 newartistmodel http://newartistmodel.com/wp-content/uploads/2017/06/logo_transparent-copy.png newartistmodel2010-09-07 10:02:302014-03-11 13:26:24Are iTunes downloads actually "licenses" rather than "sales"?
I don't believe this has anything to do with of a consumer's purchase of a copy of a digital file… this has to do with the licensing of rights by the record companies to iTunes.
If record company contracts with third party distributors rather than using their own distribution channels, most recording agreements state that the artist is entitled to 50% of the licensing fees received by the record company. That's because licensors assume the all of the distribution costs and responsibilities.
As far as songwriters and music publishers are concerned, there is really only one area where the traditional 50/50 split doesn't come into play and that's the area of printed music.
If a music publisher assumes the cost of printing and distributing music, the writer paid at the royalty rate specified in their songwriter agreement … If, as is the case with most print today, the publisher who has the agreement with the songwriter licenses another firm to handle print, the resulting royalty paid by the print distributor is split 50/50. That's because the royalty paid to the music publisher by the print publisher is very low due to the fact that the print publisher assumes all of the risks.
I will say this … if Eminem eventually prevails it will be the end of discovering an nurturing new talent by record companies and will throw the music scene into more disarray that P2P ever did.
This would not be a good thing for consumers and new artists alike.
You are correct that this is a licensing issue and not directly related to the consumer purchase. This has to do with how much the artist and writer receive vs the label on a download.
I don't agree that this would be the end of discovering and nurturing new talent entirely, but would change the balance of investment in artist development towards the artist and their manager, where it belongs. The labels have no loyalty to artists anymore and artists must find new means to finance their development, and recoup that investment.
I'm struggling here to see exactly what it is that the record label brings to the table. No need to manufacture and distribute vinyl records or CDs – hardly any record stores left anyway. Does Eminem need help with publicity?
You can create an album and upload it to CD Baby for $55 and it will be available on iTunes and Amazon. Artists need to band together into collectives – the workers now control the means of production AND distribution.
I don't agree that moving the cost of investing in artist development to the manager and artist is where it belongs – initially. The economics just don't work.
The reality is that 95%+ of all new releases will fail no matter how much money is invested in producing and promoting them. The public just can't absorb more new offerings than that at any one time.
If only one artist is being promoted by and individual or some sort of consortium… the odds of success are about equivalent to playing the lotto. That's an over exaggeration but not by much.
Record companies are successful for several reasons.
2. They play several hands at one time offering music they are fairly sure will be of interest to their target market (mass market outlets and consumers) knowing that no matter how accurately they have targeted their market, most of what they offer won't see the light of day – but knowing, too, that enough of it will stick to pay for those that don't thereby providing money for future investments … some of which will pay of big time and allow them to turn a profit.
3. They are plugged into every aspect of the mass market – sales, marketing, tour support, personal relationships – and everything else required to give their talent a real shot at breaking through the ever defining noise of everybody and his sister dumping every squeak and grunt they make into the internet musical cesspool.
4. Additionally, through developing it themselves and acquisitions, major labels have aggregated large amounts of hit product – providing a solid foundation for future speculation.
5. They have all the pieces needed to 'brand' and artist.
Of course, once an artist is "branded" the chances are much better that they can be successful without the support of an organized label.. especially with the technology available today … But the branding process costly, requires expertise and is crucial.
Sugar daddies and the uninformed have always wanted to 'be in showbiz' and are willing to pay for the opportunity – and there will always be a new crop of suckers coming along who will continue losing their investments by backing one offs. But savvy investors are going to find the odds against them too overwhelming to take a shot.
Record labels are evolving and will eventually hone their skills to deal with the new era … takes a long time to turn a battleship around … And remember, that while record labels haven't figured it out as of yet … neither has anyone else – We've heard a lot of rhetoric but have seen little, if any, real success — The only thing we've really learned is that the rhetoric that has been babbled for the last 10 – 15 years has been, for the most part, totally wrong.
CD Baby Hits $150 Million In Artist Payouts. Is That Good?
Here's another DIY fact, for what it's worth. According to details shared Monday morning, CD Baby has now paid $150 million to artists since its inception in the late 90s (through July, 2010). The figure includes both CDs and downloads, and CD Baby expects to pay roughly $40 million in payouts this year alone.
Sounds great, but what's the per-artist payout? In a conversation with Digital Music News, CD Baby CEO Tony Van Veen was unable to share the cumulative number of artists receiving payments since inception. But he could confirm a current artist population of 230,000. Judging by the expected artist payout of $40 million, each CD Baby artist will make an average of $174 this year.
That seems to reaffirm a brutal revision of the Long Tail, a part of the distribution curve CD Baby knows well. In fairness, a group of overachievers could be pulling decent payouts, though at present, figures on top earners are not available.
Thanks for the facts and figures – nice summary. I am in agreement that the independent artist is very unlikely to get rich from CD Baby. For those of us laboring in the outer darkness, however, we can put a collection together and have it in digital distribution for a modest amount – instead of waiting to be "discovered" by a record label.
Your summary of what a label can do is very comprehensive – and fine as far as it goes – but it still seems like the lottery. CDs cannot be realistically seen as a major revenue source except for the most popular of artists. And if you are popular, you no longer need a label to put your work out there.
Naxos says that a classical CD that sells 5000 copies is unusual, and they barely break even. I think the 21st century will allow emerging artists to stand on their own – or band together – to achieve what a label does now.
Everyone is entitled to their own opinion, and I wish you the best of luck with pursuing the major label model. Maybe you will figure something out that no one else has. It looks to me like they are all headed straight into the dust, and that without their publishing income, would already be gone.
I think your CD Baby analysis is misinformed. Averages tell you nothing. Indeed if you use the same logic to account for major label artists, you would come to the same conclusion – namely that the "average" artist gets a pittance from the label.
The truth is that only a handful of label artists ever made any real money, and the vast majority (95%) of artists signed, never recouped their advances. So in a way, there is really nothing new about CDBaby's model. A few make most all the money, and the rest make very little.
I think you are ignoring lots of new acts that are thriving without major label involvement or investment including Arcade Fire, Corey Smith, and Pomplamoose – all of which are described in the Berklee Blog network. Most of these musician businesses are succeeding because they are not just focused on recording revenue, but multiple income streams and vertically integrated marketing efforts. If you check out Mike King's blog in particular, you can learn about direct to fan marketing and building a successful career without major label support.
It can and is being done.
It's amazing to me, an independent musician and artist, that everyone talking and giving advice about the music industry is either not in the industry or has already made enough money to expiriment with different strategies.
Here's why this is a bad idea. Artists are seperate from songwriters. Even if they are on in the same. Under this provision the money coming in from digital sales gets split 50/50 between the owner of the master and the writer. This sounds great, but 95% of the music you hear is not written by the artist. This means that even less money would go to a majority of bands and artists. Sure this is great for eminem who writes his songs, but for the rest of the artists out there this would be a decision that undercuts the funding of all labels, not just major ones, including the label who signed the arcade fire. Without that money, the arcade fire and other bands like death cab, coldplay, Jimmy eat world, etc. would never be given a start. They didn't come from nothing.
iTunes should have to pay these artists their fair share of money. These artists sell a product, just like any other company. But they are being taken advantage of simply becuase their product is digital media. These people are treating the artists unjustly becuase their product can easily be put on-line and sold in seconds flat all around the nation, unlike canned food. They have the ability to just as easily write their own songs, form a band, and sell their own music. These companies are treating the situation with an idea that, even though it is somebody else's product they want to take more than their fair share of the profits, simply becuase it is easy to sell and distribute. Artists take huge losses of income in this digital age of piracy and this, however slow it may be, is an honest way for them to try and make a living. I guess you have to ask yourself, where the piracy is really taking place?
I'm not defending the record label model – If it's not dead, it is certainly on life support.
What I think has been taken away from artists, however, is the 'brass ring" – With no hope of walking away a huge winner, what is the incentive to strive for excellence?
When artists finally wake up and realize that the best they will ever be able to look forward to is a mediocre like – and that getting older and taking on the responsibilities of adulthood demands more than playing awful clubs, selling t-shirts, paying all the costs – up front – to play the game and spending your live trying to keep in touch with so called fans who, given today's propensity to view music as dispensable, don't really give a damn about you… where is the next generation of great talent going to come from?
For instance, why would anybody pay to go to an amazingly wonderful school like Berklee if their chances of making enough money in their lives to cover the loans they took out to go their are close to nil?
If Berklee is selling the dream of the possibility of great success as a result of the internet, then they are being disingenuous at best.
Not only are record companies on the way out so is the whole wonderful musical culture their capitalist ways helped create.
We had a wonderful run of the greatest popular music ever created from the mid twenties to the end of the century… and we had it because there was always hope that what one put into building their career would pay off … That's gone.
Artists reading this have got to realize … That's Gone!
You named a few acts that might be making good money as a result of a pure play on the internet … Given the fact that we are well over 5 years into a developed internet that could support pure plays… isn't that a horrible batting average?
In today's world you have a better chance of making a living flipping burgers than you do being a musician… and, heaven forbid that you are a stand alone songwriter because you've got no chance at all.
All I can say is this, when your parents tell you to get a real job rather than becoming a musician … heed their advice.
By William F. Aicher — There is a core group of people who will create and share their creations, regardless of any external motivation. There is also a never-ending flood of new people being added to the mix, simply by being born. But, as the individuals who create with the goal of being a professional wither and die amidst all the other noise, a demand for quality content will rise. The current phase of the Internet, especially in file trading, relies greatly on the creations of the past. The Beatles will never stop being enjoyed, but eventually a yearning for something new will rise—and if there is no motivation to create something new of quality, especially the kind of creation that only comes through the ability to focus on and be a professional creator, there will be nothing new to fill that void.
What I believe we have been dropped into, is primarily a time when we MUST shout out for and demand quality. The fact that the internet has allowed a generation of both disinterested and talentless people and visionary and future oriented mavericks to dismantle a fire breathing soul sucking empire like the music business of the latter twentieth century, is one that must be thought of indeed quite carefully. Does this mean it is harder to display quality work and get it appreciated by a warm, fresh, responsive audience. Yes. But it could be argued that this has always been the plight of the artist. This new system of formatting and delivery really comes down to presentation and work in the end. There will be the masses who accept poor quality work for massive amounts of collective cash spent, but this has always been the case. It is all relative. And as Nick stated, this is a unique time in which 'middle class' artists can enjoy the ability to share their craft and musings with the world. There will always be those who strive for more, those who are content with their form, and those who will blissfully undershoot the mark and yet pull out ahead. If we are discussing short term gain? Most brilliant artists of the Renaissance only came into full appreciation after their deaths; likewise, lasting art may be difficult (seemingly) to find whilst it is being created and distributed. However all of this supersaturation of the medium will lead to the same thing: artists that were lucrative if unimaginative, artists that were inventive if unknown, and artists that strove for quality and enjoyed enough success to fully 'stick'. It's all beautiful and constant, and will continue as long as we value making artistic works.


The above link will take you to our third podcast in the Keep It Simple: Being the Simple Church in a Complex World series. This podcast is put together by Gavin Duerson, from Lexington, Ky and myself (Tom LeCompte) from Louisville, Ky. We are both passionate about being the Simple Church. Today, Gavin and I discuss what worship looks like in a small community of believers meeting in homes, parks, and other "off campus" venues. We hope these podcasts are helpful and informative for you. God Bless!
Link | This entry was posted in Uncategorized and tagged Church, House Church, Organic Church, Podcast, Simple Church, Worship. Bookmark the permalink.


text:
Heart Disease and Secondhand Smoke, Anxiety
Contact: Amanda Jekowsky, ajekowsk@acc.org, 202-375-6645
In addition to alleviating emotional suffering, keeping one's anxiety in check may also be good for the heart. While doctors are well aware of the temporary effects anxiety can have on blood pressure, heart palpitations and chest pains, two new studies suggest that symptoms of anxiety may also increase a person's risk of developing heart disease decades into the future. Data from both studies are published in the June 29, 2010, special prevention and outcomes focus issue of the Journal of the American College of Cardiology.
Also reported in this issue are findings from a study that shows over a two-fold increased risk of cardiovascular death in people with high exposure to second hand smoke who have never smoked. This study, for the first time, also assesses the role markers of inflammation and hemostasis might play in mediating the association between second hand smoke and cardiovascular deaths.
Anxiety's Toxic Effects on Long-Term Heart Health
"The studies in this issue of the Journal suggest that, by the time patients with symptoms of coronary heart disease present themselves to a cardiologist, early life anxiety might have already taken its toll," states Joel Dimsdale, M.D., professor of psychiatry, University of California, San Diego, CA, and author of the accompanying editorial.
One of the studies—the first meta-analysis to examine the association of anxiety and subsequent development of heart disease among initially health people—found anxiety to be an independent risk factor for developing heart disease and related death. In fact, anxiety was associated with a 26 percent increased risk of coronary heart disease on average 11 years into the future. People who are anxious also had a 48 percent increased risk of heart-related death down the line. The association between anxiety and future cardiac risk remained significant even after adjusting for demographics and other traditional risk-promoting behaviors (e.g., smoking, sedentary behavior).
The analysis combined reports from 20 prospective studies reporting on incident cardiac events and included nearly 250,000 people. Compared to previous studies, authors noted that anxiety appears to be more strongly associated with developing heart disease than anger and hostility (19 percent increased risk), but somewhat less than depression (46 percent increased risk).
A second study confirmed the role of anxiety as a strong predictor of future cardiac events. This 37-year follow-up of approximately 50,000 young Swedish men, who were medically examined for military service and 18 to 20 years of age at the time, found that anxiety, but not depression, was a major risk factor for cardiac events later in life.
Anxiety disorders remained significantly predictive of subsequent heart disease even after controlling for baseline differences in blood pressure, smoking, and other potential risk factors for heart disease. Strengths of this study include diagnosis by a psychiatrist rather than through self-report, completeness of Swedish health registries, and studying a young population whose emotional symptoms are unlikely influenced by subclinical or clinical heart disease (called reverse causation). Major cardiovascular risk factors were recorded including smoking status, alcohol consumption, body mass index, family history of heart disease, diabetes, blood pressure and physical activity.
Findings from both studies reinforce the need to assess patients' emotional health in addition to asking about physical symptoms, especially as nearly three in 10 people will suffer from anxiety at some point in their lives. Dr. Dimsdale encourages cardiologists and others to take advantage of assessment tools like the Prime-MD, which include easy-to-ask questions such as "have you been bothered a lot by 'nerves' or feeling anxious or on edge?"
"Physicians are frequently timid about assessing emotional symptoms. It is odd that we thread catheters, ablate lesions, and give rectal exams but are uncomfortable asking our patients about their lives," he states.
Authors agree future research studies should investigate whether treating anxiety disorders through medications, psychotherapy, stress reduction andor lifestyle changes might have long-term heart benefits as well as reducing emotional suffering and improving quality of life. New studies should also examine the interplay of anxiety and other psychological factors (e.g., depression and anger), and uncover the mechanisms by which anxiety might affect the onset and progression of heart disease. "That emotional factors affect the heart is obvious. How they do so and how to mitigate these effects remains to be discovered," writes Dr. Dimsdale.
Exposure to Second Hand Smoke Spells Trouble for Heart, Inflammation Plays Role
People who have never smoked, but have high exposure to second hand smoke (SHS)—as determined by measuring salivary levels of cotinine (a reliable biochemical marker of nicotine exposure)—appear to have over a two-fold increased risk of cardiovascular death after adjusting for other risk factors, according to a new study.
This study—the first to assess the role of inflammatory and hemostatic markers in relation to SHS exposure—also showed that otherwise healthy people exposed to SHS had higher levels of low grade inflammation in their blood, which is thought to be involved with processes in the blood vessels that lead to heart disease. In particular, authors found that high SHS exposure was associated with elevated C-reactive protein (CRP), which explained nearly half (48 percent) of the association between smoke exposure and heart-related deaths.
Researchers collected cotinine from the saliva of 13,443 British adults. Of these, 20.8 percent had high SHS exposure, which was associated with all-cause and cardiac deaths during an average 8-year follow up. During this period, there were 1,221 all-cause deaths and 364 cardiovascular deaths. Compared to those with lower SHS exposure, both smokers and participants with high SHS were younger, more likely to be male, come from lower social status groups, and be less physically active.
Interestingly, there was no association between high SHS exposure and cardiovascular disease in former smokers. Cigarette smoking was related to elevated levels of fibrinogen, CRP and lower HDL cholesterol.
About the American College of Cardiology
The American College of Cardiology is leading the way to optimal cardiovascular care and disease prevention. The College is a 39,000-member nonprofit medical society and bestows the credential Fellow of the American College of Cardiology upon physicians who meet its stringent qualifications. The College is a leader in the formulation of health policy, standards and guidelines, and is a staunch supporter of cardiovascular research. The ACC provides professional education and operates national registries for the measurement and improvement of quality care. More information about the association is available online at www.cardiosource.org.
YOU ARE HERE: Home > About ACC > Press Releases > Heart Disease and Secondhand Smoke, Anxiety


Seismic activity was detected Saturday near the site of North Korea's Punggye-ri nuclear site, but it is not known whether a nuclear test caused the development.
The first sign Pyongyang has conducted a nuclear test is usually seismic activity. North Korea has one nuclear test site -- Punggye-ri.
A magnitude 3.5 earthquake struck at 4:29 a.m. ET Saturday 22 kilometers (more than 13 miles) east-northeast of Sungjibaegam, North Korea, the US Geological Survey said. The depth of the earthquake was 5 kilometers (3.1 miles).
"This event occurred in the area of the previous North Korean nuclear tests," the USGS said. "We cannot conclusively confirm at this time the nature (natural or human-made) of the event."
The Comprehensive Nuclear Test Ban Treaty Organization, a watchdog group that works to end nuclear testing worldwide, said there were two seismic events Saturday in North Korea, neither of very large magnitude. The larger one had a 3.4 magnitude, the group's initial assessment found, which is much smaller than anything declared as a nuclear test in previous years.
The analysis indicated neither one was man-made, meaning they don't appear to be explosions. The locations are around 50 kilometers away (more than 30 miles) from the site of previous nuclear tests, the group said.
Two South Korean officials at the Korea Meteorological Administration told CNN that their analysis so far suggests Saturday's seismic activity around the nuclear site was not caused by an explosion or a collapse of the site.
"We assess that there is a slim possibility that it was caused by a collapse," said Park Jong-shin, one of the officials.
"Our analysis shows that it was a natural earthquake. However, we are carrying out a further analysis because there are concerns that it might have been a man-made earthquake."
A preliminary analysis shows the earthquake occurred 20 kilometers (12.4 miles) southeast of the North Korean nuclear test site, the official said.
China's earthquake administration said it was a magnitude 3.4 earthquake and cited a "suspected explosion."
Saturday's reports of seismic activity come at a time of rising tensions between the United States and North Korea, with North Korean dictator Kim Jong Un and President Donald Trump engaging in an escalating war of words over Pyongyang's nuclear program.
North Korea's foreign minister said this week that his country could test a powerful nuclear weapon over the Pacific Ocean in response to President Donald Trump's threats of military action.
Foreign Minister Ri Yong Ho spoke to reporters in New York during the UN General Assembly shortly after North Korean leader Kim Jong Un made an unprecedented televised statement, accusing Trump of being "mentally deranged."
The forceful rhetoric from Pyongyang came after Trump threatened to "totally destroy" North Korea in a speech Tuesday to the General Assembly. Trump tweeted Friday that Kim was "obviously a madman" who would be "tested like never before."
One -- titled "We will throw the irrational war fanatics of Trump's gang in the fire of justice" -- condemned Trump's UN speech as "rubbish."
"Trump, the president of so-called 'power,' is mad enough to wag his tongue without any consideration that he would 'totally destroy' a sovereign state."
The article said, "For more than seven decades since the foundation of the UN, no chief executives or diplomats including the preceding US presidents have openly called for the obliteration of another state" at the UN General Assembly.
"Trump's rubbish is the open declaration of war against our supreme dignity, state, social system and people, and an unpardonable extra-large provocation," the report said, adding that "the US warmongers will face unimaginable consequences."
"It is a foolish misjudgment if Trump's gang thinks that America is safe because it's far away from the Korean Peninsula."
"The fire roughnecks who enjoy playing with fire, will die in fire," the news agency said.
Russian Foreign Minister Sergey Lavrov said this week that "we're witnessing a very dangerous confrontation spiral around (North Korea).
"We resolutely condemned the nuclear missile adventures of Pyongyang in violation of Security Council resolutions, but military hysteria is not just an impasse, it's a disaster," Lavrov said in a speech at the UN General Assembly.


It has been 14 months since the New Horizons spacecraft flew past Pluto and its moons, but data still continues to come in, and new discoveries are still being made. The dwarf planet has surprised scientists by its geological activity, for the most part unexpected for such a small, cold body. Now two new results are adding to the mystery of Pluto: the detection of x-rays emanating from the surface and new evidence that Pluto "spray-paints" the north pole of its largest moon Charon a rusty red color.
As had been surmised, and now substantiated by additional research, the coloring comes from Pluto, as methane gas escapes Pluto's weak gravity and re-freezes on Charon at its north pole. Ultraviolet light from the Sun then changes the material into heavier hydrocarbons and eventually into reddish organic materials called tholins. In essence, Pluto is "spray-painting" its largest moon.
Analysis of images of Charon taken by New Horizons was combined with computer models of how ice would be expected to evolve at Charon's poles. What was found was evidence for "extreme weather" at Charon's poles, where 100 years of continuous sunlight alternate with another century of continuous darkness. Surface temperatures during the dark winters were found to dip to -430 Fahrenheit (-257 Celsius), which is cold enough for methane gas to freeze into solid ice.
Should ask Lisse about it in Nov, and post a follow up..
Something knocked Uranus over some time ago. I wonder in the inclination of planet Nine, Pluto and Uranus show any relation.
Pluto may have gotten some heavy material from inside an ice giant.