<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _unpack_body(self, buff):
 """ Parse the response body. After body unpacking its data available as python list of tuples For each request type the response body has the same format: <insert_response_body> ::= <count> | <count><fq_tuple> <update_response_body> ::= <count> | <count><fq_tuple> <delete_response_body> ::= <count> | <count><fq_tuple> <select_response_body> ::= <count><fq_tuple>* <call_response_body> ::= <count><fq_tuple> :param buff: buffer containing request body :type byff: ctypes buffer """


        # Unpack <return_code> and <count> (how many records affected or selected)
        self._return_code = struct_L.unpack_from(buff, offset=0)[0]

        # Separate return_code and completion_code
        self._completion_status = self._return_code & 0x00ff
        self._return_code >>= 8

        # In case of an error unpack the body as an error message
        if self._return_code != 0:
            self._return_message = unicode(buff[4:-1], self.charset, self.errors)
            if self._completion_status == 2:
                raise TarantoolError(self._return_code, self._return_message)

        # Unpack <count> (how many records affected or selected)
        self._rowcount = struct_L.unpack_from(buff, offset=4)[0]

        # If the response doesn't contain any tuple - there is nothing to unpack
        if self._body_length == 8:
            return

        # Parse response tuples (<fq_tuple>)
        if self._rowcount > 0:
            offset = 8    # The first 4 bytes in the response body is the <count> we have already read
            while offset < self._body_length:
                # In resonse tuples have the form <size><tuple> (<fq_tuple> ::= <size><tuple>).
                # Attribute <size> takes into account only size of tuple's <field> payload,
                # but does not include 4-byte of <cardinality> field.
                #Therefore the actual size of the <tuple> is greater to 4 bytes.
                tuple_size = struct.unpack_from("<L", buff, offset)[0] + 4
                tuple_data = struct.unpack_from("<%ds" % (tuple_size), buff, offset+4)[0]
                tuple_value = self._unpack_tuple(tuple_data)
                if self.field_types:
                    self.append(self._cast_tuple(tuple_value))
                else:
                    self.append(tuple_value)

                offset = offset + tuple_size + 4