diff --git a/.gitignore b/.gitignore
index e69de29..17a319a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,9 @@
+
+.idea/
+*.iws
+out/
+.gradle
+build/
+
+
+!gradle-wrapper.jar
\ No newline at end of file
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 0000000..16175a8
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    id("ru.mipt.npm.project")
+}
+
+group = "ru.inr.mass"
+version = "0.1.0-SHAPSHOT"
+
+val dataforgeVersion by extra("0.3.0-dev")
+
+val spaceRepo by extra("https://maven.pkg.jetbrains.space/mipt-npm/p/numass/maven")
+
+apiValidation{
+    validationDisabled = true
+}
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..e708b1c
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..da9702f
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100644
index 0000000..4f906e0
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or 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
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..107acd3
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/numass-data-model/build.gradle.kts b/numass-data-model/build.gradle.kts
new file mode 100644
index 0000000..a230a9d
--- /dev/null
+++ b/numass-data-model/build.gradle.kts
@@ -0,0 +1,10 @@
+plugins {
+    kotlin("jvm")
+    id("ru.mipt.npm.kscience")
+}
+
+val dataforgeVersion: String by rootProject.extra
+
+dependencies {
+    api("hep.dataforge:dataforge-context:$dataforgeVersion")
+}
diff --git a/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/MetaBlock.kt b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/MetaBlock.kt
new file mode 100644
index 0000000..5335e6e
--- /dev/null
+++ b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/MetaBlock.kt
@@ -0,0 +1,39 @@
+package ru.inr.mass.data.api
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.flatMap
+import kotlinx.coroutines.flow.flatMapConcat
+import java.time.Duration
+import java.time.Instant
+import java.util.stream.Stream
+
+public interface ParentBlock : NumassBlock {
+    public val blocks: List<NumassBlock>
+
+    /**
+     * If true, the sub-blocks a considered to be isSequential, if not, the sub-blocks are parallel
+     */
+    public val isSequential: Boolean get() = true
+}
+
+/**
+ * A block constructed from a set of other blocks. Internal blocks are not necessary subsequent. Blocks are automatically sorted.
+ * Created by darksnake on 16.07.2017.
+ */
+public class MetaBlock(override val blocks: List<NumassBlock>) : ParentBlock {
+
+    override val startTime: Instant
+        get() = blocks.first().startTime
+
+    override val length: Duration
+        get() = Duration.ofNanos(blocks.stream().mapToLong { block -> block.length.toNanos() }.sum())
+
+    override val events: Flow<NumassEvent>
+        get() = blocks.sortedBy { it.startTime }.asFlow().flatMapConcat { it.events }
+
+    override val frames: Flow<NumassFrame>
+        get() = blocks.sortedBy { it.startTime }.asFlow().flatMapConcat { it.frames }
+
+
+}
diff --git a/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassBlock.kt b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassBlock.kt
new file mode 100644
index 0000000..7602b97
--- /dev/null
+++ b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassBlock.kt
@@ -0,0 +1,114 @@
+/*
+ * Copyright  2018 Alexander Nozik.
+ *
+ * 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
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package ru.inr.mass.data.api
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.emptyFlow
+import java.time.Duration
+import java.time.Instant
+
+public open class OrphanNumassEvent(public val amplitude: Short, public val timeOffset: Long) :
+    Comparable<OrphanNumassEvent> {
+    public operator fun component1(): Short = amplitude
+    public operator fun component2(): Long = timeOffset
+
+    override fun compareTo(other: OrphanNumassEvent): Int {
+        return this.timeOffset.compareTo(other.timeOffset)
+    }
+}
+
+/**
+ * A single numass event with given amplitude and time.
+ *
+ * @author Darksnake
+ * @property amp the amplitude of the event
+ * @property timeOffset time in nanoseconds relative to block start
+ * @property owner an owner block for this event
+ *
+ */
+public class NumassEvent(amplitude: Short, timeOffset: Long, public val owner: NumassBlock) :
+    OrphanNumassEvent(amplitude, timeOffset) {
+
+    public val channel: Int get() = owner.channel
+
+    public val time: Instant get() = owner.startTime.plusNanos(timeOffset)
+
+}
+
+
+/**
+ * A single continuous measurement block. The block can contain both isolated events and signal frames
+ *
+ *
+ * Created by darksnake on 06-Jul-17.
+ */
+public interface NumassBlock {
+
+    /**
+     * The absolute start time of the block
+     */
+    public val startTime: Instant
+
+    /**
+     * The length of the block
+     */
+    public val length: Duration
+
+    /**
+     * Stream of isolated events. Could be empty
+     */
+    public val events: Flow<NumassEvent>
+
+    /**
+     * Stream of frames. Could be empty
+     */
+    public val frames: Flow<NumassFrame>
+
+    public val channel: Int get() = 0
+}
+
+public fun OrphanNumassEvent.adopt(parent: NumassBlock): NumassEvent {
+    return NumassEvent(this.amplitude, this.timeOffset, parent)
+}
+
+/**
+ * A simple in-memory implementation of block of events. No frames are allowed
+ * Created by darksnake on 08.07.2017.
+ */
+public class SimpleBlock(
+    override val startTime: Instant,
+    override val length: Duration,
+    rawEvents: Iterable<OrphanNumassEvent>,
+) : NumassBlock {
+
+    private val eventList by lazy { rawEvents.map { it.adopt(this) } }
+
+    override val frames: Flow<NumassFrame> get() = emptyFlow()
+
+    override val events: Flow<NumassEvent> get() = eventList.asFlow()
+
+    public companion object {
+        public suspend fun produce(
+            startTime: Instant,
+            length: Duration,
+            producer: suspend () -> Iterable<OrphanNumassEvent>,
+        ): SimpleBlock {
+            return SimpleBlock(startTime, length, producer())
+        }
+    }
+}
\ No newline at end of file
diff --git a/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassFrame.kt b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassFrame.kt
new file mode 100644
index 0000000..94daa32
--- /dev/null
+++ b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassFrame.kt
@@ -0,0 +1,27 @@
+package ru.inr.mass.data.api
+
+import java.nio.ShortBuffer
+import java.time.Duration
+import java.time.Instant
+
+/**
+ * The continuous frame of digital detector data
+ * Created by darksnake on 06-Jul-17.
+ */
+public class NumassFrame(
+        /**
+         * The absolute start time of the frame
+         */
+        public val time: Instant,
+        /**
+         * The time interval per tick
+         */
+        public val tickSize: Duration,
+        /**
+         * The buffered signal shape in ticks
+         */
+        public val signal: ShortBuffer) {
+
+    public val length: Duration
+        get() = tickSize.multipliedBy(signal.capacity().toLong())
+}
diff --git a/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassPoint.kt b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassPoint.kt
new file mode 100644
index 0000000..f71b5e9
--- /dev/null
+++ b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassPoint.kt
@@ -0,0 +1,130 @@
+/*
+ * Copyright  2018 Alexander Nozik.
+ *
+ * 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
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package ru.inr.mass.data.api
+
+import hep.dataforge.meta.*
+import hep.dataforge.names.Name
+import hep.dataforge.names.toName
+import hep.dataforge.provider.Provider
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.flatMap
+import kotlinx.coroutines.flow.flatMapConcat
+import java.time.Duration
+import java.time.Instant
+import java.util.stream.Stream
+
+/**
+ * Created by darksnake on 06-Jul-17.
+ */
+public interface NumassPoint : ParentBlock, Provider {
+
+    public val meta: Meta
+
+    override val blocks: List<NumassBlock>
+
+    /**
+     * Distinct map of channel number to corresponding grouping block
+     */
+    public val channels: Map<Int, NumassBlock>
+        get() = blocks.toList().groupBy { it.channel }.mapValues { entry ->
+            if (entry.value.size == 1) {
+                entry.value.first()
+            } else {
+                MetaBlock(entry.value)
+            }
+        }
+
+    override fun content(target: String): Map<Name, Any> = when (target) {
+        NUMASS_BLOCK_TARGET -> blocks.mapIndexed { index, numassBlock ->
+            "block[$index]".toName() to numassBlock
+        }.toMap()
+        NUMASS_CHANNEL_TARGET -> channels.mapKeys { "channel[${it.key}]".toName() }
+        else -> super.content(target)
+    }
+
+    /**
+     * Get the voltage setting for the point
+     *
+     * @return
+     */
+    public val voltage: Double get() = meta[HV_KEY].double ?: 0.0
+
+    /**
+     * Get the index for this point in the set
+     * @return
+     */
+    public val index: Int get() = meta[INDEX_KEY].int ?: -1
+
+    /**
+     * Get the starting time from meta or from first block
+     *
+     * @return
+     */
+    override val startTime: Instant
+        get() = meta[START_TIME_KEY]?.long?.let { Instant.ofEpochMilli(it) } ?: firstBlock.startTime
+
+    /**
+     * Get the length key of meta or calculate length as a sum of block lengths. The latter could be a bit slow
+     *
+     * @return
+     */
+    override val length: Duration
+        get() = Duration.ofNanos(blocks.stream().filter { it.channel == 0 }.mapToLong { it -> it.length.toNanos() }
+            .sum())
+
+    /**
+     * Get all events it all blocks as a single sequence
+     *
+     *
+     * Some performance analysis of different stream concatenation approaches is given here: https://www.techempower.com/blog/2016/10/19/efficient-multiple-stream-concatenation-in-java/
+     *
+     *
+     * @return
+     */
+    override val events: Flow<NumassEvent>
+        get() = blocks.asFlow().flatMapConcat { it.events }
+
+    /**
+     * Get all frames in all blocks as a single sequence
+     *
+     * @return
+     */
+    override val frames: Flow<NumassFrame>
+        get() = blocks.asFlow().flatMapConcat { it.frames }
+
+
+    override val isSequential: Boolean
+        get() = channels.size == 1
+
+    public companion object {
+        public const val NUMASS_BLOCK_TARGET: String = "block"
+        public const val NUMASS_CHANNEL_TARGET: String = "channel"
+
+        public const val START_TIME_KEY: String = "start"
+        public const val LENGTH_KEY: String = "length"
+        public const val HV_KEY: String = "voltage"
+        public const val INDEX_KEY: String = "index"
+    }
+}
+
+/**
+ * Get the first block if it exists. Throw runtime exception otherwise.
+ *
+ */
+public val NumassPoint.firstBlock: NumassBlock
+    get() = blocks.firstOrNull() ?: throw RuntimeException("The point is empty")
diff --git a/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassSet.kt b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassSet.kt
new file mode 100644
index 0000000..2b27c68
--- /dev/null
+++ b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/NumassSet.kt
@@ -0,0 +1,86 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.inr.mass.data.api
+
+import hep.dataforge.context.Named
+import hep.dataforge.meta.Meta
+import hep.dataforge.meta.get
+import hep.dataforge.meta.long
+import hep.dataforge.names.Name
+import hep.dataforge.names.toName
+import hep.dataforge.provider.Provider
+import java.time.Instant
+import java.util.*
+
+/**
+ * A single set of numass points previously called file.
+ *
+ * @author [Alexander Nozik](mailto:altavir@gmail.com)
+ */
+public interface NumassSet : Named, Iterable<NumassPoint>, Provider {
+
+    public val meta: Meta
+
+    public val points: List<NumassPoint>
+
+    /**
+     * Get the starting time from meta or from first point
+     *
+     * @return
+     */
+    public val startTime: Instant
+        get() = meta[NumassPoint.START_TIME_KEY].long?.let { Instant.ofEpochMilli(it) } ?: firstPoint.startTime
+
+    //suspend fun getHvData(): Table?
+
+    override fun iterator(): Iterator<NumassPoint> {
+        return points.iterator()
+    }
+
+
+    override val defaultTarget: String get() = NUMASS_POINT_PROVIDER_KEY
+
+    override fun content(target: String): Map<Name, Any> {
+        return if(target == NUMASS_POINT_PROVIDER_KEY){
+            points.associate { "point[${it.voltage}]".toName() to it }
+        }else {
+            super.content(target)
+        }
+    }
+
+    companion object {
+        const val DESCRIPTION_KEY = "info"
+        const val NUMASS_POINT_PROVIDER_KEY = "point"
+    }
+}
+
+/**
+ * List all points with given voltage
+ *
+ * @param voltage
+ * @return
+ */
+public fun NumassSet.getPoints(voltage: Double): List<NumassPoint> {
+    return points.filter { it -> it.voltage == voltage }.toList()
+}
+
+/**
+ * Find first point with given voltage
+ *
+ * @param voltage
+ * @return
+ */
+public fun NumassSet.pointOrNull(voltage: Double): NumassPoint? {
+    return points.firstOrNull { it -> it.voltage == voltage }
+}
+
+/**
+ * Get the first point if it exists. Throw runtime exception otherwise.
+ *
+ * @return
+ */
+public val NumassSet.firstPoint: NumassPoint
+    get() = points.firstOrNull() ?: throw RuntimeException("The set is empty")
diff --git a/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/SignalProcessor.kt b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/SignalProcessor.kt
new file mode 100644
index 0000000..96ebb04
--- /dev/null
+++ b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/SignalProcessor.kt
@@ -0,0 +1,11 @@
+package ru.inr.mass.data.api
+
+import java.util.stream.Stream
+
+/**
+ * An ancestor to numass frame analyzers
+ * Created by darksnake on 07.07.2017.
+ */
+public interface SignalProcessor {
+    public fun analyze(frame: NumassFrame): Stream<NumassEvent>
+}
diff --git a/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/SimpleNumassPoint.kt b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/SimpleNumassPoint.kt
new file mode 100644
index 0000000..398026e
--- /dev/null
+++ b/numass-data-model/src/main/kotlin/ru/inr/mass/data/api/SimpleNumassPoint.kt
@@ -0,0 +1,30 @@
+package ru.inr.mass.data.api
+
+import hep.dataforge.meta.Meta
+import hep.dataforge.meta.MetaBuilder
+
+/**
+ * A simple static implementation of NumassPoint
+ * Created by darksnake on 08.07.2017.
+ */
+public class SimpleNumassPoint(
+    override val blocks: List<NumassBlock>,
+    override val meta: Meta,
+    override val isSequential: Boolean = true,
+) : NumassPoint {
+
+//    /**
+//     * Input blocks must be sorted
+//     * @param voltage
+//     * @param blocks
+//     */
+//    constructor(blocks: Collection<NumassBlock>, voltage: Double) :
+//            this(blocks.sortedBy { it.startTime }, MetaBuilder("point").setValue(NumassPoint.HV_KEY, voltage))
+
+    init {
+        if (blocks.isEmpty()) {
+            throw IllegalArgumentException("No blocks in collection")
+        }
+    }
+
+}
diff --git a/numass-data-proto/build.gradle.kts b/numass-data-proto/build.gradle.kts
new file mode 100644
index 0000000..394423a
--- /dev/null
+++ b/numass-data-proto/build.gradle.kts
@@ -0,0 +1,53 @@
+import com.google.protobuf.gradle.*
+
+plugins {
+    java
+    kotlin("jvm")
+    id("ru.mipt.npm.kscience")
+    id("com.google.protobuf") version "0.8.14"
+}
+
+val dataforgeVersion: String by rootProject.extra
+
+dependencies {
+    api(project(":numass-data-model"))
+    api("hep.dataforge:dataforge-workspace:$dataforgeVersion")
+    implementation("com.google.protobuf:protobuf-java:3.14.0")
+    implementation("javax.annotation:javax.annotation-api:1.3.1")
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+    dependsOn(":numass-data-proto:generateProto")
+}
+
+sourceSets {
+    create("proto") {
+        proto {
+            srcDir("src/main/proto")
+        }
+    }
+    create("gen"){
+        java{
+            srcDir("gen/main/java")
+        }
+    }
+}
+
+//kotlin{
+//    sourceSets{
+//        main{
+//            de
+//        }
+//    }
+//}
+
+
+protobuf {
+    // Configure the protoc executable
+    protoc {
+        // Download from repositories
+        artifact = "com.google.protobuf:protoc:3.14.0"
+    }
+
+    generatedFilesBaseDir = "$projectDir/gen"
+}
diff --git a/numass-data-proto/gen/main/java/ru/inr/mass/data/proto/NumassProto.java b/numass-data-proto/gen/main/java/ru/inr/mass/data/proto/NumassProto.java
new file mode 100644
index 0000000..70958d3
--- /dev/null
+++ b/numass-data-proto/gen/main/java/ru/inr/mass/data/proto/NumassProto.java
@@ -0,0 +1,4995 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ru/inr/mass/data/proto/numass-proto.proto
+
+package ru.inr.mass.data.proto;
+
+public final class NumassProto {
+  private NumassProto() {}
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistryLite registry) {
+  }
+
+  public static void registerAllExtensions(
+      com.google.protobuf.ExtensionRegistry registry) {
+    registerAllExtensions(
+        (com.google.protobuf.ExtensionRegistryLite) registry);
+  }
+  public interface PointOrBuilder extends
+      // @@protoc_insertion_point(interface_extends:ru.inr.mass.data.proto.Point)
+      com.google.protobuf.MessageOrBuilder {
+
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel> 
+        getChannelsList();
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    ru.inr.mass.data.proto.NumassProto.Point.Channel getChannels(int index);
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    int getChannelsCount();
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder> 
+        getChannelsOrBuilderList();
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder getChannelsOrBuilder(
+        int index);
+  }
+  /**
+   * Protobuf type {@code ru.inr.mass.data.proto.Point}
+   */
+  public static final class Point extends
+      com.google.protobuf.GeneratedMessageV3 implements
+      // @@protoc_insertion_point(message_implements:ru.inr.mass.data.proto.Point)
+      PointOrBuilder {
+  private static final long serialVersionUID = 0L;
+    // Use Point.newBuilder() to construct.
+    private Point(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
+      super(builder);
+    }
+    private Point() {
+      channels_ = java.util.Collections.emptyList();
+    }
+
+    @java.lang.Override
+    @SuppressWarnings({"unused"})
+    protected java.lang.Object newInstance(
+        UnusedPrivateParameter unused) {
+      return new Point();
+    }
+
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+    getUnknownFields() {
+      return this.unknownFields;
+    }
+    private Point(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      this();
+      if (extensionRegistry == null) {
+        throw new java.lang.NullPointerException();
+      }
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            case 10: {
+              if (!((mutable_bitField0_ & 0x00000001) != 0)) {
+                channels_ = new java.util.ArrayList<ru.inr.mass.data.proto.NumassProto.Point.Channel>();
+                mutable_bitField0_ |= 0x00000001;
+              }
+              channels_.add(
+                  input.readMessage(ru.inr.mass.data.proto.NumassProto.Point.Channel.parser(), extensionRegistry));
+              break;
+            }
+            default: {
+              if (!parseUnknownField(
+                  input, unknownFields, extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e).setUnfinishedMessage(this);
+      } finally {
+        if (((mutable_bitField0_ & 0x00000001) != 0)) {
+          channels_ = java.util.Collections.unmodifiableList(channels_);
+        }
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_descriptor;
+    }
+
+    @java.lang.Override
+    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              ru.inr.mass.data.proto.NumassProto.Point.class, ru.inr.mass.data.proto.NumassProto.Point.Builder.class);
+    }
+
+    public interface ChannelOrBuilder extends
+        // @@protoc_insertion_point(interface_extends:ru.inr.mass.data.proto.Point.Channel)
+        com.google.protobuf.MessageOrBuilder {
+
+      /**
+       * <pre>
+       * The number of measuring channel
+       * </pre>
+       *
+       * <code>uint64 id = 1;</code>
+       * @return The id.
+       */
+      long getId();
+
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block> 
+          getBlocksList();
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      ru.inr.mass.data.proto.NumassProto.Point.Channel.Block getBlocks(int index);
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      int getBlocksCount();
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder> 
+          getBlocksOrBuilderList();
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder getBlocksOrBuilder(
+          int index);
+    }
+    /**
+     * <pre>
+     * A single channel for multichannel detector readout
+     * </pre>
+     *
+     * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel}
+     */
+    public static final class Channel extends
+        com.google.protobuf.GeneratedMessageV3 implements
+        // @@protoc_insertion_point(message_implements:ru.inr.mass.data.proto.Point.Channel)
+        ChannelOrBuilder {
+    private static final long serialVersionUID = 0L;
+      // Use Channel.newBuilder() to construct.
+      private Channel(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
+        super(builder);
+      }
+      private Channel() {
+        blocks_ = java.util.Collections.emptyList();
+      }
+
+      @java.lang.Override
+      @SuppressWarnings({"unused"})
+      protected java.lang.Object newInstance(
+          UnusedPrivateParameter unused) {
+        return new Channel();
+      }
+
+      @java.lang.Override
+      public final com.google.protobuf.UnknownFieldSet
+      getUnknownFields() {
+        return this.unknownFields;
+      }
+      private Channel(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        this();
+        if (extensionRegistry == null) {
+          throw new java.lang.NullPointerException();
+        }
+        int mutable_bitField0_ = 0;
+        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+            com.google.protobuf.UnknownFieldSet.newBuilder();
+        try {
+          boolean done = false;
+          while (!done) {
+            int tag = input.readTag();
+            switch (tag) {
+              case 0:
+                done = true;
+                break;
+              case 8: {
+
+                id_ = input.readUInt64();
+                break;
+              }
+              case 18: {
+                if (!((mutable_bitField0_ & 0x00000001) != 0)) {
+                  blocks_ = new java.util.ArrayList<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block>();
+                  mutable_bitField0_ |= 0x00000001;
+                }
+                blocks_.add(
+                    input.readMessage(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.parser(), extensionRegistry));
+                break;
+              }
+              default: {
+                if (!parseUnknownField(
+                    input, unknownFields, extensionRegistry, tag)) {
+                  done = true;
+                }
+                break;
+              }
+            }
+          }
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          throw e.setUnfinishedMessage(this);
+        } catch (java.io.IOException e) {
+          throw new com.google.protobuf.InvalidProtocolBufferException(
+              e).setUnfinishedMessage(this);
+        } finally {
+          if (((mutable_bitField0_ & 0x00000001) != 0)) {
+            blocks_ = java.util.Collections.unmodifiableList(blocks_);
+          }
+          this.unknownFields = unknownFields.build();
+          makeExtensionsImmutable();
+        }
+      }
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                ru.inr.mass.data.proto.NumassProto.Point.Channel.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder.class);
+      }
+
+      public interface BlockOrBuilder extends
+          // @@protoc_insertion_point(interface_extends:ru.inr.mass.data.proto.Point.Channel.Block)
+          com.google.protobuf.MessageOrBuilder {
+
+        /**
+         * <pre>
+         * Block start in epoch nanos
+         * </pre>
+         *
+         * <code>uint64 time = 1;</code>
+         * @return The time.
+         */
+        long getTime();
+
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame> 
+            getFramesList();
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame getFrames(int index);
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        int getFramesCount();
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder> 
+            getFramesOrBuilderList();
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder getFramesOrBuilder(
+            int index);
+
+        /**
+         * <pre>
+         * Events array
+         * </pre>
+         *
+         * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+         * @return Whether the events field is set.
+         */
+        boolean hasEvents();
+        /**
+         * <pre>
+         * Events array
+         * </pre>
+         *
+         * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+         * @return The events.
+         */
+        ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events getEvents();
+        /**
+         * <pre>
+         * Events array
+         * </pre>
+         *
+         * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+         */
+        ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.EventsOrBuilder getEventsOrBuilder();
+
+        /**
+         * <pre>
+         * block size in nanos. If missing, take from meta.
+         * </pre>
+         *
+         * <code>uint64 length = 4;</code>
+         * @return The length.
+         */
+        long getLength();
+
+        /**
+         * <pre>
+         * tick size in nanos. Obsolete, to be removed
+         * </pre>
+         *
+         * <code>uint64 bin_size = 5;</code>
+         * @return The binSize.
+         */
+        long getBinSize();
+      }
+      /**
+       * <pre>
+       *A continuous measurement block
+       * </pre>
+       *
+       * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel.Block}
+       */
+      public static final class Block extends
+          com.google.protobuf.GeneratedMessageV3 implements
+          // @@protoc_insertion_point(message_implements:ru.inr.mass.data.proto.Point.Channel.Block)
+          BlockOrBuilder {
+      private static final long serialVersionUID = 0L;
+        // Use Block.newBuilder() to construct.
+        private Block(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
+          super(builder);
+        }
+        private Block() {
+          frames_ = java.util.Collections.emptyList();
+        }
+
+        @java.lang.Override
+        @SuppressWarnings({"unused"})
+        protected java.lang.Object newInstance(
+            UnusedPrivateParameter unused) {
+          return new Block();
+        }
+
+        @java.lang.Override
+        public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+          return this.unknownFields;
+        }
+        private Block(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          this();
+          if (extensionRegistry == null) {
+            throw new java.lang.NullPointerException();
+          }
+          int mutable_bitField0_ = 0;
+          com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+              com.google.protobuf.UnknownFieldSet.newBuilder();
+          try {
+            boolean done = false;
+            while (!done) {
+              int tag = input.readTag();
+              switch (tag) {
+                case 0:
+                  done = true;
+                  break;
+                case 8: {
+
+                  time_ = input.readUInt64();
+                  break;
+                }
+                case 18: {
+                  if (!((mutable_bitField0_ & 0x00000001) != 0)) {
+                    frames_ = new java.util.ArrayList<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame>();
+                    mutable_bitField0_ |= 0x00000001;
+                  }
+                  frames_.add(
+                      input.readMessage(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.parser(), extensionRegistry));
+                  break;
+                }
+                case 26: {
+                  ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder subBuilder = null;
+                  if (events_ != null) {
+                    subBuilder = events_.toBuilder();
+                  }
+                  events_ = input.readMessage(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.parser(), extensionRegistry);
+                  if (subBuilder != null) {
+                    subBuilder.mergeFrom(events_);
+                    events_ = subBuilder.buildPartial();
+                  }
+
+                  break;
+                }
+                case 32: {
+
+                  length_ = input.readUInt64();
+                  break;
+                }
+                case 40: {
+
+                  binSize_ = input.readUInt64();
+                  break;
+                }
+                default: {
+                  if (!parseUnknownField(
+                      input, unknownFields, extensionRegistry, tag)) {
+                    done = true;
+                  }
+                  break;
+                }
+              }
+            }
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            throw e.setUnfinishedMessage(this);
+          } catch (java.io.IOException e) {
+            throw new com.google.protobuf.InvalidProtocolBufferException(
+                e).setUnfinishedMessage(this);
+          } finally {
+            if (((mutable_bitField0_ & 0x00000001) != 0)) {
+              frames_ = java.util.Collections.unmodifiableList(frames_);
+            }
+            this.unknownFields = unknownFields.build();
+            makeExtensionsImmutable();
+          }
+        }
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder.class);
+        }
+
+        public interface FrameOrBuilder extends
+            // @@protoc_insertion_point(interface_extends:ru.inr.mass.data.proto.Point.Channel.Block.Frame)
+            com.google.protobuf.MessageOrBuilder {
+
+          /**
+           * <pre>
+           * Time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>uint64 time = 1;</code>
+           * @return The time.
+           */
+          long getTime();
+
+          /**
+           * <pre>
+           * Frame data as an array of int16 mesured in arbitrary channels
+           * </pre>
+           *
+           * <code>bytes data = 2;</code>
+           * @return The data.
+           */
+          com.google.protobuf.ByteString getData();
+        }
+        /**
+         * <pre>
+         * Raw data frame
+         * </pre>
+         *
+         * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel.Block.Frame}
+         */
+        public static final class Frame extends
+            com.google.protobuf.GeneratedMessageV3 implements
+            // @@protoc_insertion_point(message_implements:ru.inr.mass.data.proto.Point.Channel.Block.Frame)
+            FrameOrBuilder {
+        private static final long serialVersionUID = 0L;
+          // Use Frame.newBuilder() to construct.
+          private Frame(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
+            super(builder);
+          }
+          private Frame() {
+            data_ = com.google.protobuf.ByteString.EMPTY;
+          }
+
+          @java.lang.Override
+          @SuppressWarnings({"unused"})
+          protected java.lang.Object newInstance(
+              UnusedPrivateParameter unused) {
+            return new Frame();
+          }
+
+          @java.lang.Override
+          public final com.google.protobuf.UnknownFieldSet
+          getUnknownFields() {
+            return this.unknownFields;
+          }
+          private Frame(
+              com.google.protobuf.CodedInputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            this();
+            if (extensionRegistry == null) {
+              throw new java.lang.NullPointerException();
+            }
+            com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+                com.google.protobuf.UnknownFieldSet.newBuilder();
+            try {
+              boolean done = false;
+              while (!done) {
+                int tag = input.readTag();
+                switch (tag) {
+                  case 0:
+                    done = true;
+                    break;
+                  case 8: {
+
+                    time_ = input.readUInt64();
+                    break;
+                  }
+                  case 18: {
+
+                    data_ = input.readBytes();
+                    break;
+                  }
+                  default: {
+                    if (!parseUnknownField(
+                        input, unknownFields, extensionRegistry, tag)) {
+                      done = true;
+                    }
+                    break;
+                  }
+                }
+              }
+            } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+              throw e.setUnfinishedMessage(this);
+            } catch (java.io.IOException e) {
+              throw new com.google.protobuf.InvalidProtocolBufferException(
+                  e).setUnfinishedMessage(this);
+            } finally {
+              this.unknownFields = unknownFields.build();
+              makeExtensionsImmutable();
+            }
+          }
+          public static final com.google.protobuf.Descriptors.Descriptor
+              getDescriptor() {
+            return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_descriptor;
+          }
+
+          @java.lang.Override
+          protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+              internalGetFieldAccessorTable() {
+            return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_fieldAccessorTable
+                .ensureFieldAccessorsInitialized(
+                    ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder.class);
+          }
+
+          public static final int TIME_FIELD_NUMBER = 1;
+          private long time_;
+          /**
+           * <pre>
+           * Time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>uint64 time = 1;</code>
+           * @return The time.
+           */
+          @java.lang.Override
+          public long getTime() {
+            return time_;
+          }
+
+          public static final int DATA_FIELD_NUMBER = 2;
+          private com.google.protobuf.ByteString data_;
+          /**
+           * <pre>
+           * Frame data as an array of int16 mesured in arbitrary channels
+           * </pre>
+           *
+           * <code>bytes data = 2;</code>
+           * @return The data.
+           */
+          @java.lang.Override
+          public com.google.protobuf.ByteString getData() {
+            return data_;
+          }
+
+          private byte memoizedIsInitialized = -1;
+          @java.lang.Override
+          public final boolean isInitialized() {
+            byte isInitialized = memoizedIsInitialized;
+            if (isInitialized == 1) return true;
+            if (isInitialized == 0) return false;
+
+            memoizedIsInitialized = 1;
+            return true;
+          }
+
+          @java.lang.Override
+          public void writeTo(com.google.protobuf.CodedOutputStream output)
+                              throws java.io.IOException {
+            if (time_ != 0L) {
+              output.writeUInt64(1, time_);
+            }
+            if (!data_.isEmpty()) {
+              output.writeBytes(2, data_);
+            }
+            unknownFields.writeTo(output);
+          }
+
+          @java.lang.Override
+          public int getSerializedSize() {
+            int size = memoizedSize;
+            if (size != -1) return size;
+
+            size = 0;
+            if (time_ != 0L) {
+              size += com.google.protobuf.CodedOutputStream
+                .computeUInt64Size(1, time_);
+            }
+            if (!data_.isEmpty()) {
+              size += com.google.protobuf.CodedOutputStream
+                .computeBytesSize(2, data_);
+            }
+            size += unknownFields.getSerializedSize();
+            memoizedSize = size;
+            return size;
+          }
+
+          @java.lang.Override
+          public boolean equals(final java.lang.Object obj) {
+            if (obj == this) {
+             return true;
+            }
+            if (!(obj instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame)) {
+              return super.equals(obj);
+            }
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame other = (ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame) obj;
+
+            if (getTime()
+                != other.getTime()) return false;
+            if (!getData()
+                .equals(other.getData())) return false;
+            if (!unknownFields.equals(other.unknownFields)) return false;
+            return true;
+          }
+
+          @java.lang.Override
+          public int hashCode() {
+            if (memoizedHashCode != 0) {
+              return memoizedHashCode;
+            }
+            int hash = 41;
+            hash = (19 * hash) + getDescriptor().hashCode();
+            hash = (37 * hash) + TIME_FIELD_NUMBER;
+            hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
+                getTime());
+            hash = (37 * hash) + DATA_FIELD_NUMBER;
+            hash = (53 * hash) + getData().hashCode();
+            hash = (29 * hash) + unknownFields.hashCode();
+            memoizedHashCode = hash;
+            return hash;
+          }
+
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              java.nio.ByteBuffer data)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              java.nio.ByteBuffer data,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              com.google.protobuf.ByteString data)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              com.google.protobuf.ByteString data,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(byte[] data)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              byte[] data,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(java.io.InputStream input)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              java.io.InputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseDelimitedFrom(java.io.InputStream input)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseDelimitedWithIOException(PARSER, input);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseDelimitedFrom(
+              java.io.InputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              com.google.protobuf.CodedInputStream input)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parseFrom(
+              com.google.protobuf.CodedInputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input, extensionRegistry);
+          }
+
+          @java.lang.Override
+          public Builder newBuilderForType() { return newBuilder(); }
+          public static Builder newBuilder() {
+            return DEFAULT_INSTANCE.toBuilder();
+          }
+          public static Builder newBuilder(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame prototype) {
+            return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+          }
+          @java.lang.Override
+          public Builder toBuilder() {
+            return this == DEFAULT_INSTANCE
+                ? new Builder() : new Builder().mergeFrom(this);
+          }
+
+          @java.lang.Override
+          protected Builder newBuilderForType(
+              com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+            Builder builder = new Builder(parent);
+            return builder;
+          }
+          /**
+           * <pre>
+           * Raw data frame
+           * </pre>
+           *
+           * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel.Block.Frame}
+           */
+          public static final class Builder extends
+              com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
+              // @@protoc_insertion_point(builder_implements:ru.inr.mass.data.proto.Point.Channel.Block.Frame)
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder {
+            public static final com.google.protobuf.Descriptors.Descriptor
+                getDescriptor() {
+              return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_descriptor;
+            }
+
+            @java.lang.Override
+            protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+                internalGetFieldAccessorTable() {
+              return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_fieldAccessorTable
+                  .ensureFieldAccessorsInitialized(
+                      ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder.class);
+            }
+
+            // Construct using ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.newBuilder()
+            private Builder() {
+              maybeForceBuilderInitialization();
+            }
+
+            private Builder(
+                com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+              super(parent);
+              maybeForceBuilderInitialization();
+            }
+            private void maybeForceBuilderInitialization() {
+              if (com.google.protobuf.GeneratedMessageV3
+                      .alwaysUseFieldBuilders) {
+              }
+            }
+            @java.lang.Override
+            public Builder clear() {
+              super.clear();
+              time_ = 0L;
+
+              data_ = com.google.protobuf.ByteString.EMPTY;
+
+              return this;
+            }
+
+            @java.lang.Override
+            public com.google.protobuf.Descriptors.Descriptor
+                getDescriptorForType() {
+              return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_descriptor;
+            }
+
+            @java.lang.Override
+            public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame getDefaultInstanceForType() {
+              return ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.getDefaultInstance();
+            }
+
+            @java.lang.Override
+            public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame build() {
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame result = buildPartial();
+              if (!result.isInitialized()) {
+                throw newUninitializedMessageException(result);
+              }
+              return result;
+            }
+
+            @java.lang.Override
+            public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame buildPartial() {
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame result = new ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame(this);
+              result.time_ = time_;
+              result.data_ = data_;
+              onBuilt();
+              return result;
+            }
+
+            @java.lang.Override
+            public Builder clone() {
+              return super.clone();
+            }
+            @java.lang.Override
+            public Builder setField(
+                com.google.protobuf.Descriptors.FieldDescriptor field,
+                java.lang.Object value) {
+              return super.setField(field, value);
+            }
+            @java.lang.Override
+            public Builder clearField(
+                com.google.protobuf.Descriptors.FieldDescriptor field) {
+              return super.clearField(field);
+            }
+            @java.lang.Override
+            public Builder clearOneof(
+                com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+              return super.clearOneof(oneof);
+            }
+            @java.lang.Override
+            public Builder setRepeatedField(
+                com.google.protobuf.Descriptors.FieldDescriptor field,
+                int index, java.lang.Object value) {
+              return super.setRepeatedField(field, index, value);
+            }
+            @java.lang.Override
+            public Builder addRepeatedField(
+                com.google.protobuf.Descriptors.FieldDescriptor field,
+                java.lang.Object value) {
+              return super.addRepeatedField(field, value);
+            }
+            @java.lang.Override
+            public Builder mergeFrom(com.google.protobuf.Message other) {
+              if (other instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame) {
+                return mergeFrom((ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame)other);
+              } else {
+                super.mergeFrom(other);
+                return this;
+              }
+            }
+
+            public Builder mergeFrom(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame other) {
+              if (other == ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.getDefaultInstance()) return this;
+              if (other.getTime() != 0L) {
+                setTime(other.getTime());
+              }
+              if (other.getData() != com.google.protobuf.ByteString.EMPTY) {
+                setData(other.getData());
+              }
+              this.mergeUnknownFields(other.unknownFields);
+              onChanged();
+              return this;
+            }
+
+            @java.lang.Override
+            public final boolean isInitialized() {
+              return true;
+            }
+
+            @java.lang.Override
+            public Builder mergeFrom(
+                com.google.protobuf.CodedInputStream input,
+                com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+                throws java.io.IOException {
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame parsedMessage = null;
+              try {
+                parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+              } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+                parsedMessage = (ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame) e.getUnfinishedMessage();
+                throw e.unwrapIOException();
+              } finally {
+                if (parsedMessage != null) {
+                  mergeFrom(parsedMessage);
+                }
+              }
+              return this;
+            }
+
+            private long time_ ;
+            /**
+             * <pre>
+             * Time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>uint64 time = 1;</code>
+             * @return The time.
+             */
+            @java.lang.Override
+            public long getTime() {
+              return time_;
+            }
+            /**
+             * <pre>
+             * Time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>uint64 time = 1;</code>
+             * @param value The time to set.
+             * @return This builder for chaining.
+             */
+            public Builder setTime(long value) {
+              
+              time_ = value;
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>uint64 time = 1;</code>
+             * @return This builder for chaining.
+             */
+            public Builder clearTime() {
+              
+              time_ = 0L;
+              onChanged();
+              return this;
+            }
+
+            private com.google.protobuf.ByteString data_ = com.google.protobuf.ByteString.EMPTY;
+            /**
+             * <pre>
+             * Frame data as an array of int16 mesured in arbitrary channels
+             * </pre>
+             *
+             * <code>bytes data = 2;</code>
+             * @return The data.
+             */
+            @java.lang.Override
+            public com.google.protobuf.ByteString getData() {
+              return data_;
+            }
+            /**
+             * <pre>
+             * Frame data as an array of int16 mesured in arbitrary channels
+             * </pre>
+             *
+             * <code>bytes data = 2;</code>
+             * @param value The data to set.
+             * @return This builder for chaining.
+             */
+            public Builder setData(com.google.protobuf.ByteString value) {
+              if (value == null) {
+    throw new NullPointerException();
+  }
+  
+              data_ = value;
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Frame data as an array of int16 mesured in arbitrary channels
+             * </pre>
+             *
+             * <code>bytes data = 2;</code>
+             * @return This builder for chaining.
+             */
+            public Builder clearData() {
+              
+              data_ = getDefaultInstance().getData();
+              onChanged();
+              return this;
+            }
+            @java.lang.Override
+            public final Builder setUnknownFields(
+                final com.google.protobuf.UnknownFieldSet unknownFields) {
+              return super.setUnknownFields(unknownFields);
+            }
+
+            @java.lang.Override
+            public final Builder mergeUnknownFields(
+                final com.google.protobuf.UnknownFieldSet unknownFields) {
+              return super.mergeUnknownFields(unknownFields);
+            }
+
+
+            // @@protoc_insertion_point(builder_scope:ru.inr.mass.data.proto.Point.Channel.Block.Frame)
+          }
+
+          // @@protoc_insertion_point(class_scope:ru.inr.mass.data.proto.Point.Channel.Block.Frame)
+          private static final ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame DEFAULT_INSTANCE;
+          static {
+            DEFAULT_INSTANCE = new ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame();
+          }
+
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame getDefaultInstance() {
+            return DEFAULT_INSTANCE;
+          }
+
+          private static final com.google.protobuf.Parser<Frame>
+              PARSER = new com.google.protobuf.AbstractParser<Frame>() {
+            @java.lang.Override
+            public Frame parsePartialFrom(
+                com.google.protobuf.CodedInputStream input,
+                com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+                throws com.google.protobuf.InvalidProtocolBufferException {
+              return new Frame(input, extensionRegistry);
+            }
+          };
+
+          public static com.google.protobuf.Parser<Frame> parser() {
+            return PARSER;
+          }
+
+          @java.lang.Override
+          public com.google.protobuf.Parser<Frame> getParserForType() {
+            return PARSER;
+          }
+
+          @java.lang.Override
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame getDefaultInstanceForType() {
+            return DEFAULT_INSTANCE;
+          }
+
+        }
+
+        public interface EventsOrBuilder extends
+            // @@protoc_insertion_point(interface_extends:ru.inr.mass.data.proto.Point.Channel.Block.Events)
+            com.google.protobuf.MessageOrBuilder {
+
+          /**
+           * <pre>
+           * Array of time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>repeated uint64 times = 1;</code>
+           * @return A list containing the times.
+           */
+          java.util.List<java.lang.Long> getTimesList();
+          /**
+           * <pre>
+           * Array of time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>repeated uint64 times = 1;</code>
+           * @return The count of times.
+           */
+          int getTimesCount();
+          /**
+           * <pre>
+           * Array of time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>repeated uint64 times = 1;</code>
+           * @param index The index of the element to return.
+           * @return The times at the given index.
+           */
+          long getTimes(int index);
+
+          /**
+           * <pre>
+           * Array of amplitudes of events in channels
+           * </pre>
+           *
+           * <code>repeated uint64 amplitudes = 2;</code>
+           * @return A list containing the amplitudes.
+           */
+          java.util.List<java.lang.Long> getAmplitudesList();
+          /**
+           * <pre>
+           * Array of amplitudes of events in channels
+           * </pre>
+           *
+           * <code>repeated uint64 amplitudes = 2;</code>
+           * @return The count of amplitudes.
+           */
+          int getAmplitudesCount();
+          /**
+           * <pre>
+           * Array of amplitudes of events in channels
+           * </pre>
+           *
+           * <code>repeated uint64 amplitudes = 2;</code>
+           * @param index The index of the element to return.
+           * @return The amplitudes at the given index.
+           */
+          long getAmplitudes(int index);
+        }
+        /**
+         * <pre>
+         * Event block obtained directly from  device of from frame analysis
+         * In order to save space, times and amplitudes are in separate arrays.
+         * Amplitude and time with the same index correspond to the same event
+         * </pre>
+         *
+         * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel.Block.Events}
+         */
+        public static final class Events extends
+            com.google.protobuf.GeneratedMessageV3 implements
+            // @@protoc_insertion_point(message_implements:ru.inr.mass.data.proto.Point.Channel.Block.Events)
+            EventsOrBuilder {
+        private static final long serialVersionUID = 0L;
+          // Use Events.newBuilder() to construct.
+          private Events(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
+            super(builder);
+          }
+          private Events() {
+            times_ = emptyLongList();
+            amplitudes_ = emptyLongList();
+          }
+
+          @java.lang.Override
+          @SuppressWarnings({"unused"})
+          protected java.lang.Object newInstance(
+              UnusedPrivateParameter unused) {
+            return new Events();
+          }
+
+          @java.lang.Override
+          public final com.google.protobuf.UnknownFieldSet
+          getUnknownFields() {
+            return this.unknownFields;
+          }
+          private Events(
+              com.google.protobuf.CodedInputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            this();
+            if (extensionRegistry == null) {
+              throw new java.lang.NullPointerException();
+            }
+            int mutable_bitField0_ = 0;
+            com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+                com.google.protobuf.UnknownFieldSet.newBuilder();
+            try {
+              boolean done = false;
+              while (!done) {
+                int tag = input.readTag();
+                switch (tag) {
+                  case 0:
+                    done = true;
+                    break;
+                  case 8: {
+                    if (!((mutable_bitField0_ & 0x00000001) != 0)) {
+                      times_ = newLongList();
+                      mutable_bitField0_ |= 0x00000001;
+                    }
+                    times_.addLong(input.readUInt64());
+                    break;
+                  }
+                  case 10: {
+                    int length = input.readRawVarint32();
+                    int limit = input.pushLimit(length);
+                    if (!((mutable_bitField0_ & 0x00000001) != 0) && input.getBytesUntilLimit() > 0) {
+                      times_ = newLongList();
+                      mutable_bitField0_ |= 0x00000001;
+                    }
+                    while (input.getBytesUntilLimit() > 0) {
+                      times_.addLong(input.readUInt64());
+                    }
+                    input.popLimit(limit);
+                    break;
+                  }
+                  case 16: {
+                    if (!((mutable_bitField0_ & 0x00000002) != 0)) {
+                      amplitudes_ = newLongList();
+                      mutable_bitField0_ |= 0x00000002;
+                    }
+                    amplitudes_.addLong(input.readUInt64());
+                    break;
+                  }
+                  case 18: {
+                    int length = input.readRawVarint32();
+                    int limit = input.pushLimit(length);
+                    if (!((mutable_bitField0_ & 0x00000002) != 0) && input.getBytesUntilLimit() > 0) {
+                      amplitudes_ = newLongList();
+                      mutable_bitField0_ |= 0x00000002;
+                    }
+                    while (input.getBytesUntilLimit() > 0) {
+                      amplitudes_.addLong(input.readUInt64());
+                    }
+                    input.popLimit(limit);
+                    break;
+                  }
+                  default: {
+                    if (!parseUnknownField(
+                        input, unknownFields, extensionRegistry, tag)) {
+                      done = true;
+                    }
+                    break;
+                  }
+                }
+              }
+            } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+              throw e.setUnfinishedMessage(this);
+            } catch (java.io.IOException e) {
+              throw new com.google.protobuf.InvalidProtocolBufferException(
+                  e).setUnfinishedMessage(this);
+            } finally {
+              if (((mutable_bitField0_ & 0x00000001) != 0)) {
+                times_.makeImmutable(); // C
+              }
+              if (((mutable_bitField0_ & 0x00000002) != 0)) {
+                amplitudes_.makeImmutable(); // C
+              }
+              this.unknownFields = unknownFields.build();
+              makeExtensionsImmutable();
+            }
+          }
+          public static final com.google.protobuf.Descriptors.Descriptor
+              getDescriptor() {
+            return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_descriptor;
+          }
+
+          @java.lang.Override
+          protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+              internalGetFieldAccessorTable() {
+            return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_fieldAccessorTable
+                .ensureFieldAccessorsInitialized(
+                    ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder.class);
+          }
+
+          public static final int TIMES_FIELD_NUMBER = 1;
+          private com.google.protobuf.Internal.LongList times_;
+          /**
+           * <pre>
+           * Array of time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>repeated uint64 times = 1;</code>
+           * @return A list containing the times.
+           */
+          @java.lang.Override
+          public java.util.List<java.lang.Long>
+              getTimesList() {
+            return times_;
+          }
+          /**
+           * <pre>
+           * Array of time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>repeated uint64 times = 1;</code>
+           * @return The count of times.
+           */
+          public int getTimesCount() {
+            return times_.size();
+          }
+          /**
+           * <pre>
+           * Array of time in nanos from the beginning of the block
+           * </pre>
+           *
+           * <code>repeated uint64 times = 1;</code>
+           * @param index The index of the element to return.
+           * @return The times at the given index.
+           */
+          public long getTimes(int index) {
+            return times_.getLong(index);
+          }
+          private int timesMemoizedSerializedSize = -1;
+
+          public static final int AMPLITUDES_FIELD_NUMBER = 2;
+          private com.google.protobuf.Internal.LongList amplitudes_;
+          /**
+           * <pre>
+           * Array of amplitudes of events in channels
+           * </pre>
+           *
+           * <code>repeated uint64 amplitudes = 2;</code>
+           * @return A list containing the amplitudes.
+           */
+          @java.lang.Override
+          public java.util.List<java.lang.Long>
+              getAmplitudesList() {
+            return amplitudes_;
+          }
+          /**
+           * <pre>
+           * Array of amplitudes of events in channels
+           * </pre>
+           *
+           * <code>repeated uint64 amplitudes = 2;</code>
+           * @return The count of amplitudes.
+           */
+          public int getAmplitudesCount() {
+            return amplitudes_.size();
+          }
+          /**
+           * <pre>
+           * Array of amplitudes of events in channels
+           * </pre>
+           *
+           * <code>repeated uint64 amplitudes = 2;</code>
+           * @param index The index of the element to return.
+           * @return The amplitudes at the given index.
+           */
+          public long getAmplitudes(int index) {
+            return amplitudes_.getLong(index);
+          }
+          private int amplitudesMemoizedSerializedSize = -1;
+
+          private byte memoizedIsInitialized = -1;
+          @java.lang.Override
+          public final boolean isInitialized() {
+            byte isInitialized = memoizedIsInitialized;
+            if (isInitialized == 1) return true;
+            if (isInitialized == 0) return false;
+
+            memoizedIsInitialized = 1;
+            return true;
+          }
+
+          @java.lang.Override
+          public void writeTo(com.google.protobuf.CodedOutputStream output)
+                              throws java.io.IOException {
+            getSerializedSize();
+            if (getTimesList().size() > 0) {
+              output.writeUInt32NoTag(10);
+              output.writeUInt32NoTag(timesMemoizedSerializedSize);
+            }
+            for (int i = 0; i < times_.size(); i++) {
+              output.writeUInt64NoTag(times_.getLong(i));
+            }
+            if (getAmplitudesList().size() > 0) {
+              output.writeUInt32NoTag(18);
+              output.writeUInt32NoTag(amplitudesMemoizedSerializedSize);
+            }
+            for (int i = 0; i < amplitudes_.size(); i++) {
+              output.writeUInt64NoTag(amplitudes_.getLong(i));
+            }
+            unknownFields.writeTo(output);
+          }
+
+          @java.lang.Override
+          public int getSerializedSize() {
+            int size = memoizedSize;
+            if (size != -1) return size;
+
+            size = 0;
+            {
+              int dataSize = 0;
+              for (int i = 0; i < times_.size(); i++) {
+                dataSize += com.google.protobuf.CodedOutputStream
+                  .computeUInt64SizeNoTag(times_.getLong(i));
+              }
+              size += dataSize;
+              if (!getTimesList().isEmpty()) {
+                size += 1;
+                size += com.google.protobuf.CodedOutputStream
+                    .computeInt32SizeNoTag(dataSize);
+              }
+              timesMemoizedSerializedSize = dataSize;
+            }
+            {
+              int dataSize = 0;
+              for (int i = 0; i < amplitudes_.size(); i++) {
+                dataSize += com.google.protobuf.CodedOutputStream
+                  .computeUInt64SizeNoTag(amplitudes_.getLong(i));
+              }
+              size += dataSize;
+              if (!getAmplitudesList().isEmpty()) {
+                size += 1;
+                size += com.google.protobuf.CodedOutputStream
+                    .computeInt32SizeNoTag(dataSize);
+              }
+              amplitudesMemoizedSerializedSize = dataSize;
+            }
+            size += unknownFields.getSerializedSize();
+            memoizedSize = size;
+            return size;
+          }
+
+          @java.lang.Override
+          public boolean equals(final java.lang.Object obj) {
+            if (obj == this) {
+             return true;
+            }
+            if (!(obj instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events)) {
+              return super.equals(obj);
+            }
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events other = (ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events) obj;
+
+            if (!getTimesList()
+                .equals(other.getTimesList())) return false;
+            if (!getAmplitudesList()
+                .equals(other.getAmplitudesList())) return false;
+            if (!unknownFields.equals(other.unknownFields)) return false;
+            return true;
+          }
+
+          @java.lang.Override
+          public int hashCode() {
+            if (memoizedHashCode != 0) {
+              return memoizedHashCode;
+            }
+            int hash = 41;
+            hash = (19 * hash) + getDescriptor().hashCode();
+            if (getTimesCount() > 0) {
+              hash = (37 * hash) + TIMES_FIELD_NUMBER;
+              hash = (53 * hash) + getTimesList().hashCode();
+            }
+            if (getAmplitudesCount() > 0) {
+              hash = (37 * hash) + AMPLITUDES_FIELD_NUMBER;
+              hash = (53 * hash) + getAmplitudesList().hashCode();
+            }
+            hash = (29 * hash) + unknownFields.hashCode();
+            memoizedHashCode = hash;
+            return hash;
+          }
+
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              java.nio.ByteBuffer data)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              java.nio.ByteBuffer data,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              com.google.protobuf.ByteString data)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              com.google.protobuf.ByteString data,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(byte[] data)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              byte[] data,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return PARSER.parseFrom(data, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(java.io.InputStream input)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              java.io.InputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseDelimitedFrom(java.io.InputStream input)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseDelimitedWithIOException(PARSER, input);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseDelimitedFrom(
+              java.io.InputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              com.google.protobuf.CodedInputStream input)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input);
+          }
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parseFrom(
+              com.google.protobuf.CodedInputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws java.io.IOException {
+            return com.google.protobuf.GeneratedMessageV3
+                .parseWithIOException(PARSER, input, extensionRegistry);
+          }
+
+          @java.lang.Override
+          public Builder newBuilderForType() { return newBuilder(); }
+          public static Builder newBuilder() {
+            return DEFAULT_INSTANCE.toBuilder();
+          }
+          public static Builder newBuilder(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events prototype) {
+            return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+          }
+          @java.lang.Override
+          public Builder toBuilder() {
+            return this == DEFAULT_INSTANCE
+                ? new Builder() : new Builder().mergeFrom(this);
+          }
+
+          @java.lang.Override
+          protected Builder newBuilderForType(
+              com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+            Builder builder = new Builder(parent);
+            return builder;
+          }
+          /**
+           * <pre>
+           * Event block obtained directly from  device of from frame analysis
+           * In order to save space, times and amplitudes are in separate arrays.
+           * Amplitude and time with the same index correspond to the same event
+           * </pre>
+           *
+           * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel.Block.Events}
+           */
+          public static final class Builder extends
+              com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
+              // @@protoc_insertion_point(builder_implements:ru.inr.mass.data.proto.Point.Channel.Block.Events)
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.EventsOrBuilder {
+            public static final com.google.protobuf.Descriptors.Descriptor
+                getDescriptor() {
+              return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_descriptor;
+            }
+
+            @java.lang.Override
+            protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+                internalGetFieldAccessorTable() {
+              return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_fieldAccessorTable
+                  .ensureFieldAccessorsInitialized(
+                      ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder.class);
+            }
+
+            // Construct using ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.newBuilder()
+            private Builder() {
+              maybeForceBuilderInitialization();
+            }
+
+            private Builder(
+                com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+              super(parent);
+              maybeForceBuilderInitialization();
+            }
+            private void maybeForceBuilderInitialization() {
+              if (com.google.protobuf.GeneratedMessageV3
+                      .alwaysUseFieldBuilders) {
+              }
+            }
+            @java.lang.Override
+            public Builder clear() {
+              super.clear();
+              times_ = emptyLongList();
+              bitField0_ = (bitField0_ & ~0x00000001);
+              amplitudes_ = emptyLongList();
+              bitField0_ = (bitField0_ & ~0x00000002);
+              return this;
+            }
+
+            @java.lang.Override
+            public com.google.protobuf.Descriptors.Descriptor
+                getDescriptorForType() {
+              return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_descriptor;
+            }
+
+            @java.lang.Override
+            public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events getDefaultInstanceForType() {
+              return ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.getDefaultInstance();
+            }
+
+            @java.lang.Override
+            public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events build() {
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events result = buildPartial();
+              if (!result.isInitialized()) {
+                throw newUninitializedMessageException(result);
+              }
+              return result;
+            }
+
+            @java.lang.Override
+            public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events buildPartial() {
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events result = new ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events(this);
+              int from_bitField0_ = bitField0_;
+              if (((bitField0_ & 0x00000001) != 0)) {
+                times_.makeImmutable();
+                bitField0_ = (bitField0_ & ~0x00000001);
+              }
+              result.times_ = times_;
+              if (((bitField0_ & 0x00000002) != 0)) {
+                amplitudes_.makeImmutable();
+                bitField0_ = (bitField0_ & ~0x00000002);
+              }
+              result.amplitudes_ = amplitudes_;
+              onBuilt();
+              return result;
+            }
+
+            @java.lang.Override
+            public Builder clone() {
+              return super.clone();
+            }
+            @java.lang.Override
+            public Builder setField(
+                com.google.protobuf.Descriptors.FieldDescriptor field,
+                java.lang.Object value) {
+              return super.setField(field, value);
+            }
+            @java.lang.Override
+            public Builder clearField(
+                com.google.protobuf.Descriptors.FieldDescriptor field) {
+              return super.clearField(field);
+            }
+            @java.lang.Override
+            public Builder clearOneof(
+                com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+              return super.clearOneof(oneof);
+            }
+            @java.lang.Override
+            public Builder setRepeatedField(
+                com.google.protobuf.Descriptors.FieldDescriptor field,
+                int index, java.lang.Object value) {
+              return super.setRepeatedField(field, index, value);
+            }
+            @java.lang.Override
+            public Builder addRepeatedField(
+                com.google.protobuf.Descriptors.FieldDescriptor field,
+                java.lang.Object value) {
+              return super.addRepeatedField(field, value);
+            }
+            @java.lang.Override
+            public Builder mergeFrom(com.google.protobuf.Message other) {
+              if (other instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events) {
+                return mergeFrom((ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events)other);
+              } else {
+                super.mergeFrom(other);
+                return this;
+              }
+            }
+
+            public Builder mergeFrom(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events other) {
+              if (other == ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.getDefaultInstance()) return this;
+              if (!other.times_.isEmpty()) {
+                if (times_.isEmpty()) {
+                  times_ = other.times_;
+                  bitField0_ = (bitField0_ & ~0x00000001);
+                } else {
+                  ensureTimesIsMutable();
+                  times_.addAll(other.times_);
+                }
+                onChanged();
+              }
+              if (!other.amplitudes_.isEmpty()) {
+                if (amplitudes_.isEmpty()) {
+                  amplitudes_ = other.amplitudes_;
+                  bitField0_ = (bitField0_ & ~0x00000002);
+                } else {
+                  ensureAmplitudesIsMutable();
+                  amplitudes_.addAll(other.amplitudes_);
+                }
+                onChanged();
+              }
+              this.mergeUnknownFields(other.unknownFields);
+              onChanged();
+              return this;
+            }
+
+            @java.lang.Override
+            public final boolean isInitialized() {
+              return true;
+            }
+
+            @java.lang.Override
+            public Builder mergeFrom(
+                com.google.protobuf.CodedInputStream input,
+                com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+                throws java.io.IOException {
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events parsedMessage = null;
+              try {
+                parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+              } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+                parsedMessage = (ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events) e.getUnfinishedMessage();
+                throw e.unwrapIOException();
+              } finally {
+                if (parsedMessage != null) {
+                  mergeFrom(parsedMessage);
+                }
+              }
+              return this;
+            }
+            private int bitField0_;
+
+            private com.google.protobuf.Internal.LongList times_ = emptyLongList();
+            private void ensureTimesIsMutable() {
+              if (!((bitField0_ & 0x00000001) != 0)) {
+                times_ = mutableCopy(times_);
+                bitField0_ |= 0x00000001;
+               }
+            }
+            /**
+             * <pre>
+             * Array of time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>repeated uint64 times = 1;</code>
+             * @return A list containing the times.
+             */
+            public java.util.List<java.lang.Long>
+                getTimesList() {
+              return ((bitField0_ & 0x00000001) != 0) ?
+                       java.util.Collections.unmodifiableList(times_) : times_;
+            }
+            /**
+             * <pre>
+             * Array of time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>repeated uint64 times = 1;</code>
+             * @return The count of times.
+             */
+            public int getTimesCount() {
+              return times_.size();
+            }
+            /**
+             * <pre>
+             * Array of time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>repeated uint64 times = 1;</code>
+             * @param index The index of the element to return.
+             * @return The times at the given index.
+             */
+            public long getTimes(int index) {
+              return times_.getLong(index);
+            }
+            /**
+             * <pre>
+             * Array of time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>repeated uint64 times = 1;</code>
+             * @param index The index to set the value at.
+             * @param value The times to set.
+             * @return This builder for chaining.
+             */
+            public Builder setTimes(
+                int index, long value) {
+              ensureTimesIsMutable();
+              times_.setLong(index, value);
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Array of time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>repeated uint64 times = 1;</code>
+             * @param value The times to add.
+             * @return This builder for chaining.
+             */
+            public Builder addTimes(long value) {
+              ensureTimesIsMutable();
+              times_.addLong(value);
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Array of time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>repeated uint64 times = 1;</code>
+             * @param values The times to add.
+             * @return This builder for chaining.
+             */
+            public Builder addAllTimes(
+                java.lang.Iterable<? extends java.lang.Long> values) {
+              ensureTimesIsMutable();
+              com.google.protobuf.AbstractMessageLite.Builder.addAll(
+                  values, times_);
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Array of time in nanos from the beginning of the block
+             * </pre>
+             *
+             * <code>repeated uint64 times = 1;</code>
+             * @return This builder for chaining.
+             */
+            public Builder clearTimes() {
+              times_ = emptyLongList();
+              bitField0_ = (bitField0_ & ~0x00000001);
+              onChanged();
+              return this;
+            }
+
+            private com.google.protobuf.Internal.LongList amplitudes_ = emptyLongList();
+            private void ensureAmplitudesIsMutable() {
+              if (!((bitField0_ & 0x00000002) != 0)) {
+                amplitudes_ = mutableCopy(amplitudes_);
+                bitField0_ |= 0x00000002;
+               }
+            }
+            /**
+             * <pre>
+             * Array of amplitudes of events in channels
+             * </pre>
+             *
+             * <code>repeated uint64 amplitudes = 2;</code>
+             * @return A list containing the amplitudes.
+             */
+            public java.util.List<java.lang.Long>
+                getAmplitudesList() {
+              return ((bitField0_ & 0x00000002) != 0) ?
+                       java.util.Collections.unmodifiableList(amplitudes_) : amplitudes_;
+            }
+            /**
+             * <pre>
+             * Array of amplitudes of events in channels
+             * </pre>
+             *
+             * <code>repeated uint64 amplitudes = 2;</code>
+             * @return The count of amplitudes.
+             */
+            public int getAmplitudesCount() {
+              return amplitudes_.size();
+            }
+            /**
+             * <pre>
+             * Array of amplitudes of events in channels
+             * </pre>
+             *
+             * <code>repeated uint64 amplitudes = 2;</code>
+             * @param index The index of the element to return.
+             * @return The amplitudes at the given index.
+             */
+            public long getAmplitudes(int index) {
+              return amplitudes_.getLong(index);
+            }
+            /**
+             * <pre>
+             * Array of amplitudes of events in channels
+             * </pre>
+             *
+             * <code>repeated uint64 amplitudes = 2;</code>
+             * @param index The index to set the value at.
+             * @param value The amplitudes to set.
+             * @return This builder for chaining.
+             */
+            public Builder setAmplitudes(
+                int index, long value) {
+              ensureAmplitudesIsMutable();
+              amplitudes_.setLong(index, value);
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Array of amplitudes of events in channels
+             * </pre>
+             *
+             * <code>repeated uint64 amplitudes = 2;</code>
+             * @param value The amplitudes to add.
+             * @return This builder for chaining.
+             */
+            public Builder addAmplitudes(long value) {
+              ensureAmplitudesIsMutable();
+              amplitudes_.addLong(value);
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Array of amplitudes of events in channels
+             * </pre>
+             *
+             * <code>repeated uint64 amplitudes = 2;</code>
+             * @param values The amplitudes to add.
+             * @return This builder for chaining.
+             */
+            public Builder addAllAmplitudes(
+                java.lang.Iterable<? extends java.lang.Long> values) {
+              ensureAmplitudesIsMutable();
+              com.google.protobuf.AbstractMessageLite.Builder.addAll(
+                  values, amplitudes_);
+              onChanged();
+              return this;
+            }
+            /**
+             * <pre>
+             * Array of amplitudes of events in channels
+             * </pre>
+             *
+             * <code>repeated uint64 amplitudes = 2;</code>
+             * @return This builder for chaining.
+             */
+            public Builder clearAmplitudes() {
+              amplitudes_ = emptyLongList();
+              bitField0_ = (bitField0_ & ~0x00000002);
+              onChanged();
+              return this;
+            }
+            @java.lang.Override
+            public final Builder setUnknownFields(
+                final com.google.protobuf.UnknownFieldSet unknownFields) {
+              return super.setUnknownFields(unknownFields);
+            }
+
+            @java.lang.Override
+            public final Builder mergeUnknownFields(
+                final com.google.protobuf.UnknownFieldSet unknownFields) {
+              return super.mergeUnknownFields(unknownFields);
+            }
+
+
+            // @@protoc_insertion_point(builder_scope:ru.inr.mass.data.proto.Point.Channel.Block.Events)
+          }
+
+          // @@protoc_insertion_point(class_scope:ru.inr.mass.data.proto.Point.Channel.Block.Events)
+          private static final ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events DEFAULT_INSTANCE;
+          static {
+            DEFAULT_INSTANCE = new ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events();
+          }
+
+          public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events getDefaultInstance() {
+            return DEFAULT_INSTANCE;
+          }
+
+          private static final com.google.protobuf.Parser<Events>
+              PARSER = new com.google.protobuf.AbstractParser<Events>() {
+            @java.lang.Override
+            public Events parsePartialFrom(
+                com.google.protobuf.CodedInputStream input,
+                com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+                throws com.google.protobuf.InvalidProtocolBufferException {
+              return new Events(input, extensionRegistry);
+            }
+          };
+
+          public static com.google.protobuf.Parser<Events> parser() {
+            return PARSER;
+          }
+
+          @java.lang.Override
+          public com.google.protobuf.Parser<Events> getParserForType() {
+            return PARSER;
+          }
+
+          @java.lang.Override
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events getDefaultInstanceForType() {
+            return DEFAULT_INSTANCE;
+          }
+
+        }
+
+        public static final int TIME_FIELD_NUMBER = 1;
+        private long time_;
+        /**
+         * <pre>
+         * Block start in epoch nanos
+         * </pre>
+         *
+         * <code>uint64 time = 1;</code>
+         * @return The time.
+         */
+        @java.lang.Override
+        public long getTime() {
+          return time_;
+        }
+
+        public static final int FRAMES_FIELD_NUMBER = 2;
+        private java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame> frames_;
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        @java.lang.Override
+        public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame> getFramesList() {
+          return frames_;
+        }
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        @java.lang.Override
+        public java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder> 
+            getFramesOrBuilderList() {
+          return frames_;
+        }
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        @java.lang.Override
+        public int getFramesCount() {
+          return frames_.size();
+        }
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame getFrames(int index) {
+          return frames_.get(index);
+        }
+        /**
+         * <pre>
+         * Frames array
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+         */
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder getFramesOrBuilder(
+            int index) {
+          return frames_.get(index);
+        }
+
+        public static final int EVENTS_FIELD_NUMBER = 3;
+        private ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events events_;
+        /**
+         * <pre>
+         * Events array
+         * </pre>
+         *
+         * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+         * @return Whether the events field is set.
+         */
+        @java.lang.Override
+        public boolean hasEvents() {
+          return events_ != null;
+        }
+        /**
+         * <pre>
+         * Events array
+         * </pre>
+         *
+         * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+         * @return The events.
+         */
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events getEvents() {
+          return events_ == null ? ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.getDefaultInstance() : events_;
+        }
+        /**
+         * <pre>
+         * Events array
+         * </pre>
+         *
+         * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+         */
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.EventsOrBuilder getEventsOrBuilder() {
+          return getEvents();
+        }
+
+        public static final int LENGTH_FIELD_NUMBER = 4;
+        private long length_;
+        /**
+         * <pre>
+         * block size in nanos. If missing, take from meta.
+         * </pre>
+         *
+         * <code>uint64 length = 4;</code>
+         * @return The length.
+         */
+        @java.lang.Override
+        public long getLength() {
+          return length_;
+        }
+
+        public static final int BIN_SIZE_FIELD_NUMBER = 5;
+        private long binSize_;
+        /**
+         * <pre>
+         * tick size in nanos. Obsolete, to be removed
+         * </pre>
+         *
+         * <code>uint64 bin_size = 5;</code>
+         * @return The binSize.
+         */
+        @java.lang.Override
+        public long getBinSize() {
+          return binSize_;
+        }
+
+        private byte memoizedIsInitialized = -1;
+        @java.lang.Override
+        public final boolean isInitialized() {
+          byte isInitialized = memoizedIsInitialized;
+          if (isInitialized == 1) return true;
+          if (isInitialized == 0) return false;
+
+          memoizedIsInitialized = 1;
+          return true;
+        }
+
+        @java.lang.Override
+        public void writeTo(com.google.protobuf.CodedOutputStream output)
+                            throws java.io.IOException {
+          if (time_ != 0L) {
+            output.writeUInt64(1, time_);
+          }
+          for (int i = 0; i < frames_.size(); i++) {
+            output.writeMessage(2, frames_.get(i));
+          }
+          if (events_ != null) {
+            output.writeMessage(3, getEvents());
+          }
+          if (length_ != 0L) {
+            output.writeUInt64(4, length_);
+          }
+          if (binSize_ != 0L) {
+            output.writeUInt64(5, binSize_);
+          }
+          unknownFields.writeTo(output);
+        }
+
+        @java.lang.Override
+        public int getSerializedSize() {
+          int size = memoizedSize;
+          if (size != -1) return size;
+
+          size = 0;
+          if (time_ != 0L) {
+            size += com.google.protobuf.CodedOutputStream
+              .computeUInt64Size(1, time_);
+          }
+          for (int i = 0; i < frames_.size(); i++) {
+            size += com.google.protobuf.CodedOutputStream
+              .computeMessageSize(2, frames_.get(i));
+          }
+          if (events_ != null) {
+            size += com.google.protobuf.CodedOutputStream
+              .computeMessageSize(3, getEvents());
+          }
+          if (length_ != 0L) {
+            size += com.google.protobuf.CodedOutputStream
+              .computeUInt64Size(4, length_);
+          }
+          if (binSize_ != 0L) {
+            size += com.google.protobuf.CodedOutputStream
+              .computeUInt64Size(5, binSize_);
+          }
+          size += unknownFields.getSerializedSize();
+          memoizedSize = size;
+          return size;
+        }
+
+        @java.lang.Override
+        public boolean equals(final java.lang.Object obj) {
+          if (obj == this) {
+           return true;
+          }
+          if (!(obj instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel.Block)) {
+            return super.equals(obj);
+          }
+          ru.inr.mass.data.proto.NumassProto.Point.Channel.Block other = (ru.inr.mass.data.proto.NumassProto.Point.Channel.Block) obj;
+
+          if (getTime()
+              != other.getTime()) return false;
+          if (!getFramesList()
+              .equals(other.getFramesList())) return false;
+          if (hasEvents() != other.hasEvents()) return false;
+          if (hasEvents()) {
+            if (!getEvents()
+                .equals(other.getEvents())) return false;
+          }
+          if (getLength()
+              != other.getLength()) return false;
+          if (getBinSize()
+              != other.getBinSize()) return false;
+          if (!unknownFields.equals(other.unknownFields)) return false;
+          return true;
+        }
+
+        @java.lang.Override
+        public int hashCode() {
+          if (memoizedHashCode != 0) {
+            return memoizedHashCode;
+          }
+          int hash = 41;
+          hash = (19 * hash) + getDescriptor().hashCode();
+          hash = (37 * hash) + TIME_FIELD_NUMBER;
+          hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
+              getTime());
+          if (getFramesCount() > 0) {
+            hash = (37 * hash) + FRAMES_FIELD_NUMBER;
+            hash = (53 * hash) + getFramesList().hashCode();
+          }
+          if (hasEvents()) {
+            hash = (37 * hash) + EVENTS_FIELD_NUMBER;
+            hash = (53 * hash) + getEvents().hashCode();
+          }
+          hash = (37 * hash) + LENGTH_FIELD_NUMBER;
+          hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
+              getLength());
+          hash = (37 * hash) + BIN_SIZE_FIELD_NUMBER;
+          hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
+              getBinSize());
+          hash = (29 * hash) + unknownFields.hashCode();
+          memoizedHashCode = hash;
+          return hash;
+        }
+
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            java.nio.ByteBuffer data)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          return PARSER.parseFrom(data);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            java.nio.ByteBuffer data,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          return PARSER.parseFrom(data, extensionRegistry);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            com.google.protobuf.ByteString data)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          return PARSER.parseFrom(data);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            com.google.protobuf.ByteString data,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          return PARSER.parseFrom(data, extensionRegistry);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(byte[] data)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          return PARSER.parseFrom(data);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            byte[] data,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          return PARSER.parseFrom(data, extensionRegistry);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(java.io.InputStream input)
+            throws java.io.IOException {
+          return com.google.protobuf.GeneratedMessageV3
+              .parseWithIOException(PARSER, input);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            java.io.InputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          return com.google.protobuf.GeneratedMessageV3
+              .parseWithIOException(PARSER, input, extensionRegistry);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseDelimitedFrom(java.io.InputStream input)
+            throws java.io.IOException {
+          return com.google.protobuf.GeneratedMessageV3
+              .parseDelimitedWithIOException(PARSER, input);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseDelimitedFrom(
+            java.io.InputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          return com.google.protobuf.GeneratedMessageV3
+              .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            com.google.protobuf.CodedInputStream input)
+            throws java.io.IOException {
+          return com.google.protobuf.GeneratedMessageV3
+              .parseWithIOException(PARSER, input);
+        }
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parseFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          return com.google.protobuf.GeneratedMessageV3
+              .parseWithIOException(PARSER, input, extensionRegistry);
+        }
+
+        @java.lang.Override
+        public Builder newBuilderForType() { return newBuilder(); }
+        public static Builder newBuilder() {
+          return DEFAULT_INSTANCE.toBuilder();
+        }
+        public static Builder newBuilder(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block prototype) {
+          return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+        }
+        @java.lang.Override
+        public Builder toBuilder() {
+          return this == DEFAULT_INSTANCE
+              ? new Builder() : new Builder().mergeFrom(this);
+        }
+
+        @java.lang.Override
+        protected Builder newBuilderForType(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          Builder builder = new Builder(parent);
+          return builder;
+        }
+        /**
+         * <pre>
+         *A continuous measurement block
+         * </pre>
+         *
+         * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel.Block}
+         */
+        public static final class Builder extends
+            com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
+            // @@protoc_insertion_point(builder_implements:ru.inr.mass.data.proto.Point.Channel.Block)
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder {
+          public static final com.google.protobuf.Descriptors.Descriptor
+              getDescriptor() {
+            return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor;
+          }
+
+          @java.lang.Override
+          protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+              internalGetFieldAccessorTable() {
+            return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_fieldAccessorTable
+                .ensureFieldAccessorsInitialized(
+                    ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder.class);
+          }
+
+          // Construct using ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.newBuilder()
+          private Builder() {
+            maybeForceBuilderInitialization();
+          }
+
+          private Builder(
+              com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+            super(parent);
+            maybeForceBuilderInitialization();
+          }
+          private void maybeForceBuilderInitialization() {
+            if (com.google.protobuf.GeneratedMessageV3
+                    .alwaysUseFieldBuilders) {
+              getFramesFieldBuilder();
+            }
+          }
+          @java.lang.Override
+          public Builder clear() {
+            super.clear();
+            time_ = 0L;
+
+            if (framesBuilder_ == null) {
+              frames_ = java.util.Collections.emptyList();
+              bitField0_ = (bitField0_ & ~0x00000001);
+            } else {
+              framesBuilder_.clear();
+            }
+            if (eventsBuilder_ == null) {
+              events_ = null;
+            } else {
+              events_ = null;
+              eventsBuilder_ = null;
+            }
+            length_ = 0L;
+
+            binSize_ = 0L;
+
+            return this;
+          }
+
+          @java.lang.Override
+          public com.google.protobuf.Descriptors.Descriptor
+              getDescriptorForType() {
+            return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor;
+          }
+
+          @java.lang.Override
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block getDefaultInstanceForType() {
+            return ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.getDefaultInstance();
+          }
+
+          @java.lang.Override
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block build() {
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block result = buildPartial();
+            if (!result.isInitialized()) {
+              throw newUninitializedMessageException(result);
+            }
+            return result;
+          }
+
+          @java.lang.Override
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block buildPartial() {
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block result = new ru.inr.mass.data.proto.NumassProto.Point.Channel.Block(this);
+            int from_bitField0_ = bitField0_;
+            result.time_ = time_;
+            if (framesBuilder_ == null) {
+              if (((bitField0_ & 0x00000001) != 0)) {
+                frames_ = java.util.Collections.unmodifiableList(frames_);
+                bitField0_ = (bitField0_ & ~0x00000001);
+              }
+              result.frames_ = frames_;
+            } else {
+              result.frames_ = framesBuilder_.build();
+            }
+            if (eventsBuilder_ == null) {
+              result.events_ = events_;
+            } else {
+              result.events_ = eventsBuilder_.build();
+            }
+            result.length_ = length_;
+            result.binSize_ = binSize_;
+            onBuilt();
+            return result;
+          }
+
+          @java.lang.Override
+          public Builder clone() {
+            return super.clone();
+          }
+          @java.lang.Override
+          public Builder setField(
+              com.google.protobuf.Descriptors.FieldDescriptor field,
+              java.lang.Object value) {
+            return super.setField(field, value);
+          }
+          @java.lang.Override
+          public Builder clearField(
+              com.google.protobuf.Descriptors.FieldDescriptor field) {
+            return super.clearField(field);
+          }
+          @java.lang.Override
+          public Builder clearOneof(
+              com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+            return super.clearOneof(oneof);
+          }
+          @java.lang.Override
+          public Builder setRepeatedField(
+              com.google.protobuf.Descriptors.FieldDescriptor field,
+              int index, java.lang.Object value) {
+            return super.setRepeatedField(field, index, value);
+          }
+          @java.lang.Override
+          public Builder addRepeatedField(
+              com.google.protobuf.Descriptors.FieldDescriptor field,
+              java.lang.Object value) {
+            return super.addRepeatedField(field, value);
+          }
+          @java.lang.Override
+          public Builder mergeFrom(com.google.protobuf.Message other) {
+            if (other instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel.Block) {
+              return mergeFrom((ru.inr.mass.data.proto.NumassProto.Point.Channel.Block)other);
+            } else {
+              super.mergeFrom(other);
+              return this;
+            }
+          }
+
+          public Builder mergeFrom(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block other) {
+            if (other == ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.getDefaultInstance()) return this;
+            if (other.getTime() != 0L) {
+              setTime(other.getTime());
+            }
+            if (framesBuilder_ == null) {
+              if (!other.frames_.isEmpty()) {
+                if (frames_.isEmpty()) {
+                  frames_ = other.frames_;
+                  bitField0_ = (bitField0_ & ~0x00000001);
+                } else {
+                  ensureFramesIsMutable();
+                  frames_.addAll(other.frames_);
+                }
+                onChanged();
+              }
+            } else {
+              if (!other.frames_.isEmpty()) {
+                if (framesBuilder_.isEmpty()) {
+                  framesBuilder_.dispose();
+                  framesBuilder_ = null;
+                  frames_ = other.frames_;
+                  bitField0_ = (bitField0_ & ~0x00000001);
+                  framesBuilder_ = 
+                    com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+                       getFramesFieldBuilder() : null;
+                } else {
+                  framesBuilder_.addAllMessages(other.frames_);
+                }
+              }
+            }
+            if (other.hasEvents()) {
+              mergeEvents(other.getEvents());
+            }
+            if (other.getLength() != 0L) {
+              setLength(other.getLength());
+            }
+            if (other.getBinSize() != 0L) {
+              setBinSize(other.getBinSize());
+            }
+            this.mergeUnknownFields(other.unknownFields);
+            onChanged();
+            return this;
+          }
+
+          @java.lang.Override
+          public final boolean isInitialized() {
+            return true;
+          }
+
+          @java.lang.Override
+          public Builder mergeFrom(
+              com.google.protobuf.CodedInputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws java.io.IOException {
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block parsedMessage = null;
+            try {
+              parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+            } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+              parsedMessage = (ru.inr.mass.data.proto.NumassProto.Point.Channel.Block) e.getUnfinishedMessage();
+              throw e.unwrapIOException();
+            } finally {
+              if (parsedMessage != null) {
+                mergeFrom(parsedMessage);
+              }
+            }
+            return this;
+          }
+          private int bitField0_;
+
+          private long time_ ;
+          /**
+           * <pre>
+           * Block start in epoch nanos
+           * </pre>
+           *
+           * <code>uint64 time = 1;</code>
+           * @return The time.
+           */
+          @java.lang.Override
+          public long getTime() {
+            return time_;
+          }
+          /**
+           * <pre>
+           * Block start in epoch nanos
+           * </pre>
+           *
+           * <code>uint64 time = 1;</code>
+           * @param value The time to set.
+           * @return This builder for chaining.
+           */
+          public Builder setTime(long value) {
+            
+            time_ = value;
+            onChanged();
+            return this;
+          }
+          /**
+           * <pre>
+           * Block start in epoch nanos
+           * </pre>
+           *
+           * <code>uint64 time = 1;</code>
+           * @return This builder for chaining.
+           */
+          public Builder clearTime() {
+            
+            time_ = 0L;
+            onChanged();
+            return this;
+          }
+
+          private java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame> frames_ =
+            java.util.Collections.emptyList();
+          private void ensureFramesIsMutable() {
+            if (!((bitField0_ & 0x00000001) != 0)) {
+              frames_ = new java.util.ArrayList<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame>(frames_);
+              bitField0_ |= 0x00000001;
+             }
+          }
+
+          private com.google.protobuf.RepeatedFieldBuilderV3<
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder> framesBuilder_;
+
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame> getFramesList() {
+            if (framesBuilder_ == null) {
+              return java.util.Collections.unmodifiableList(frames_);
+            } else {
+              return framesBuilder_.getMessageList();
+            }
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public int getFramesCount() {
+            if (framesBuilder_ == null) {
+              return frames_.size();
+            } else {
+              return framesBuilder_.getCount();
+            }
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame getFrames(int index) {
+            if (framesBuilder_ == null) {
+              return frames_.get(index);
+            } else {
+              return framesBuilder_.getMessage(index);
+            }
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder setFrames(
+              int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame value) {
+            if (framesBuilder_ == null) {
+              if (value == null) {
+                throw new NullPointerException();
+              }
+              ensureFramesIsMutable();
+              frames_.set(index, value);
+              onChanged();
+            } else {
+              framesBuilder_.setMessage(index, value);
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder setFrames(
+              int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder builderForValue) {
+            if (framesBuilder_ == null) {
+              ensureFramesIsMutable();
+              frames_.set(index, builderForValue.build());
+              onChanged();
+            } else {
+              framesBuilder_.setMessage(index, builderForValue.build());
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder addFrames(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame value) {
+            if (framesBuilder_ == null) {
+              if (value == null) {
+                throw new NullPointerException();
+              }
+              ensureFramesIsMutable();
+              frames_.add(value);
+              onChanged();
+            } else {
+              framesBuilder_.addMessage(value);
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder addFrames(
+              int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame value) {
+            if (framesBuilder_ == null) {
+              if (value == null) {
+                throw new NullPointerException();
+              }
+              ensureFramesIsMutable();
+              frames_.add(index, value);
+              onChanged();
+            } else {
+              framesBuilder_.addMessage(index, value);
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder addFrames(
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder builderForValue) {
+            if (framesBuilder_ == null) {
+              ensureFramesIsMutable();
+              frames_.add(builderForValue.build());
+              onChanged();
+            } else {
+              framesBuilder_.addMessage(builderForValue.build());
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder addFrames(
+              int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder builderForValue) {
+            if (framesBuilder_ == null) {
+              ensureFramesIsMutable();
+              frames_.add(index, builderForValue.build());
+              onChanged();
+            } else {
+              framesBuilder_.addMessage(index, builderForValue.build());
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder addAllFrames(
+              java.lang.Iterable<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame> values) {
+            if (framesBuilder_ == null) {
+              ensureFramesIsMutable();
+              com.google.protobuf.AbstractMessageLite.Builder.addAll(
+                  values, frames_);
+              onChanged();
+            } else {
+              framesBuilder_.addAllMessages(values);
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder clearFrames() {
+            if (framesBuilder_ == null) {
+              frames_ = java.util.Collections.emptyList();
+              bitField0_ = (bitField0_ & ~0x00000001);
+              onChanged();
+            } else {
+              framesBuilder_.clear();
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public Builder removeFrames(int index) {
+            if (framesBuilder_ == null) {
+              ensureFramesIsMutable();
+              frames_.remove(index);
+              onChanged();
+            } else {
+              framesBuilder_.remove(index);
+            }
+            return this;
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder getFramesBuilder(
+              int index) {
+            return getFramesFieldBuilder().getBuilder(index);
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder getFramesOrBuilder(
+              int index) {
+            if (framesBuilder_ == null) {
+              return frames_.get(index);  } else {
+              return framesBuilder_.getMessageOrBuilder(index);
+            }
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder> 
+               getFramesOrBuilderList() {
+            if (framesBuilder_ != null) {
+              return framesBuilder_.getMessageOrBuilderList();
+            } else {
+              return java.util.Collections.unmodifiableList(frames_);
+            }
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder addFramesBuilder() {
+            return getFramesFieldBuilder().addBuilder(
+                ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.getDefaultInstance());
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder addFramesBuilder(
+              int index) {
+            return getFramesFieldBuilder().addBuilder(
+                index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.getDefaultInstance());
+          }
+          /**
+           * <pre>
+           * Frames array
+           * </pre>
+           *
+           * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block.Frame frames = 2;</code>
+           */
+          public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder> 
+               getFramesBuilderList() {
+            return getFramesFieldBuilder().getBuilderList();
+          }
+          private com.google.protobuf.RepeatedFieldBuilderV3<
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder> 
+              getFramesFieldBuilder() {
+            if (framesBuilder_ == null) {
+              framesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+                  ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Frame.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.FrameOrBuilder>(
+                      frames_,
+                      ((bitField0_ & 0x00000001) != 0),
+                      getParentForChildren(),
+                      isClean());
+              frames_ = null;
+            }
+            return framesBuilder_;
+          }
+
+          private ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events events_;
+          private com.google.protobuf.SingleFieldBuilderV3<
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.EventsOrBuilder> eventsBuilder_;
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           * @return Whether the events field is set.
+           */
+          public boolean hasEvents() {
+            return eventsBuilder_ != null || events_ != null;
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           * @return The events.
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events getEvents() {
+            if (eventsBuilder_ == null) {
+              return events_ == null ? ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.getDefaultInstance() : events_;
+            } else {
+              return eventsBuilder_.getMessage();
+            }
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           */
+          public Builder setEvents(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events value) {
+            if (eventsBuilder_ == null) {
+              if (value == null) {
+                throw new NullPointerException();
+              }
+              events_ = value;
+              onChanged();
+            } else {
+              eventsBuilder_.setMessage(value);
+            }
+
+            return this;
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           */
+          public Builder setEvents(
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder builderForValue) {
+            if (eventsBuilder_ == null) {
+              events_ = builderForValue.build();
+              onChanged();
+            } else {
+              eventsBuilder_.setMessage(builderForValue.build());
+            }
+
+            return this;
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           */
+          public Builder mergeEvents(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events value) {
+            if (eventsBuilder_ == null) {
+              if (events_ != null) {
+                events_ =
+                  ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.newBuilder(events_).mergeFrom(value).buildPartial();
+              } else {
+                events_ = value;
+              }
+              onChanged();
+            } else {
+              eventsBuilder_.mergeFrom(value);
+            }
+
+            return this;
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           */
+          public Builder clearEvents() {
+            if (eventsBuilder_ == null) {
+              events_ = null;
+              onChanged();
+            } else {
+              events_ = null;
+              eventsBuilder_ = null;
+            }
+
+            return this;
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder getEventsBuilder() {
+            
+            onChanged();
+            return getEventsFieldBuilder().getBuilder();
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           */
+          public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.EventsOrBuilder getEventsOrBuilder() {
+            if (eventsBuilder_ != null) {
+              return eventsBuilder_.getMessageOrBuilder();
+            } else {
+              return events_ == null ?
+                  ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.getDefaultInstance() : events_;
+            }
+          }
+          /**
+           * <pre>
+           * Events array
+           * </pre>
+           *
+           * <code>.ru.inr.mass.data.proto.Point.Channel.Block.Events events = 3;</code>
+           */
+          private com.google.protobuf.SingleFieldBuilderV3<
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.EventsOrBuilder> 
+              getEventsFieldBuilder() {
+            if (eventsBuilder_ == null) {
+              eventsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
+                  ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Events.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.EventsOrBuilder>(
+                      getEvents(),
+                      getParentForChildren(),
+                      isClean());
+              events_ = null;
+            }
+            return eventsBuilder_;
+          }
+
+          private long length_ ;
+          /**
+           * <pre>
+           * block size in nanos. If missing, take from meta.
+           * </pre>
+           *
+           * <code>uint64 length = 4;</code>
+           * @return The length.
+           */
+          @java.lang.Override
+          public long getLength() {
+            return length_;
+          }
+          /**
+           * <pre>
+           * block size in nanos. If missing, take from meta.
+           * </pre>
+           *
+           * <code>uint64 length = 4;</code>
+           * @param value The length to set.
+           * @return This builder for chaining.
+           */
+          public Builder setLength(long value) {
+            
+            length_ = value;
+            onChanged();
+            return this;
+          }
+          /**
+           * <pre>
+           * block size in nanos. If missing, take from meta.
+           * </pre>
+           *
+           * <code>uint64 length = 4;</code>
+           * @return This builder for chaining.
+           */
+          public Builder clearLength() {
+            
+            length_ = 0L;
+            onChanged();
+            return this;
+          }
+
+          private long binSize_ ;
+          /**
+           * <pre>
+           * tick size in nanos. Obsolete, to be removed
+           * </pre>
+           *
+           * <code>uint64 bin_size = 5;</code>
+           * @return The binSize.
+           */
+          @java.lang.Override
+          public long getBinSize() {
+            return binSize_;
+          }
+          /**
+           * <pre>
+           * tick size in nanos. Obsolete, to be removed
+           * </pre>
+           *
+           * <code>uint64 bin_size = 5;</code>
+           * @param value The binSize to set.
+           * @return This builder for chaining.
+           */
+          public Builder setBinSize(long value) {
+            
+            binSize_ = value;
+            onChanged();
+            return this;
+          }
+          /**
+           * <pre>
+           * tick size in nanos. Obsolete, to be removed
+           * </pre>
+           *
+           * <code>uint64 bin_size = 5;</code>
+           * @return This builder for chaining.
+           */
+          public Builder clearBinSize() {
+            
+            binSize_ = 0L;
+            onChanged();
+            return this;
+          }
+          @java.lang.Override
+          public final Builder setUnknownFields(
+              final com.google.protobuf.UnknownFieldSet unknownFields) {
+            return super.setUnknownFields(unknownFields);
+          }
+
+          @java.lang.Override
+          public final Builder mergeUnknownFields(
+              final com.google.protobuf.UnknownFieldSet unknownFields) {
+            return super.mergeUnknownFields(unknownFields);
+          }
+
+
+          // @@protoc_insertion_point(builder_scope:ru.inr.mass.data.proto.Point.Channel.Block)
+        }
+
+        // @@protoc_insertion_point(class_scope:ru.inr.mass.data.proto.Point.Channel.Block)
+        private static final ru.inr.mass.data.proto.NumassProto.Point.Channel.Block DEFAULT_INSTANCE;
+        static {
+          DEFAULT_INSTANCE = new ru.inr.mass.data.proto.NumassProto.Point.Channel.Block();
+        }
+
+        public static ru.inr.mass.data.proto.NumassProto.Point.Channel.Block getDefaultInstance() {
+          return DEFAULT_INSTANCE;
+        }
+
+        private static final com.google.protobuf.Parser<Block>
+            PARSER = new com.google.protobuf.AbstractParser<Block>() {
+          @java.lang.Override
+          public Block parsePartialFrom(
+              com.google.protobuf.CodedInputStream input,
+              com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+              throws com.google.protobuf.InvalidProtocolBufferException {
+            return new Block(input, extensionRegistry);
+          }
+        };
+
+        public static com.google.protobuf.Parser<Block> parser() {
+          return PARSER;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Parser<Block> getParserForType() {
+          return PARSER;
+        }
+
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block getDefaultInstanceForType() {
+          return DEFAULT_INSTANCE;
+        }
+
+      }
+
+      public static final int ID_FIELD_NUMBER = 1;
+      private long id_;
+      /**
+       * <pre>
+       * The number of measuring channel
+       * </pre>
+       *
+       * <code>uint64 id = 1;</code>
+       * @return The id.
+       */
+      @java.lang.Override
+      public long getId() {
+        return id_;
+      }
+
+      public static final int BLOCKS_FIELD_NUMBER = 2;
+      private java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block> blocks_;
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      @java.lang.Override
+      public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block> getBlocksList() {
+        return blocks_;
+      }
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      @java.lang.Override
+      public java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder> 
+          getBlocksOrBuilderList() {
+        return blocks_;
+      }
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      @java.lang.Override
+      public int getBlocksCount() {
+        return blocks_.size();
+      }
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      @java.lang.Override
+      public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block getBlocks(int index) {
+        return blocks_.get(index);
+      }
+      /**
+       * <pre>
+       * Blocks
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+       */
+      @java.lang.Override
+      public ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder getBlocksOrBuilder(
+          int index) {
+        return blocks_.get(index);
+      }
+
+      private byte memoizedIsInitialized = -1;
+      @java.lang.Override
+      public final boolean isInitialized() {
+        byte isInitialized = memoizedIsInitialized;
+        if (isInitialized == 1) return true;
+        if (isInitialized == 0) return false;
+
+        memoizedIsInitialized = 1;
+        return true;
+      }
+
+      @java.lang.Override
+      public void writeTo(com.google.protobuf.CodedOutputStream output)
+                          throws java.io.IOException {
+        if (id_ != 0L) {
+          output.writeUInt64(1, id_);
+        }
+        for (int i = 0; i < blocks_.size(); i++) {
+          output.writeMessage(2, blocks_.get(i));
+        }
+        unknownFields.writeTo(output);
+      }
+
+      @java.lang.Override
+      public int getSerializedSize() {
+        int size = memoizedSize;
+        if (size != -1) return size;
+
+        size = 0;
+        if (id_ != 0L) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeUInt64Size(1, id_);
+        }
+        for (int i = 0; i < blocks_.size(); i++) {
+          size += com.google.protobuf.CodedOutputStream
+            .computeMessageSize(2, blocks_.get(i));
+        }
+        size += unknownFields.getSerializedSize();
+        memoizedSize = size;
+        return size;
+      }
+
+      @java.lang.Override
+      public boolean equals(final java.lang.Object obj) {
+        if (obj == this) {
+         return true;
+        }
+        if (!(obj instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel)) {
+          return super.equals(obj);
+        }
+        ru.inr.mass.data.proto.NumassProto.Point.Channel other = (ru.inr.mass.data.proto.NumassProto.Point.Channel) obj;
+
+        if (getId()
+            != other.getId()) return false;
+        if (!getBlocksList()
+            .equals(other.getBlocksList())) return false;
+        if (!unknownFields.equals(other.unknownFields)) return false;
+        return true;
+      }
+
+      @java.lang.Override
+      public int hashCode() {
+        if (memoizedHashCode != 0) {
+          return memoizedHashCode;
+        }
+        int hash = 41;
+        hash = (19 * hash) + getDescriptor().hashCode();
+        hash = (37 * hash) + ID_FIELD_NUMBER;
+        hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
+            getId());
+        if (getBlocksCount() > 0) {
+          hash = (37 * hash) + BLOCKS_FIELD_NUMBER;
+          hash = (53 * hash) + getBlocksList().hashCode();
+        }
+        hash = (29 * hash) + unknownFields.hashCode();
+        memoizedHashCode = hash;
+        return hash;
+      }
+
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          java.nio.ByteBuffer data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          java.nio.ByteBuffer data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          com.google.protobuf.ByteString data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          com.google.protobuf.ByteString data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(byte[] data)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          byte[] data,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return PARSER.parseFrom(data, extensionRegistry);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseDelimitedFrom(java.io.InputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseDelimitedFrom(
+          java.io.InputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          com.google.protobuf.CodedInputStream input)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input);
+      }
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel parseFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        return com.google.protobuf.GeneratedMessageV3
+            .parseWithIOException(PARSER, input, extensionRegistry);
+      }
+
+      @java.lang.Override
+      public Builder newBuilderForType() { return newBuilder(); }
+      public static Builder newBuilder() {
+        return DEFAULT_INSTANCE.toBuilder();
+      }
+      public static Builder newBuilder(ru.inr.mass.data.proto.NumassProto.Point.Channel prototype) {
+        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+      }
+      @java.lang.Override
+      public Builder toBuilder() {
+        return this == DEFAULT_INSTANCE
+            ? new Builder() : new Builder().mergeFrom(this);
+      }
+
+      @java.lang.Override
+      protected Builder newBuilderForType(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        Builder builder = new Builder(parent);
+        return builder;
+      }
+      /**
+       * <pre>
+       * A single channel for multichannel detector readout
+       * </pre>
+       *
+       * Protobuf type {@code ru.inr.mass.data.proto.Point.Channel}
+       */
+      public static final class Builder extends
+          com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
+          // @@protoc_insertion_point(builder_implements:ru.inr.mass.data.proto.Point.Channel)
+          ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder {
+        public static final com.google.protobuf.Descriptors.Descriptor
+            getDescriptor() {
+          return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_descriptor;
+        }
+
+        @java.lang.Override
+        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+            internalGetFieldAccessorTable() {
+          return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_fieldAccessorTable
+              .ensureFieldAccessorsInitialized(
+                  ru.inr.mass.data.proto.NumassProto.Point.Channel.class, ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder.class);
+        }
+
+        // Construct using ru.inr.mass.data.proto.NumassProto.Point.Channel.newBuilder()
+        private Builder() {
+          maybeForceBuilderInitialization();
+        }
+
+        private Builder(
+            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+          super(parent);
+          maybeForceBuilderInitialization();
+        }
+        private void maybeForceBuilderInitialization() {
+          if (com.google.protobuf.GeneratedMessageV3
+                  .alwaysUseFieldBuilders) {
+            getBlocksFieldBuilder();
+          }
+        }
+        @java.lang.Override
+        public Builder clear() {
+          super.clear();
+          id_ = 0L;
+
+          if (blocksBuilder_ == null) {
+            blocks_ = java.util.Collections.emptyList();
+            bitField0_ = (bitField0_ & ~0x00000001);
+          } else {
+            blocksBuilder_.clear();
+          }
+          return this;
+        }
+
+        @java.lang.Override
+        public com.google.protobuf.Descriptors.Descriptor
+            getDescriptorForType() {
+          return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_Channel_descriptor;
+        }
+
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel getDefaultInstanceForType() {
+          return ru.inr.mass.data.proto.NumassProto.Point.Channel.getDefaultInstance();
+        }
+
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel build() {
+          ru.inr.mass.data.proto.NumassProto.Point.Channel result = buildPartial();
+          if (!result.isInitialized()) {
+            throw newUninitializedMessageException(result);
+          }
+          return result;
+        }
+
+        @java.lang.Override
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel buildPartial() {
+          ru.inr.mass.data.proto.NumassProto.Point.Channel result = new ru.inr.mass.data.proto.NumassProto.Point.Channel(this);
+          int from_bitField0_ = bitField0_;
+          result.id_ = id_;
+          if (blocksBuilder_ == null) {
+            if (((bitField0_ & 0x00000001) != 0)) {
+              blocks_ = java.util.Collections.unmodifiableList(blocks_);
+              bitField0_ = (bitField0_ & ~0x00000001);
+            }
+            result.blocks_ = blocks_;
+          } else {
+            result.blocks_ = blocksBuilder_.build();
+          }
+          onBuilt();
+          return result;
+        }
+
+        @java.lang.Override
+        public Builder clone() {
+          return super.clone();
+        }
+        @java.lang.Override
+        public Builder setField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.setField(field, value);
+        }
+        @java.lang.Override
+        public Builder clearField(
+            com.google.protobuf.Descriptors.FieldDescriptor field) {
+          return super.clearField(field);
+        }
+        @java.lang.Override
+        public Builder clearOneof(
+            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+          return super.clearOneof(oneof);
+        }
+        @java.lang.Override
+        public Builder setRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            int index, java.lang.Object value) {
+          return super.setRepeatedField(field, index, value);
+        }
+        @java.lang.Override
+        public Builder addRepeatedField(
+            com.google.protobuf.Descriptors.FieldDescriptor field,
+            java.lang.Object value) {
+          return super.addRepeatedField(field, value);
+        }
+        @java.lang.Override
+        public Builder mergeFrom(com.google.protobuf.Message other) {
+          if (other instanceof ru.inr.mass.data.proto.NumassProto.Point.Channel) {
+            return mergeFrom((ru.inr.mass.data.proto.NumassProto.Point.Channel)other);
+          } else {
+            super.mergeFrom(other);
+            return this;
+          }
+        }
+
+        public Builder mergeFrom(ru.inr.mass.data.proto.NumassProto.Point.Channel other) {
+          if (other == ru.inr.mass.data.proto.NumassProto.Point.Channel.getDefaultInstance()) return this;
+          if (other.getId() != 0L) {
+            setId(other.getId());
+          }
+          if (blocksBuilder_ == null) {
+            if (!other.blocks_.isEmpty()) {
+              if (blocks_.isEmpty()) {
+                blocks_ = other.blocks_;
+                bitField0_ = (bitField0_ & ~0x00000001);
+              } else {
+                ensureBlocksIsMutable();
+                blocks_.addAll(other.blocks_);
+              }
+              onChanged();
+            }
+          } else {
+            if (!other.blocks_.isEmpty()) {
+              if (blocksBuilder_.isEmpty()) {
+                blocksBuilder_.dispose();
+                blocksBuilder_ = null;
+                blocks_ = other.blocks_;
+                bitField0_ = (bitField0_ & ~0x00000001);
+                blocksBuilder_ = 
+                  com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+                     getBlocksFieldBuilder() : null;
+              } else {
+                blocksBuilder_.addAllMessages(other.blocks_);
+              }
+            }
+          }
+          this.mergeUnknownFields(other.unknownFields);
+          onChanged();
+          return this;
+        }
+
+        @java.lang.Override
+        public final boolean isInitialized() {
+          return true;
+        }
+
+        @java.lang.Override
+        public Builder mergeFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws java.io.IOException {
+          ru.inr.mass.data.proto.NumassProto.Point.Channel parsedMessage = null;
+          try {
+            parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            parsedMessage = (ru.inr.mass.data.proto.NumassProto.Point.Channel) e.getUnfinishedMessage();
+            throw e.unwrapIOException();
+          } finally {
+            if (parsedMessage != null) {
+              mergeFrom(parsedMessage);
+            }
+          }
+          return this;
+        }
+        private int bitField0_;
+
+        private long id_ ;
+        /**
+         * <pre>
+         * The number of measuring channel
+         * </pre>
+         *
+         * <code>uint64 id = 1;</code>
+         * @return The id.
+         */
+        @java.lang.Override
+        public long getId() {
+          return id_;
+        }
+        /**
+         * <pre>
+         * The number of measuring channel
+         * </pre>
+         *
+         * <code>uint64 id = 1;</code>
+         * @param value The id to set.
+         * @return This builder for chaining.
+         */
+        public Builder setId(long value) {
+          
+          id_ = value;
+          onChanged();
+          return this;
+        }
+        /**
+         * <pre>
+         * The number of measuring channel
+         * </pre>
+         *
+         * <code>uint64 id = 1;</code>
+         * @return This builder for chaining.
+         */
+        public Builder clearId() {
+          
+          id_ = 0L;
+          onChanged();
+          return this;
+        }
+
+        private java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block> blocks_ =
+          java.util.Collections.emptyList();
+        private void ensureBlocksIsMutable() {
+          if (!((bitField0_ & 0x00000001) != 0)) {
+            blocks_ = new java.util.ArrayList<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block>(blocks_);
+            bitField0_ |= 0x00000001;
+           }
+        }
+
+        private com.google.protobuf.RepeatedFieldBuilderV3<
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder> blocksBuilder_;
+
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block> getBlocksList() {
+          if (blocksBuilder_ == null) {
+            return java.util.Collections.unmodifiableList(blocks_);
+          } else {
+            return blocksBuilder_.getMessageList();
+          }
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public int getBlocksCount() {
+          if (blocksBuilder_ == null) {
+            return blocks_.size();
+          } else {
+            return blocksBuilder_.getCount();
+          }
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block getBlocks(int index) {
+          if (blocksBuilder_ == null) {
+            return blocks_.get(index);
+          } else {
+            return blocksBuilder_.getMessage(index);
+          }
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder setBlocks(
+            int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block value) {
+          if (blocksBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureBlocksIsMutable();
+            blocks_.set(index, value);
+            onChanged();
+          } else {
+            blocksBuilder_.setMessage(index, value);
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder setBlocks(
+            int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder builderForValue) {
+          if (blocksBuilder_ == null) {
+            ensureBlocksIsMutable();
+            blocks_.set(index, builderForValue.build());
+            onChanged();
+          } else {
+            blocksBuilder_.setMessage(index, builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder addBlocks(ru.inr.mass.data.proto.NumassProto.Point.Channel.Block value) {
+          if (blocksBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureBlocksIsMutable();
+            blocks_.add(value);
+            onChanged();
+          } else {
+            blocksBuilder_.addMessage(value);
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder addBlocks(
+            int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block value) {
+          if (blocksBuilder_ == null) {
+            if (value == null) {
+              throw new NullPointerException();
+            }
+            ensureBlocksIsMutable();
+            blocks_.add(index, value);
+            onChanged();
+          } else {
+            blocksBuilder_.addMessage(index, value);
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder addBlocks(
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder builderForValue) {
+          if (blocksBuilder_ == null) {
+            ensureBlocksIsMutable();
+            blocks_.add(builderForValue.build());
+            onChanged();
+          } else {
+            blocksBuilder_.addMessage(builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder addBlocks(
+            int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder builderForValue) {
+          if (blocksBuilder_ == null) {
+            ensureBlocksIsMutable();
+            blocks_.add(index, builderForValue.build());
+            onChanged();
+          } else {
+            blocksBuilder_.addMessage(index, builderForValue.build());
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder addAllBlocks(
+            java.lang.Iterable<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.Block> values) {
+          if (blocksBuilder_ == null) {
+            ensureBlocksIsMutable();
+            com.google.protobuf.AbstractMessageLite.Builder.addAll(
+                values, blocks_);
+            onChanged();
+          } else {
+            blocksBuilder_.addAllMessages(values);
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder clearBlocks() {
+          if (blocksBuilder_ == null) {
+            blocks_ = java.util.Collections.emptyList();
+            bitField0_ = (bitField0_ & ~0x00000001);
+            onChanged();
+          } else {
+            blocksBuilder_.clear();
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public Builder removeBlocks(int index) {
+          if (blocksBuilder_ == null) {
+            ensureBlocksIsMutable();
+            blocks_.remove(index);
+            onChanged();
+          } else {
+            blocksBuilder_.remove(index);
+          }
+          return this;
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder getBlocksBuilder(
+            int index) {
+          return getBlocksFieldBuilder().getBuilder(index);
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder getBlocksOrBuilder(
+            int index) {
+          if (blocksBuilder_ == null) {
+            return blocks_.get(index);  } else {
+            return blocksBuilder_.getMessageOrBuilder(index);
+          }
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder> 
+             getBlocksOrBuilderList() {
+          if (blocksBuilder_ != null) {
+            return blocksBuilder_.getMessageOrBuilderList();
+          } else {
+            return java.util.Collections.unmodifiableList(blocks_);
+          }
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder addBlocksBuilder() {
+          return getBlocksFieldBuilder().addBuilder(
+              ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.getDefaultInstance());
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder addBlocksBuilder(
+            int index) {
+          return getBlocksFieldBuilder().addBuilder(
+              index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.getDefaultInstance());
+        }
+        /**
+         * <pre>
+         * Blocks
+         * </pre>
+         *
+         * <code>repeated .ru.inr.mass.data.proto.Point.Channel.Block blocks = 2;</code>
+         */
+        public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder> 
+             getBlocksBuilderList() {
+          return getBlocksFieldBuilder().getBuilderList();
+        }
+        private com.google.protobuf.RepeatedFieldBuilderV3<
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.Block, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder> 
+            getBlocksFieldBuilder() {
+          if (blocksBuilder_ == null) {
+            blocksBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+                ru.inr.mass.data.proto.NumassProto.Point.Channel.Block, ru.inr.mass.data.proto.NumassProto.Point.Channel.Block.Builder, ru.inr.mass.data.proto.NumassProto.Point.Channel.BlockOrBuilder>(
+                    blocks_,
+                    ((bitField0_ & 0x00000001) != 0),
+                    getParentForChildren(),
+                    isClean());
+            blocks_ = null;
+          }
+          return blocksBuilder_;
+        }
+        @java.lang.Override
+        public final Builder setUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.setUnknownFields(unknownFields);
+        }
+
+        @java.lang.Override
+        public final Builder mergeUnknownFields(
+            final com.google.protobuf.UnknownFieldSet unknownFields) {
+          return super.mergeUnknownFields(unknownFields);
+        }
+
+
+        // @@protoc_insertion_point(builder_scope:ru.inr.mass.data.proto.Point.Channel)
+      }
+
+      // @@protoc_insertion_point(class_scope:ru.inr.mass.data.proto.Point.Channel)
+      private static final ru.inr.mass.data.proto.NumassProto.Point.Channel DEFAULT_INSTANCE;
+      static {
+        DEFAULT_INSTANCE = new ru.inr.mass.data.proto.NumassProto.Point.Channel();
+      }
+
+      public static ru.inr.mass.data.proto.NumassProto.Point.Channel getDefaultInstance() {
+        return DEFAULT_INSTANCE;
+      }
+
+      private static final com.google.protobuf.Parser<Channel>
+          PARSER = new com.google.protobuf.AbstractParser<Channel>() {
+        @java.lang.Override
+        public Channel parsePartialFrom(
+            com.google.protobuf.CodedInputStream input,
+            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+            throws com.google.protobuf.InvalidProtocolBufferException {
+          return new Channel(input, extensionRegistry);
+        }
+      };
+
+      public static com.google.protobuf.Parser<Channel> parser() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Parser<Channel> getParserForType() {
+        return PARSER;
+      }
+
+      @java.lang.Override
+      public ru.inr.mass.data.proto.NumassProto.Point.Channel getDefaultInstanceForType() {
+        return DEFAULT_INSTANCE;
+      }
+
+    }
+
+    public static final int CHANNELS_FIELD_NUMBER = 1;
+    private java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel> channels_;
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    @java.lang.Override
+    public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel> getChannelsList() {
+      return channels_;
+    }
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    @java.lang.Override
+    public java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder> 
+        getChannelsOrBuilderList() {
+      return channels_;
+    }
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    @java.lang.Override
+    public int getChannelsCount() {
+      return channels_.size();
+    }
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    @java.lang.Override
+    public ru.inr.mass.data.proto.NumassProto.Point.Channel getChannels(int index) {
+      return channels_.get(index);
+    }
+    /**
+     * <pre>
+     * Array of measuring channels
+     * </pre>
+     *
+     * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+     */
+    @java.lang.Override
+    public ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder getChannelsOrBuilder(
+        int index) {
+      return channels_.get(index);
+    }
+
+    private byte memoizedIsInitialized = -1;
+    @java.lang.Override
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized == 1) return true;
+      if (isInitialized == 0) return false;
+
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    @java.lang.Override
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      for (int i = 0; i < channels_.size(); i++) {
+        output.writeMessage(1, channels_.get(i));
+      }
+      unknownFields.writeTo(output);
+    }
+
+    @java.lang.Override
+    public int getSerializedSize() {
+      int size = memoizedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      for (int i = 0; i < channels_.size(); i++) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(1, channels_.get(i));
+      }
+      size += unknownFields.getSerializedSize();
+      memoizedSize = size;
+      return size;
+    }
+
+    @java.lang.Override
+    public boolean equals(final java.lang.Object obj) {
+      if (obj == this) {
+       return true;
+      }
+      if (!(obj instanceof ru.inr.mass.data.proto.NumassProto.Point)) {
+        return super.equals(obj);
+      }
+      ru.inr.mass.data.proto.NumassProto.Point other = (ru.inr.mass.data.proto.NumassProto.Point) obj;
+
+      if (!getChannelsList()
+          .equals(other.getChannelsList())) return false;
+      if (!unknownFields.equals(other.unknownFields)) return false;
+      return true;
+    }
+
+    @java.lang.Override
+    public int hashCode() {
+      if (memoizedHashCode != 0) {
+        return memoizedHashCode;
+      }
+      int hash = 41;
+      hash = (19 * hash) + getDescriptor().hashCode();
+      if (getChannelsCount() > 0) {
+        hash = (37 * hash) + CHANNELS_FIELD_NUMBER;
+        hash = (53 * hash) + getChannelsList().hashCode();
+      }
+      hash = (29 * hash) + unknownFields.hashCode();
+      memoizedHashCode = hash;
+      return hash;
+    }
+
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        java.nio.ByteBuffer data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        java.nio.ByteBuffer data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input);
+    }
+    public static ru.inr.mass.data.proto.NumassProto.Point parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return com.google.protobuf.GeneratedMessageV3
+          .parseWithIOException(PARSER, input, extensionRegistry);
+    }
+
+    @java.lang.Override
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder() {
+      return DEFAULT_INSTANCE.toBuilder();
+    }
+    public static Builder newBuilder(ru.inr.mass.data.proto.NumassProto.Point prototype) {
+      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
+    }
+    @java.lang.Override
+    public Builder toBuilder() {
+      return this == DEFAULT_INSTANCE
+          ? new Builder() : new Builder().mergeFrom(this);
+    }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code ru.inr.mass.data.proto.Point}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
+        // @@protoc_insertion_point(builder_implements:ru.inr.mass.data.proto.Point)
+        ru.inr.mass.data.proto.NumassProto.PointOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_descriptor;
+      }
+
+      @java.lang.Override
+      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                ru.inr.mass.data.proto.NumassProto.Point.class, ru.inr.mass.data.proto.NumassProto.Point.Builder.class);
+      }
+
+      // Construct using ru.inr.mass.data.proto.NumassProto.Point.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessageV3
+                .alwaysUseFieldBuilders) {
+          getChannelsFieldBuilder();
+        }
+      }
+      @java.lang.Override
+      public Builder clear() {
+        super.clear();
+        if (channelsBuilder_ == null) {
+          channels_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000001);
+        } else {
+          channelsBuilder_.clear();
+        }
+        return this;
+      }
+
+      @java.lang.Override
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return ru.inr.mass.data.proto.NumassProto.internal_static_ru_inr_mass_data_proto_Point_descriptor;
+      }
+
+      @java.lang.Override
+      public ru.inr.mass.data.proto.NumassProto.Point getDefaultInstanceForType() {
+        return ru.inr.mass.data.proto.NumassProto.Point.getDefaultInstance();
+      }
+
+      @java.lang.Override
+      public ru.inr.mass.data.proto.NumassProto.Point build() {
+        ru.inr.mass.data.proto.NumassProto.Point result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      @java.lang.Override
+      public ru.inr.mass.data.proto.NumassProto.Point buildPartial() {
+        ru.inr.mass.data.proto.NumassProto.Point result = new ru.inr.mass.data.proto.NumassProto.Point(this);
+        int from_bitField0_ = bitField0_;
+        if (channelsBuilder_ == null) {
+          if (((bitField0_ & 0x00000001) != 0)) {
+            channels_ = java.util.Collections.unmodifiableList(channels_);
+            bitField0_ = (bitField0_ & ~0x00000001);
+          }
+          result.channels_ = channels_;
+        } else {
+          result.channels_ = channelsBuilder_.build();
+        }
+        onBuilt();
+        return result;
+      }
+
+      @java.lang.Override
+      public Builder clone() {
+        return super.clone();
+      }
+      @java.lang.Override
+      public Builder setField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.setField(field, value);
+      }
+      @java.lang.Override
+      public Builder clearField(
+          com.google.protobuf.Descriptors.FieldDescriptor field) {
+        return super.clearField(field);
+      }
+      @java.lang.Override
+      public Builder clearOneof(
+          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
+        return super.clearOneof(oneof);
+      }
+      @java.lang.Override
+      public Builder setRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          int index, java.lang.Object value) {
+        return super.setRepeatedField(field, index, value);
+      }
+      @java.lang.Override
+      public Builder addRepeatedField(
+          com.google.protobuf.Descriptors.FieldDescriptor field,
+          java.lang.Object value) {
+        return super.addRepeatedField(field, value);
+      }
+      @java.lang.Override
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof ru.inr.mass.data.proto.NumassProto.Point) {
+          return mergeFrom((ru.inr.mass.data.proto.NumassProto.Point)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(ru.inr.mass.data.proto.NumassProto.Point other) {
+        if (other == ru.inr.mass.data.proto.NumassProto.Point.getDefaultInstance()) return this;
+        if (channelsBuilder_ == null) {
+          if (!other.channels_.isEmpty()) {
+            if (channels_.isEmpty()) {
+              channels_ = other.channels_;
+              bitField0_ = (bitField0_ & ~0x00000001);
+            } else {
+              ensureChannelsIsMutable();
+              channels_.addAll(other.channels_);
+            }
+            onChanged();
+          }
+        } else {
+          if (!other.channels_.isEmpty()) {
+            if (channelsBuilder_.isEmpty()) {
+              channelsBuilder_.dispose();
+              channelsBuilder_ = null;
+              channels_ = other.channels_;
+              bitField0_ = (bitField0_ & ~0x00000001);
+              channelsBuilder_ = 
+                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
+                   getChannelsFieldBuilder() : null;
+            } else {
+              channelsBuilder_.addAllMessages(other.channels_);
+            }
+          }
+        }
+        this.mergeUnknownFields(other.unknownFields);
+        onChanged();
+        return this;
+      }
+
+      @java.lang.Override
+      public final boolean isInitialized() {
+        return true;
+      }
+
+      @java.lang.Override
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        ru.inr.mass.data.proto.NumassProto.Point parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (ru.inr.mass.data.proto.NumassProto.Point) e.getUnfinishedMessage();
+          throw e.unwrapIOException();
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      private java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel> channels_ =
+        java.util.Collections.emptyList();
+      private void ensureChannelsIsMutable() {
+        if (!((bitField0_ & 0x00000001) != 0)) {
+          channels_ = new java.util.ArrayList<ru.inr.mass.data.proto.NumassProto.Point.Channel>(channels_);
+          bitField0_ |= 0x00000001;
+         }
+      }
+
+      private com.google.protobuf.RepeatedFieldBuilderV3<
+          ru.inr.mass.data.proto.NumassProto.Point.Channel, ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder, ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder> channelsBuilder_;
+
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel> getChannelsList() {
+        if (channelsBuilder_ == null) {
+          return java.util.Collections.unmodifiableList(channels_);
+        } else {
+          return channelsBuilder_.getMessageList();
+        }
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public int getChannelsCount() {
+        if (channelsBuilder_ == null) {
+          return channels_.size();
+        } else {
+          return channelsBuilder_.getCount();
+        }
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public ru.inr.mass.data.proto.NumassProto.Point.Channel getChannels(int index) {
+        if (channelsBuilder_ == null) {
+          return channels_.get(index);
+        } else {
+          return channelsBuilder_.getMessage(index);
+        }
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder setChannels(
+          int index, ru.inr.mass.data.proto.NumassProto.Point.Channel value) {
+        if (channelsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureChannelsIsMutable();
+          channels_.set(index, value);
+          onChanged();
+        } else {
+          channelsBuilder_.setMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder setChannels(
+          int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder builderForValue) {
+        if (channelsBuilder_ == null) {
+          ensureChannelsIsMutable();
+          channels_.set(index, builderForValue.build());
+          onChanged();
+        } else {
+          channelsBuilder_.setMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder addChannels(ru.inr.mass.data.proto.NumassProto.Point.Channel value) {
+        if (channelsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureChannelsIsMutable();
+          channels_.add(value);
+          onChanged();
+        } else {
+          channelsBuilder_.addMessage(value);
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder addChannels(
+          int index, ru.inr.mass.data.proto.NumassProto.Point.Channel value) {
+        if (channelsBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureChannelsIsMutable();
+          channels_.add(index, value);
+          onChanged();
+        } else {
+          channelsBuilder_.addMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder addChannels(
+          ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder builderForValue) {
+        if (channelsBuilder_ == null) {
+          ensureChannelsIsMutable();
+          channels_.add(builderForValue.build());
+          onChanged();
+        } else {
+          channelsBuilder_.addMessage(builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder addChannels(
+          int index, ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder builderForValue) {
+        if (channelsBuilder_ == null) {
+          ensureChannelsIsMutable();
+          channels_.add(index, builderForValue.build());
+          onChanged();
+        } else {
+          channelsBuilder_.addMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder addAllChannels(
+          java.lang.Iterable<? extends ru.inr.mass.data.proto.NumassProto.Point.Channel> values) {
+        if (channelsBuilder_ == null) {
+          ensureChannelsIsMutable();
+          com.google.protobuf.AbstractMessageLite.Builder.addAll(
+              values, channels_);
+          onChanged();
+        } else {
+          channelsBuilder_.addAllMessages(values);
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder clearChannels() {
+        if (channelsBuilder_ == null) {
+          channels_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000001);
+          onChanged();
+        } else {
+          channelsBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public Builder removeChannels(int index) {
+        if (channelsBuilder_ == null) {
+          ensureChannelsIsMutable();
+          channels_.remove(index);
+          onChanged();
+        } else {
+          channelsBuilder_.remove(index);
+        }
+        return this;
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder getChannelsBuilder(
+          int index) {
+        return getChannelsFieldBuilder().getBuilder(index);
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder getChannelsOrBuilder(
+          int index) {
+        if (channelsBuilder_ == null) {
+          return channels_.get(index);  } else {
+          return channelsBuilder_.getMessageOrBuilder(index);
+        }
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public java.util.List<? extends ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder> 
+           getChannelsOrBuilderList() {
+        if (channelsBuilder_ != null) {
+          return channelsBuilder_.getMessageOrBuilderList();
+        } else {
+          return java.util.Collections.unmodifiableList(channels_);
+        }
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder addChannelsBuilder() {
+        return getChannelsFieldBuilder().addBuilder(
+            ru.inr.mass.data.proto.NumassProto.Point.Channel.getDefaultInstance());
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder addChannelsBuilder(
+          int index) {
+        return getChannelsFieldBuilder().addBuilder(
+            index, ru.inr.mass.data.proto.NumassProto.Point.Channel.getDefaultInstance());
+      }
+      /**
+       * <pre>
+       * Array of measuring channels
+       * </pre>
+       *
+       * <code>repeated .ru.inr.mass.data.proto.Point.Channel channels = 1;</code>
+       */
+      public java.util.List<ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder> 
+           getChannelsBuilderList() {
+        return getChannelsFieldBuilder().getBuilderList();
+      }
+      private com.google.protobuf.RepeatedFieldBuilderV3<
+          ru.inr.mass.data.proto.NumassProto.Point.Channel, ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder, ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder> 
+          getChannelsFieldBuilder() {
+        if (channelsBuilder_ == null) {
+          channelsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
+              ru.inr.mass.data.proto.NumassProto.Point.Channel, ru.inr.mass.data.proto.NumassProto.Point.Channel.Builder, ru.inr.mass.data.proto.NumassProto.Point.ChannelOrBuilder>(
+                  channels_,
+                  ((bitField0_ & 0x00000001) != 0),
+                  getParentForChildren(),
+                  isClean());
+          channels_ = null;
+        }
+        return channelsBuilder_;
+      }
+      @java.lang.Override
+      public final Builder setUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.setUnknownFields(unknownFields);
+      }
+
+      @java.lang.Override
+      public final Builder mergeUnknownFields(
+          final com.google.protobuf.UnknownFieldSet unknownFields) {
+        return super.mergeUnknownFields(unknownFields);
+      }
+
+
+      // @@protoc_insertion_point(builder_scope:ru.inr.mass.data.proto.Point)
+    }
+
+    // @@protoc_insertion_point(class_scope:ru.inr.mass.data.proto.Point)
+    private static final ru.inr.mass.data.proto.NumassProto.Point DEFAULT_INSTANCE;
+    static {
+      DEFAULT_INSTANCE = new ru.inr.mass.data.proto.NumassProto.Point();
+    }
+
+    public static ru.inr.mass.data.proto.NumassProto.Point getDefaultInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    private static final com.google.protobuf.Parser<Point>
+        PARSER = new com.google.protobuf.AbstractParser<Point>() {
+      @java.lang.Override
+      public Point parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new Point(input, extensionRegistry);
+      }
+    };
+
+    public static com.google.protobuf.Parser<Point> parser() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<Point> getParserForType() {
+      return PARSER;
+    }
+
+    @java.lang.Override
+    public ru.inr.mass.data.proto.NumassProto.Point getDefaultInstanceForType() {
+      return DEFAULT_INSTANCE;
+    }
+
+  }
+
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_ru_inr_mass_data_proto_Point_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_ru_inr_mass_data_proto_Point_fieldAccessorTable;
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_ru_inr_mass_data_proto_Point_Channel_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_ru_inr_mass_data_proto_Point_Channel_fieldAccessorTable;
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_ru_inr_mass_data_proto_Point_Channel_Block_fieldAccessorTable;
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_fieldAccessorTable;
+  private static final com.google.protobuf.Descriptors.Descriptor
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_descriptor;
+  private static final 
+    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
+      internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_fieldAccessorTable;
+
+  public static com.google.protobuf.Descriptors.FileDescriptor
+      getDescriptor() {
+    return descriptor;
+  }
+  private static  com.google.protobuf.Descriptors.FileDescriptor
+      descriptor;
+  static {
+    java.lang.String[] descriptorData = {
+      "\n)ru/inr/mass/data/proto/numass-proto.pr" +
+      "oto\022\026ru.inr.mass.data.proto\"\250\003\n\005Point\0227\n" +
+      "\010channels\030\001 \003(\0132%.ru.inr.mass.data.proto" +
+      ".Point.Channel\032\345\002\n\007Channel\022\n\n\002id\030\001 \001(\004\022;" +
+      "\n\006blocks\030\002 \003(\0132+.ru.inr.mass.data.proto." +
+      "Point.Channel.Block\032\220\002\n\005Block\022\014\n\004time\030\001 " +
+      "\001(\004\022A\n\006frames\030\002 \003(\01321.ru.inr.mass.data.p" +
+      "roto.Point.Channel.Block.Frame\022B\n\006events" +
+      "\030\003 \001(\01322.ru.inr.mass.data.proto.Point.Ch" +
+      "annel.Block.Events\022\016\n\006length\030\004 \001(\004\022\020\n\010bi" +
+      "n_size\030\005 \001(\004\032#\n\005Frame\022\014\n\004time\030\001 \001(\004\022\014\n\004d" +
+      "ata\030\002 \001(\014\032+\n\006Events\022\r\n\005times\030\001 \003(\004\022\022\n\nam" +
+      "plitudes\030\002 \003(\004b\006proto3"
+    };
+    descriptor = com.google.protobuf.Descriptors.FileDescriptor
+      .internalBuildGeneratedFileFrom(descriptorData,
+        new com.google.protobuf.Descriptors.FileDescriptor[] {
+        });
+    internal_static_ru_inr_mass_data_proto_Point_descriptor =
+      getDescriptor().getMessageTypes().get(0);
+    internal_static_ru_inr_mass_data_proto_Point_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_ru_inr_mass_data_proto_Point_descriptor,
+        new java.lang.String[] { "Channels", });
+    internal_static_ru_inr_mass_data_proto_Point_Channel_descriptor =
+      internal_static_ru_inr_mass_data_proto_Point_descriptor.getNestedTypes().get(0);
+    internal_static_ru_inr_mass_data_proto_Point_Channel_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_ru_inr_mass_data_proto_Point_Channel_descriptor,
+        new java.lang.String[] { "Id", "Blocks", });
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor =
+      internal_static_ru_inr_mass_data_proto_Point_Channel_descriptor.getNestedTypes().get(0);
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor,
+        new java.lang.String[] { "Time", "Frames", "Events", "Length", "BinSize", });
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_descriptor =
+      internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor.getNestedTypes().get(0);
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Frame_descriptor,
+        new java.lang.String[] { "Time", "Data", });
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_descriptor =
+      internal_static_ru_inr_mass_data_proto_Point_Channel_Block_descriptor.getNestedTypes().get(1);
+    internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_fieldAccessorTable = new
+      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
+        internal_static_ru_inr_mass_data_proto_Point_Channel_Block_Events_descriptor,
+        new java.lang.String[] { "Times", "Amplitudes", });
+  }
+
+  // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassEnvelopeType.kt b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassEnvelopeType.kt
new file mode 100644
index 0000000..2fa3e35
--- /dev/null
+++ b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassEnvelopeType.kt
@@ -0,0 +1,139 @@
+///*
+// * Copyright  2018 Alexander Nozik.
+// *
+// * 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
+// *
+// *  Unless required by applicable law or agreed to in writing, software
+// *  distributed under the License is distributed on an "AS IS" BASIS,
+// *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// *  See the License for the specific language governing permissions and
+// *  limitations under the License.
+// */
+//
+//package ru.inr.mass.data.proto
+//
+//import hep.dataforge.io.envelopes.*
+//import hep.dataforge.values.Value
+//import org.slf4j.LoggerFactory
+//import java.io.IOException
+//import java.nio.ByteBuffer
+//import java.nio.channels.FileChannel
+//import java.nio.file.Path
+//import java.nio.file.StandardOpenOption
+//import java.util.*
+//
+///**
+// * An envelope type for legacy numass tags. Reads legacy tag and writes DF02 tags
+// */
+//class NumassEnvelopeType : EnvelopeType {
+//
+//    override val code: Int = DefaultEnvelopeType.DEFAULT_ENVELOPE_CODE
+//
+//    override val name: String = "numass"
+//
+//    override fun description(): String = "Numass legacy envelope"
+//
+//    /**
+//     * Read as legacy
+//     */
+//    override fun getReader(properties: Map<String, String>): EnvelopeReader {
+//        return NumassEnvelopeReader()
+//    }
+//
+//    /**
+//     * Write as default
+//     */
+//    override fun getWriter(properties: Map<String, String>): EnvelopeWriter {
+//        return DefaultEnvelopeWriter(this, MetaType.resolve(properties))
+//    }
+//
+//    class LegacyTag : EnvelopeTag() {
+//        override val startSequence: ByteArray
+//            get() = LEGACY_START_SEQUENCE
+//
+//        override val endSequence: ByteArray
+//            get() = LEGACY_END_SEQUENCE
+//
+//        /**
+//         * Get the length of tag in bytes. -1 means undefined size in case tag was modified
+//         *
+//         * @return
+//         */
+//        override val length: Int
+//            get() = 30
+//
+//        /**
+//         * Read leagscy version 1 tag without leading tag head
+//         *
+//         * @param buffer
+//         * @return
+//         * @throws IOException
+//         */
+//        override fun readHeader(buffer: ByteBuffer): Map<String, Value> {
+//            val res = HashMap<String, Value>()
+//
+//            val type = buffer.getInt(2)
+//            res[Envelope.TYPE_PROPERTY] = Value.of(type)
+//
+//            val metaTypeCode = buffer.getShort(10)
+//            val metaType = MetaType.resolve(metaTypeCode)
+//
+//            if (metaType != null) {
+//                res[Envelope.META_TYPE_PROPERTY] = metaType.name.parseValue()
+//            } else {
+//                LoggerFactory.getLogger(EnvelopeTag::class.java).warn("Could not resolve meta type. Using default")
+//            }
+//
+//            val metaLength = Integer.toUnsignedLong(buffer.getInt(14))
+//            res[Envelope.META_LENGTH_PROPERTY] = Value.of(metaLength)
+//            val dataLength = Integer.toUnsignedLong(buffer.getInt(22))
+//            res[Envelope.DATA_LENGTH_PROPERTY] = Value.of(dataLength)
+//            return res
+//        }
+//    }
+//
+//    private class NumassEnvelopeReader : DefaultEnvelopeReader() {
+//        override fun newTag(): EnvelopeTag {
+//            return LegacyTag()
+//        }
+//    }
+//
+//    companion object {
+//        val INSTANCE = NumassEnvelopeType()
+//
+//        val LEGACY_START_SEQUENCE = byteArrayOf('#'.toByte(), '!'.toByte())
+//        val LEGACY_END_SEQUENCE = byteArrayOf('!'.toByte(), '#'.toByte(), '\r'.toByte(), '\n'.toByte())
+//
+//        /**
+//         * Replacement for standard type infer to include legacy type
+//         *
+//         * @param path
+//         * @return
+//         */
+//        fun infer(path: Path): EnvelopeType? {
+//            return try {
+//                FileChannel.open(path, StandardOpenOption.READ).use {
+//                    val buffer = it.map(FileChannel.MapMode.READ_ONLY, 0, 6)
+//                    when {
+//                        //TODO use templates from appropriate types
+//                        buffer.get(0) == '#'.toByte() && buffer.get(1) == '!'.toByte() -> INSTANCE
+//                        buffer.get(0) == '#'.toByte() && buffer.get(1) == '!'.toByte() &&
+//                                buffer.get(4) == 'T'.toByte() && buffer.get(5) == 'L'.toByte() -> TaglessEnvelopeType.INSTANCE
+//                        buffer.get(0) == '#'.toByte() && buffer.get(1) == '~'.toByte() -> DefaultEnvelopeType.INSTANCE
+//                        else -> null
+//                    }
+//                }
+//            } catch (ex: Exception) {
+//                LoggerFactory.getLogger(EnvelopeType::class.java).warn("Could not infer envelope type of file {} due to exception: {}", path, ex)
+//                null
+//            }
+//
+//        }
+//
+//    }
+//
+//}
diff --git a/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassFileEnvelope.kt b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassFileEnvelope.kt
new file mode 100644
index 0000000..d88ef0e
--- /dev/null
+++ b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassFileEnvelope.kt
@@ -0,0 +1,52 @@
+///*
+// * Copyright  2018 Alexander Nozik.
+// *
+// * 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
+// *
+// *  Unless required by applicable law or agreed to in writing, software
+// *  distributed under the License is distributed on an "AS IS" BASIS,
+// *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// *  See the License for the specific language governing permissions and
+// *  limitations under the License.
+// */
+//
+//package ru.inr.mass.data.proto
+//
+//import hep.dataforge.meta.Meta
+//import hep.dataforge.storage.files.MutableFileEnvelope
+//import java.nio.ByteBuffer
+//import java.nio.file.Files
+//import java.nio.file.Path
+//import java.nio.file.StandardOpenOption
+//
+//class NumassFileEnvelope(path: Path) : MutableFileEnvelope(path) {
+//
+//    private val tag by lazy { Files.newByteChannel(path, StandardOpenOption.READ).use { NumassEnvelopeType.LegacyTag().read(it) } }
+//
+//    override val dataOffset: Long by lazy { (tag.length + tag.metaSize).toLong() }
+//
+//    override var dataLength: Int
+//        get() = tag.dataSize
+//        set(value) {
+//            if (value > Int.MAX_VALUE) {
+//                throw RuntimeException("Too large data block")
+//            }
+//            tag.dataSize = value
+//            if (channel.write(tag.toBytes(), 0L) < tag.length) {
+//                throw error("Tag is not overwritten.")
+//            }
+//        }
+//
+//
+//    override val meta: Meta by lazy {
+//        val buffer = ByteBuffer.allocate(tag.metaSize).also {
+//            channel.read(it, tag.length.toLong())
+//        }
+//        tag.metaType.reader.readBuffer(buffer)
+//    }
+//}
+//
diff --git a/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassProtoPlugin.kt b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassProtoPlugin.kt
new file mode 100644
index 0000000..00d16b6
--- /dev/null
+++ b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/NumassProtoPlugin.kt
@@ -0,0 +1,20 @@
+package ru.inr.mass.data.proto
+
+import hep.dataforge.context.AbstractPlugin
+import hep.dataforge.context.Context
+import hep.dataforge.context.PluginFactory
+import hep.dataforge.context.PluginTag
+import hep.dataforge.io.IOPlugin
+import hep.dataforge.meta.Meta
+import kotlin.reflect.KClass
+
+public class NumassProtoPlugin : AbstractPlugin() {
+    val io by require(IOPlugin)
+    override val tag: PluginTag get() = Companion.tag
+
+    public companion object : PluginFactory<NumassProtoPlugin> {
+        override fun invoke(meta: Meta, context: Context): NumassProtoPlugin = NumassProtoPlugin()
+        override val tag: PluginTag = PluginTag("numass-proto", group = "ru.inr.mass")
+        override val type: KClass<out NumassProtoPlugin> = NumassProtoPlugin::class
+    }
+}
\ No newline at end of file
diff --git a/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/ProtoNumassPoint.kt b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/ProtoNumassPoint.kt
new file mode 100644
index 0000000..761666c
--- /dev/null
+++ b/numass-data-proto/src/main/kotlin/ru/inr/mass/data/proto/ProtoNumassPoint.kt
@@ -0,0 +1,180 @@
+/*
+ * Copyright  2018 Alexander Nozik.
+ *
+ * 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
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package ru.inr.mass.data.proto
+
+import hep.dataforge.context.Context
+import hep.dataforge.io.Envelope
+import hep.dataforge.io.io
+import hep.dataforge.io.readEnvelopeFile
+import hep.dataforge.meta.*
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.runBlocking
+import kotlinx.io.asInputStream
+import kotlinx.io.readByteArray
+import org.slf4j.LoggerFactory
+import ru.inr.mass.data.api.*
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.InputStream
+import java.nio.file.Path
+import java.time.Duration
+import java.time.Instant
+import java.util.zip.Inflater
+
+/**
+ * Protobuf based numass point
+ * Created by Alexander Nozik on 09.07.2017.
+ */
+public class ProtoNumassPoint(
+    override val meta: Meta,
+    private val protoBuilder: () -> NumassProto.Point,
+) : NumassPoint {
+
+    private val proto: NumassProto.Point get() = protoBuilder()
+
+    override val blocks: List<NumassBlock>
+        get() = proto.channelsList
+            .flatMap { channel ->
+                channel.blocksList
+                    .map { block -> ProtoBlock(channel.id.toInt(), block, this) }
+                    .sortedBy { it.startTime }
+            }
+
+    override val channels: Map<Int, NumassBlock>
+        get() = proto.channelsList.groupBy { it.id.toInt() }.mapValues { entry ->
+            MetaBlock(entry.value.flatMap { it.blocksList }.map { ProtoBlock(entry.key, it, this) })
+        }
+
+    override val voltage: Double get() = meta["external_meta.HV1_value"].double ?: super.voltage
+
+    override val index: Int get() = meta["external_meta.point_index"].int ?: super.index
+
+    override val startTime: Instant
+        get() = meta["start_time"].long?.let {
+            Instant.ofEpochMilli(it)
+        } ?: super.startTime
+
+    override val length: Duration
+        get() = meta["acquisition_time"].double?.let {
+            Duration.ofMillis((it * 1000).toLong())
+        } ?: super.length
+
+
+    public companion object {
+
+
+        /**
+         * Get valid data stream utilizing compression if it is present
+         */
+        private fun <R> Envelope.useData(block: (InputStream) -> R): R? = when {
+            data == null -> null
+            meta["compression"].string == "zlib" -> {
+                //TODO move to new type of data
+                val inflater = Inflater()
+
+                val array: ByteArray = data?.read {
+                    readByteArray()
+                } ?: ByteArray(0)
+
+                inflater.setInput(array)
+                val bos = ByteArrayOutputStream()
+                val buffer = ByteArray(8192)
+                while (!inflater.finished()) {
+                    val size = inflater.inflate(buffer)
+                    bos.write(buffer, 0, size)
+                }
+                val unzippeddata = bos.toByteArray()
+                inflater.end()
+                ByteArrayInputStream(unzippeddata).use(block)
+            }
+            else -> {
+                data?.read {
+                    block(asInputStream())
+                }
+            }
+        }
+
+        public fun fromEnvelope(envelope: Envelope): ProtoNumassPoint? {
+            val proto = envelope.useData {
+                NumassProto.Point.parseFrom(it)
+            }
+            return proto?.let { ProtoNumassPoint(envelope.meta) { it } }
+        }
+
+        public fun fromFile(context: Context, path: Path): ProtoNumassPoint? {
+            val envelope = context.io.readEnvelopeFile(path) ?: error("Envelope could not be read from $path")
+            return fromEnvelope(envelope)
+        }
+
+        public fun fromFile(context: Context, path: String): ProtoNumassPoint? {
+            return fromFile(context,Path.of(path))
+        }
+
+        public fun ofEpochNanos(nanos: Long): Instant {
+            val seconds = Math.floorDiv(nanos, 1e9.toInt().toLong())
+            val reminder = (nanos % 1e9).toInt()
+            return Instant.ofEpochSecond(seconds, reminder.toLong())
+        }
+    }
+}
+
+public class ProtoBlock(
+    override val channel: Int,
+    private val block: NumassProto.Point.Channel.Block,
+    public val parent: NumassPoint? = null,
+) : NumassBlock {
+
+    override val startTime: Instant
+        get() = ProtoNumassPoint.ofEpochNanos(block.time)
+
+    override val length: Duration = when {
+        block.length > 0 -> Duration.ofNanos(block.length)
+        parent?.meta["acquisition_time"] != null ->
+            Duration.ofMillis((parent?.meta["acquisition_time"].double ?: 0.0 * 1000).toLong())
+        else -> {
+            LoggerFactory.getLogger(javaClass)
+                .error("No length information on block. Trying to infer from first and last events")
+            val times = runBlocking { events.map { it.timeOffset }.toList() }
+            val nanos = (times.maxOrNull()!! - times.minOrNull()!!)
+            Duration.ofNanos(nanos)
+        }
+    }
+
+    override val events: Flow<NumassEvent>
+        get() = if (block.hasEvents()) {
+            val events = block.events
+            if (events.timesCount != events.amplitudesCount) {
+                LoggerFactory.getLogger(javaClass)
+                    .error("The block is broken. Number of times is ${events.timesCount} and number of amplitudes is ${events.amplitudesCount}")
+            }
+            (0..events.timesCount).asFlow()
+                .map { i -> NumassEvent(events.getAmplitudes(i).toShort(), events.getTimes(i), this) }
+        } else {
+            emptyFlow<NumassEvent>()
+        }
+
+
+    override val frames: Flow<NumassFrame>
+        get() {
+            val tickSize = Duration.ofNanos(block.binSize)
+            return block.framesList.asFlow().map { frame ->
+                val time = startTime.plusNanos(frame.time)
+                val frameData = frame.data.asReadOnlyByteBuffer()
+                NumassFrame(time, tickSize, frameData.asShortBuffer())
+            }
+        }
+}
\ No newline at end of file
diff --git a/numass-data-proto/src/main/proto/ru/inr/mass/data/proto/numass-proto.proto b/numass-data-proto/src/main/proto/ru/inr/mass/data/proto/numass-proto.proto
new file mode 100644
index 0000000..923d6b9
--- /dev/null
+++ b/numass-data-proto/src/main/proto/ru/inr/mass/data/proto/numass-proto.proto
@@ -0,0 +1,33 @@
+syntax = "proto3";
+
+package ru.inr.mass.data.proto;
+
+message Point {
+    // A single channel for multichannel detector readout
+    message Channel {
+        //A continuous measurement block
+        message Block {
+            // Raw data frame
+            message Frame {
+                uint64 time = 1; // Time in nanos from the beginning of the block
+                bytes data = 2; // Frame data as an array of int16 mesured in arbitrary channels
+            }
+            // Event block obtained directly from  device of from frame analysis
+            // In order to save space, times and amplitudes are in separate arrays.
+            // Amplitude and time with the same index correspond to the same event
+            message Events {
+                repeated uint64 times = 1; // Array of time in nanos from the beginning of the block
+                repeated uint64 amplitudes = 2; // Array of amplitudes of events in channels
+            }
+
+            uint64 time = 1; // Block start in epoch nanos
+            repeated Frame frames = 2; // Frames array
+            Events events = 3; // Events array
+            uint64 length = 4; // block size in nanos. If missing, take from meta.
+            uint64 bin_size = 5;  // tick size in nanos. Obsolete, to be removed
+        }
+        uint64 id = 1; // The number of measuring channel
+        repeated Block blocks = 2; // Blocks
+    }
+    repeated Channel channels = 1; // Array of measuring channels
+}
\ No newline at end of file
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 0000000..5caafe0
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,28 @@
+pluginManagement {
+    repositories {
+        mavenLocal()
+        jcenter()
+        gradlePluginPortal()
+        maven("https://dl.bintray.com/kotlin/kotlin-eap")
+        maven("https://dl.bintray.com/kotlin/kotlin-dev")
+        maven("https://dl.bintray.com/mipt-npm/dataforge")
+        maven("https://dl.bintray.com/mipt-npm/kscience")
+        maven("https://dl.bintray.com/mipt-npm/dev")
+    }
+
+    val toolsVersion = "0.7.1"
+    val kotlinVersion = "1.4.21"
+
+    plugins {
+        id("ru.mipt.npm.project") version toolsVersion
+        id("ru.mipt.npm.mpp") version toolsVersion
+        id("ru.mipt.npm.jvm") version toolsVersion
+        id("ru.mipt.npm.js") version toolsVersion
+        id("ru.mipt.npm.publish") version toolsVersion
+        kotlin("jvm") version kotlinVersion
+        kotlin("js") version kotlinVersion
+    }
+}
+
+include("numass-data-model")
+include("numass-data-proto")