text:
package org.lwjgl.vulkan.video;

import javax.annotation.*;

import java.nio.*;

import org.lwjgl.*;
import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.MemoryUtil.*;
import static org.lwjgl.system.MemoryStack.*;

import static org.lwjgl.vulkan.video.STDVulkanVideoCodecH265.*;

/**
 *
Layout

 *
 *

 * struct StdVideoH265PictureParameterSet {
 *     {@link StdVideoH265PpsFlags StdVideoH265PpsFlags} flags;
 *     uint8_t pps_pic_parameter_set_id;
 *     uint8_t pps_seq_parameter_set_id;
 *     uint8_t sps_video_parameter_set_id;
 *     uint8_t num_extra_slice_header_bits;
 *     uint8_t num_ref_idx_l0_default_active_minus1;
 *     uint8_t num_ref_idx_l1_default_active_minus1;
 *     int8_t init_qp_minus26;
 *     uint8_t diff_cu_qp_delta_depth;
 *     int8_t pps_cb_qp_offset;
 *     int8_t pps_cr_qp_offset;
 *     int8_t pps_beta_offset_div2;
 *     int8_t pps_tc_offset_div2;
 *     uint8_t log2_parallel_merge_level_minus2;
 *     uint8_t {@link #log2_max_transform_skip_block_size_minus2};
 *     uint8_t diff_cu_chroma_qp_offset_depth;
 *     uint8_t chroma_qp_offset_list_len_minus1;
 *     int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
 *     int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
 *     uint8_t log2_sao_offset_scale_luma;
 *     uint8_t log2_sao_offset_scale_chroma;
 *     int8_t {@link #pps_act_y_qp_offset_plus5};
 *     int8_t pps_act_cb_qp_offset_plus5;
 *     int8_t pps_act_cr_qp_offset_plus3;
 *     uint8_t pps_num_palette_predictor_initializers;
 *     uint8_t luma_bit_depth_entry_minus8;
 *     uint8_t chroma_bit_depth_entry_minus8;
 *     uint8_t num_tile_columns_minus1;
 *     uint8_t num_tile_rows_minus1;
 *     uint8_t reserved1;
 *     uint8_t reserved2;
 *     uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE];
 *     uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE];
 *     uint32_t reserved3;
 *     {@link StdVideoH265ScalingLists StdVideoH265ScalingLists} const * {@link #pScalingLists};
 *     {@link StdVideoH265PredictorPaletteEntries StdVideoH265PredictorPaletteEntries} const * {@link #pPredictorPaletteEntries};
 * }

 */
public class StdVideoH265PictureParameterSet extends Struct implements NativeResource {

    /** The struct size in bytes. */
    public static final int SIZEOF;

    /** The struct alignment in bytes. */
    public static final int ALIGNOF;

    /** The struct member offsets. */
    public static final int
        FLAGS,
        PPS_PIC_PARAMETER_SET_ID,
        PPS_SEQ_PARAMETER_SET_ID,
        SPS_VIDEO_PARAMETER_SET_ID,
        NUM_EXTRA_SLICE_HEADER_BITS,
        NUM_REF_IDX_L0_DEFAULT_ACTIVE_MINUS1,
        NUM_REF_IDX_L1_DEFAULT_ACTIVE_MINUS1,
        INIT_QP_MINUS26,
        DIFF_CU_QP_DELTA_DEPTH,
        PPS_CB_QP_OFFSET,
        PPS_CR_QP_OFFSET,
        PPS_BETA_OFFSET_DIV2,
        PPS_TC_OFFSET_DIV2,
        LOG2_PARALLEL_MERGE_LEVEL_MINUS2,
        LOG2_MAX_TRANSFORM_SKIP_BLOCK_SIZE_MINUS2,
        DIFF_CU_CHROMA_QP_OFFSET_DEPTH,
        CHROMA_QP_OFFSET_LIST_LEN_MINUS1,
        CB_QP_OFFSET_LIST,
        CR_QP_OFFSET_LIST,
        LOG2_SAO_OFFSET_SCALE_LUMA,
        LOG2_SAO_OFFSET_SCALE_CHROMA,
        PPS_ACT_Y_QP_OFFSET_PLUS5,
        PPS_ACT_CB_QP_OFFSET_PLUS5,
        PPS_ACT_CR_QP_OFFSET_PLUS3,
        PPS_NUM_PALETTE_PREDICTOR_INITIALIZERS,
        LUMA_BIT_DEPTH_ENTRY_MINUS8,
        CHROMA_BIT_DEPTH_ENTRY_MINUS8,
        NUM_TILE_COLUMNS_MINUS1,
        NUM_TILE_ROWS_MINUS1,
        RESERVED1,
        RESERVED2,
        COLUMN_WIDTH_MINUS1,
        ROW_HEIGHT_MINUS1,
        RESERVED3,
        PSCALINGLISTS,
        PPREDICTORPALETTEENTRIES;

    static {
        Layout layout = __struct(
            __member(StdVideoH265PpsFlags.SIZEOF, StdVideoH265PpsFlags.ALIGNOF),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __array(1, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE),
            __array(1, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __member(1),
            __array(2, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE),
            __array(2, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE),
            __member(4),
            __member(POINTER_SIZE),
            __member(POINTER_SIZE)
        );

        SIZEOF = layout.getSize();
        ALIGNOF = layout.getAlignment();

        FLAGS = layout.offsetof(0);
        PPS_PIC_PARAMETER_SET_ID = layout.offsetof(1);
        PPS_SEQ_PARAMETER_SET_ID = layout.offsetof(2);
        SPS_VIDEO_PARAMETER_SET_ID = layout.offsetof(3);
        NUM_EXTRA_SLICE_HEADER_BITS = layout.offsetof(4);
        NUM_REF_IDX_L0_DEFAULT_ACTIVE_MINUS1 = layout.offsetof(5);
        NUM_REF_IDX_L1_DEFAULT_ACTIVE_MINUS1 = layout.offsetof(6);
        INIT_QP_MINUS26 = layout.offsetof(7);
        DIFF_CU_QP_DELTA_DEPTH = layout.offsetof(8);
        PPS_CB_QP_OFFSET = layout.offsetof(9);
        PPS_CR_QP_OFFSET = layout.offsetof(10);
        PPS_BETA_OFFSET_DIV2 = layout.offsetof(11);
        PPS_TC_OFFSET_DIV2 = layout.offsetof(12);
        LOG2_PARALLEL_MERGE_LEVEL_MINUS2 = layout.offsetof(13);
        LOG2_MAX_TRANSFORM_SKIP_BLOCK_SIZE_MINUS2 = layout.offsetof(14);
        DIFF_CU_CHROMA_QP_OFFSET_DEPTH = layout.offsetof(15);
        CHROMA_QP_OFFSET_LIST_LEN_MINUS1 = layout.offsetof(16);
        CB_QP_OFFSET_LIST = layout.offsetof(17);
        CR_QP_OFFSET_LIST = layout.offsetof(18);
        LOG2_SAO_OFFSET_SCALE_LUMA = layout.offsetof(19);
        LOG2_SAO_OFFSET_SCALE_CHROMA = layout.offsetof(20);
        PPS_ACT_Y_QP_OFFSET_PLUS5 = layout.offsetof(21);
        PPS_ACT_CB_QP_OFFSET_PLUS5 = layout.offsetof(22);
        PPS_ACT_CR_QP_OFFSET_PLUS3 = layout.offsetof(23);
        PPS_NUM_PALETTE_PREDICTOR_INITIALIZERS = layout.offsetof(24);
        LUMA_BIT_DEPTH_ENTRY_MINUS8 = layout.offsetof(25);
        CHROMA_BIT_DEPTH_ENTRY_MINUS8 = layout.offsetof(26);
        NUM_TILE_COLUMNS_MINUS1 = layout.offsetof(27);
        NUM_TILE_ROWS_MINUS1 = layout.offsetof(28);
        RESERVED1 = layout.offsetof(29);
        RESERVED2 = layout.offsetof(30);
        COLUMN_WIDTH_MINUS1 = layout.offsetof(31);
        ROW_HEIGHT_MINUS1 = layout.offsetof(32);
        RESERVED3 = layout.offsetof(33);
        PSCALINGLISTS = layout.offsetof(34);
        PPREDICTORPALETTEENTRIES = layout.offsetof(35);
    }

    /**
     * Creates a {@code StdVideoH265PictureParameterSet} instance at the current position of the specified {@link ByteBuffer} container. Changes to the buffer's content will be
     * visible to the struct instance and vice versa.
     *
     *
The created instance holds a strong reference to the container object.

     */
    public StdVideoH265PictureParameterSet(ByteBuffer container) {
        super(memAddress(container), __checkContainer(container, SIZEOF));
    }

    @Override
    public int sizeof() { return SIZEOF; }

    /** @return a {@link StdVideoH265PpsFlags} view of the {@code flags} field. */
    public StdVideoH265PpsFlags flags() { return nflags(address()); }
    /** @return the value of the {@code pps_pic_parameter_set_id} field. */
    @NativeType("uint8_t")
    public byte pps_pic_parameter_set_id() { return npps_pic_parameter_set_id(address()); }
    /** @return the value of the {@code pps_seq_parameter_set_id} field. */
    @NativeType("uint8_t")
    public byte pps_seq_parameter_set_id() { return npps_seq_parameter_set_id(address()); }
    /** @return the value of the {@code sps_video_parameter_set_id} field. */
    @NativeType("uint8_t")
    public byte sps_video_parameter_set_id() { return nsps_video_parameter_set_id(address()); }
    /** @return the value of the {@code num_extra_slice_header_bits} field. */
    @NativeType("uint8_t")
    public byte num_extra_slice_header_bits() { return nnum_extra_slice_header_bits(address()); }
    /** @return the value of the {@code num_ref_idx_l0_default_active_minus1} field. */
    @NativeType("uint8_t")
    public byte num_ref_idx_l0_default_active_minus1() { return nnum_ref_idx_l0_default_active_minus1(address()); }
    /** @return the value of the {@code num_ref_idx_l1_default_active_minus1} field. */
    @NativeType("uint8_t")
    public byte num_ref_idx_l1_default_active_minus1() { return nnum_ref_idx_l1_default_active_minus1(address()); }
    /** @return the value of the {@code init_qp_minus26} field. */
    @NativeType("int8_t")
    public byte init_qp_minus26() { return ninit_qp_minus26(address()); }
    /** @return the value of the {@code diff_cu_qp_delta_depth} field. */
    @NativeType("uint8_t")
    public byte diff_cu_qp_delta_depth() { return ndiff_cu_qp_delta_depth(address()); }
    /** @return the value of the {@code pps_cb_qp_offset} field. */
    @NativeType("int8_t")
    public byte pps_cb_qp_offset() { return npps_cb_qp_offset(address()); }
    /** @return the value of the {@code pps_cr_qp_offset} field. */
    @NativeType("int8_t")
    public byte pps_cr_qp_offset() { return npps_cr_qp_offset(address()); }
    /** @return the value of the {@code pps_beta_offset_div2} field. */
    @NativeType("int8_t")
    public byte pps_beta_offset_div2() { return npps_beta_offset_div2(address()); }
    /** @return the value of the {@code pps_tc_offset_div2} field. */
    @NativeType("int8_t")
    public byte pps_tc_offset_div2() { return npps_tc_offset_div2(address()); }
    /** @return the value of the {@code log2_parallel_merge_level_minus2} field. */
    @NativeType("uint8_t")
    public byte log2_parallel_merge_level_minus2() { return nlog2_parallel_merge_level_minus2(address()); }
    /** extension PPS, valid when {@link STDVulkanVideoCodecH265#STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS} is set */
    @NativeType("uint8_t")
    public byte log2_max_transform_skip_block_size_minus2() { return nlog2_max_transform_skip_block_size_minus2(address()); }
    /** @return the value of the {@code diff_cu_chroma_qp_offset_depth} field. */
    @NativeType("uint8_t")
    public byte diff_cu_chroma_qp_offset_depth() { return ndiff_cu_chroma_qp_offset_depth(address()); }
    /** @return the value of the {@code chroma_qp_offset_list_len_minus1} field. */
    @NativeType("uint8_t")
    public byte chroma_qp_offset_list_len_minus1() { return nchroma_qp_offset_list_len_minus1(address()); }
    /** @return a {@link ByteBuffer} view of the {@code cb_qp_offset_list} field. */
    @NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]")
    public ByteBuffer cb_qp_offset_list() { return ncb_qp_offset_list(address()); }
    /** @return the value at the specified index of the {@code cb_qp_offset_list} field. */
    @NativeType("int8_t")
    public byte cb_qp_offset_list(int index) { return ncb_qp_offset_list(address(), index); }
    /** @return a {@link ByteBuffer} view of the {@code cr_qp_offset_list} field. */
    @NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]")
    public ByteBuffer cr_qp_offset_list() { return ncr_qp_offset_list(address()); }
    /** @return the value at the specified index of the {@code cr_qp_offset_list} field. */
    @NativeType("int8_t")
    public byte cr_qp_offset_list(int index) { return ncr_qp_offset_list(address(), index); }
    /** @return the value of the {@code log2_sao_offset_scale_luma} field. */
    @NativeType("uint8_t")
    public byte log2_sao_offset_scale_luma() { return nlog2_sao_offset_scale_luma(address()); }
    /** @return the value of the {@code log2_sao_offset_scale_chroma} field. */
    @NativeType("uint8_t")
    public byte log2_sao_offset_scale_chroma() { return nlog2_sao_offset_scale_chroma(address()); }
    /** extension PPS, valid when std_video_h265_profile_idc_scc_extensions is set */
    @NativeType("int8_t")
    public byte pps_act_y_qp_offset_plus5() { return npps_act_y_qp_offset_plus5(address()); }
    /** @return the value of the {@code pps_act_cb_qp_offset_plus5} field. */
    @NativeType("int8_t")
    public byte pps_act_cb_qp_offset_plus5() { return npps_act_cb_qp_offset_plus5(address()); }
    /** @return the value of the {@code pps_act_cr_qp_offset_plus3} field. */
    @NativeType("int8_t")
    public byte pps_act_cr_qp_offset_plus3() { return npps_act_cr_qp_offset_plus3(address()); }
    /** @return the value of the {@code pps_num_palette_predictor_initializers} field. */
    @NativeType("uint8_t")
    public byte pps_num_palette_predictor_initializers() { return npps_num_palette_predictor_initializers(address()); }
    /** @return the value of the {@code luma_bit_depth_entry_minus8} field. */
    @NativeType("uint8_t")
    public byte luma_bit_depth_entry_minus8() { return nluma_bit_depth_entry_minus8(address()); }
    /** @return the value of the {@code chroma_bit_depth_entry_minus8} field. */
    @NativeType("uint8_t")
    public byte chroma_bit_depth_entry_minus8() { return nchroma_bit_depth_entry_minus8(address()); }
    /** @return the value of the {@code num_tile_columns_minus1} field. */
    @NativeType("uint8_t")
    public byte num_tile_columns_minus1() { return nnum_tile_columns_minus1(address()); }
    /** @return the value of the {@code num_tile_rows_minus1} field. */
    @NativeType("uint8_t")
    public byte num_tile_rows_minus1() { return nnum_tile_rows_minus1(address()); }
    /** @return a {@link ShortBuffer} view of the {@code column_width_minus1} field. */
    @NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]")
    public ShortBuffer column_width_minus1() { return ncolumn_width_minus1(address()); }
    /** @return the value at the specified index of the {@code column_width_minus1} field. */
    @NativeType("uint16_t")
    public short column_width_minus1(int index) { return ncolumn_width_minus1(address(), index); }
    /** @return a {@link ShortBuffer} view of the {@code row_height_minus1} field. */
    @NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]")
    public ShortBuffer row_height_minus1() { return nrow_height_minus1(address()); }
    /** @return the value at the specified index of the {@code row_height_minus1} field. */
    @NativeType("uint16_t")
    public short row_height_minus1(int index) { return nrow_height_minus1(address(), index); }
    /** must be a valid pointer if {@code pps_scaling_list_data_present_flag} is set */
    @NativeType("StdVideoH265ScalingLists const *")
    public StdVideoH265ScalingLists pScalingLists() { return npScalingLists(address()); }
    /** must be a valid pointer if pps_palette_predictor_initializer_present_flag is set */
    @NativeType("StdVideoH265PredictorPaletteEntries const *")
    public StdVideoH265PredictorPaletteEntries pPredictorPaletteEntries() { return npPredictorPaletteEntries(address()); }

    /** Copies the specified {@link StdVideoH265PpsFlags} to the {@code flags} field. */
    public StdVideoH265PictureParameterSet flags(StdVideoH265PpsFlags value) { nflags(address(), value); return this; }
    /** Passes the {@code flags} field to the specified {@link java.util.function.Consumer Consumer}. */
    public StdVideoH265PictureParameterSet flags(java.util.function.Consumer<StdVideoH265PpsFlags> consumer) { consumer.accept(flags()); return this; }
    /** Sets the specified value to the {@code pps_pic_parameter_set_id} field. */
    public StdVideoH265PictureParameterSet pps_pic_parameter_set_id(@NativeType("uint8_t") byte value) { npps_pic_parameter_set_id(address(), value); return this; }
    /** Sets the specified value to the {@code pps_seq_parameter_set_id} field. */
    public StdVideoH265PictureParameterSet pps_seq_parameter_set_id(@NativeType("uint8_t") byte value) { npps_seq_parameter_set_id(address(), value); return this; }
    /** Sets the specified value to the {@code sps_video_parameter_set_id} field. */
    public StdVideoH265PictureParameterSet sps_video_parameter_set_id(@NativeType("uint8_t") byte value) { nsps_video_parameter_set_id(address(), value); return this; }
    /** Sets the specified value to the {@code num_extra_slice_header_bits} field. */
    public StdVideoH265PictureParameterSet num_extra_slice_header_bits(@NativeType("uint8_t") byte value) { nnum_extra_slice_header_bits(address(), value); return this; }
    /** Sets the specified value to the {@code num_ref_idx_l0_default_active_minus1} field. */
    public StdVideoH265PictureParameterSet num_ref_idx_l0_default_active_minus1(@NativeType("uint8_t") byte value) { nnum_ref_idx_l0_default_active_minus1(address(), value); return this; }
    /** Sets the specified value to the {@code num_ref_idx_l1_default_active_minus1} field. */
    public StdVideoH265PictureParameterSet num_ref_idx_l1_default_active_minus1(@NativeType("uint8_t") byte value) { nnum_ref_idx_l1_default_active_minus1(address(), value); return this; }
    /** Sets the specified value to the {@code init_qp_minus26} field. */
    public StdVideoH265PictureParameterSet init_qp_minus26(@NativeType("int8_t") byte value) { ninit_qp_minus26(address(), value); return this; }
    /** Sets the specified value to the {@code diff_cu_qp_delta_depth} field. */
    public StdVideoH265PictureParameterSet diff_cu_qp_delta_depth(@NativeType("uint8_t") byte value) { ndiff_cu_qp_delta_depth(address(), value); return this; }
    /** Sets the specified value to the {@code pps_cb_qp_offset} field. */
    public StdVideoH265PictureParameterSet pps_cb_qp_offset(@NativeType("int8_t") byte value) { npps_cb_qp_offset(address(), value); return this; }
    /** Sets the specified value to the {@code pps_cr_qp_offset} field. */
    public StdVideoH265PictureParameterSet pps_cr_qp_offset(@NativeType("int8_t") byte value) { npps_cr_qp_offset(address(), value); return this; }
    /** Sets the specified value to the {@code pps_beta_offset_div2} field. */
    public StdVideoH265PictureParameterSet pps_beta_offset_div2(@NativeType("int8_t") byte value) { npps_beta_offset_div2(address(), value); return this; }
    /** Sets the specified value to the {@code pps_tc_offset_div2} field. */
    public StdVideoH265PictureParameterSet pps_tc_offset_div2(@NativeType("int8_t") byte value) { npps_tc_offset_div2(address(), value); return this; }
    /** Sets the specified value to the {@code log2_parallel_merge_level_minus2} field. */
    public StdVideoH265PictureParameterSet log2_parallel_merge_level_minus2(@NativeType("uint8_t") byte value) { nlog2_parallel_merge_level_minus2(address(), value); return this; }
    /** Sets the specified value to the {@link #log2_max_transform_skip_block_size_minus2} field. */
    public StdVideoH265PictureParameterSet log2_max_transform_skip_block_size_minus2(@NativeType("uint8_t") byte value) { nlog2_max_transform_skip_block_size_minus2(address(), value); return this; }
    /** Sets the specified value to the {@code diff_cu_chroma_qp_offset_depth} field. */
    public StdVideoH265PictureParameterSet diff_cu_chroma_qp_offset_depth(@NativeType("uint8_t") byte value) { ndiff_cu_chroma_qp_offset_depth(address(), value); return this; }
    /** Sets the specified value to the {@code chroma_qp_offset_list_len_minus1} field. */
    public StdVideoH265PictureParameterSet chroma_qp_offset_list_len_minus1(@NativeType("uint8_t") byte value) { nchroma_qp_offset_list_len_minus1(address(), value); return this; }
    /** Copies the specified {@link ByteBuffer} to the {@code cb_qp_offset_list} field. */
    public StdVideoH265PictureParameterSet cb_qp_offset_list(@NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]") ByteBuffer value) { ncb_qp_offset_list(address(), value); return this; }
    /** Sets the specified value at the specified index of the {@code cb_qp_offset_list} field. */
    public StdVideoH265PictureParameterSet cb_qp_offset_list(int index, @NativeType("int8_t") byte value) { ncb_qp_offset_list(address(), index, value); return this; }
    /** Copies the specified {@link ByteBuffer} to the {@code cr_qp_offset_list} field. */
    public StdVideoH265PictureParameterSet cr_qp_offset_list(@NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]") ByteBuffer value) { ncr_qp_offset_list(address(), value); return this; }
    /** Sets the specified value at the specified index of the {@code cr_qp_offset_list} field. */
    public StdVideoH265PictureParameterSet cr_qp_offset_list(int index, @NativeType("int8_t") byte value) { ncr_qp_offset_list(address(), index, value); return this; }
    /** Sets the specified value to the {@code log2_sao_offset_scale_luma} field. */
    public StdVideoH265PictureParameterSet log2_sao_offset_scale_luma(@NativeType("uint8_t") byte value) { nlog2_sao_offset_scale_luma(address(), value); return this; }
    /** Sets the specified value to the {@code log2_sao_offset_scale_chroma} field. */
    public StdVideoH265PictureParameterSet log2_sao_offset_scale_chroma(@NativeType("uint8_t") byte value) { nlog2_sao_offset_scale_chroma(address(), value); return this; }
    /** Sets the specified value to the {@link #pps_act_y_qp_offset_plus5} field. */
    public StdVideoH265PictureParameterSet pps_act_y_qp_offset_plus5(@NativeType("int8_t") byte value) { npps_act_y_qp_offset_plus5(address(), value); return this; }
    /** Sets the specified value to the {@code pps_act_cb_qp_offset_plus5} field. */
    public StdVideoH265PictureParameterSet pps_act_cb_qp_offset_plus5(@NativeType("int8_t") byte value) { npps_act_cb_qp_offset_plus5(address(), value); return this; }
    /** Sets the specified value to the {@code pps_act_cr_qp_offset_plus3} field. */
    public StdVideoH265PictureParameterSet pps_act_cr_qp_offset_plus3(@NativeType("int8_t") byte value) { npps_act_cr_qp_offset_plus3(address(), value); return this; }
    /** Sets the specified value to the {@code pps_num_palette_predictor_initializers} field. */
    public StdVideoH265PictureParameterSet pps_num_palette_predictor_initializers(@NativeType("uint8_t") byte value) { npps_num_palette_predictor_initializers(address(), value); return this; }
    /** Sets the specified value to the {@code luma_bit_depth_entry_minus8} field. */
    public StdVideoH265PictureParameterSet luma_bit_depth_entry_minus8(@NativeType("uint8_t") byte value) { nluma_bit_depth_entry_minus8(address(), value); return this; }
    /** Sets the specified value to the {@code chroma_bit_depth_entry_minus8} field. */
    public StdVideoH265PictureParameterSet chroma_bit_depth_entry_minus8(@NativeType("uint8_t") byte value) { nchroma_bit_depth_entry_minus8(address(), value); return this; }
    /** Sets the specified value to the {@code num_tile_columns_minus1} field. */
    public StdVideoH265PictureParameterSet num_tile_columns_minus1(@NativeType("uint8_t") byte value) { nnum_tile_columns_minus1(address(), value); return this; }
    /** Sets the specified value to the {@code num_tile_rows_minus1} field. */
    public StdVideoH265PictureParameterSet num_tile_rows_minus1(@NativeType("uint8_t") byte value) { nnum_tile_rows_minus1(address(), value); return this; }
    /** Copies the specified {@link ShortBuffer} to the {@code column_width_minus1} field. */
    public StdVideoH265PictureParameterSet column_width_minus1(@NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]") ShortBuffer value) { ncolumn_width_minus1(address(), value); return this; }
    /** Sets the specified value at the specified index of the {@code column_width_minus1} field. */
    public StdVideoH265PictureParameterSet column_width_minus1(int index, @NativeType("uint16_t") short value) { ncolumn_width_minus1(address(), index, value); return this; }
    /** Copies the specified {@link ShortBuffer} to the {@code row_height_minus1} field. */
    public StdVideoH265PictureParameterSet row_height_minus1(@NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]") ShortBuffer value) { nrow_height_minus1(address(), value); return this; }
    /** Sets the specified value at the specified index of the {@code row_height_minus1} field. */
    public StdVideoH265PictureParameterSet row_height_minus1(int index, @NativeType("uint16_t") short value) { nrow_height_minus1(address(), index, value); return this; }
    /** Sets the address of the specified {@link StdVideoH265ScalingLists} to the {@link #pScalingLists} field. */
    public StdVideoH265PictureParameterSet pScalingLists(@NativeType("StdVideoH265ScalingLists const *") StdVideoH265ScalingLists value) { npScalingLists(address(), value); return this; }
    /** Sets the address of the specified {@link StdVideoH265PredictorPaletteEntries} to the {@link #pPredictorPaletteEntries} field. */
    public StdVideoH265PictureParameterSet pPredictorPaletteEntries(@NativeType("StdVideoH265PredictorPaletteEntries const *") StdVideoH265PredictorPaletteEntries value) { npPredictorPaletteEntries(address(), value); return this; }

    /** Initializes this struct with the specified values. */
    public StdVideoH265PictureParameterSet set(
        StdVideoH265PpsFlags flags,
        byte pps_pic_parameter_set_id,
        byte pps_seq_parameter_set_id,
        byte sps_video_parameter_set_id,
        byte num_extra_slice_header_bits,
        byte num_ref_idx_l0_default_active_minus1,
        byte num_ref_idx_l1_default_active_minus1,
        byte init_qp_minus26,
        byte diff_cu_qp_delta_depth,
        byte pps_cb_qp_offset,
        byte pps_cr_qp_offset,
        byte pps_beta_offset_div2,
        byte pps_tc_offset_div2,
        byte log2_parallel_merge_level_minus2,
        byte log2_max_transform_skip_block_size_minus2,
        byte diff_cu_chroma_qp_offset_depth,
        byte chroma_qp_offset_list_len_minus1,
        ByteBuffer cb_qp_offset_list,
        ByteBuffer cr_qp_offset_list,
        byte log2_sao_offset_scale_luma,
        byte log2_sao_offset_scale_chroma,
        byte pps_act_y_qp_offset_plus5,
        byte pps_act_cb_qp_offset_plus5,
        byte pps_act_cr_qp_offset_plus3,
        byte pps_num_palette_predictor_initializers,
        byte luma_bit_depth_entry_minus8,
        byte chroma_bit_depth_entry_minus8,
        byte num_tile_columns_minus1,
        byte num_tile_rows_minus1,
        ShortBuffer column_width_minus1,
        ShortBuffer row_height_minus1,
        StdVideoH265ScalingLists pScalingLists,
        StdVideoH265PredictorPaletteEntries pPredictorPaletteEntries
    ) {
        flags(flags);
        pps_pic_parameter_set_id(pps_pic_parameter_set_id);
        pps_seq_parameter_set_id(pps_seq_parameter_set_id);
        sps_video_parameter_set_id(sps_video_parameter_set_id);
        num_extra_slice_header_bits(num_extra_slice_header_bits);
        num_ref_idx_l0_default_active_minus1(num_ref_idx_l0_default_active_minus1);
        num_ref_idx_l1_default_active_minus1(num_ref_idx_l1_default_active_minus1);
        init_qp_minus26(init_qp_minus26);
        diff_cu_qp_delta_depth(diff_cu_qp_delta_depth);
        pps_cb_qp_offset(pps_cb_qp_offset);
        pps_cr_qp_offset(pps_cr_qp_offset);
        pps_beta_offset_div2(pps_beta_offset_div2);
        pps_tc_offset_div2(pps_tc_offset_div2);
        log2_parallel_merge_level_minus2(log2_parallel_merge_level_minus2);
        log2_max_transform_skip_block_size_minus2(log2_max_transform_skip_block_size_minus2);
        diff_cu_chroma_qp_offset_depth(diff_cu_chroma_qp_offset_depth);
        chroma_qp_offset_list_len_minus1(chroma_qp_offset_list_len_minus1);
        cb_qp_offset_list(cb_qp_offset_list);
        cr_qp_offset_list(cr_qp_offset_list);
        log2_sao_offset_scale_luma(log2_sao_offset_scale_luma);
        log2_sao_offset_scale_chroma(log2_sao_offset_scale_chroma);
        pps_act_y_qp_offset_plus5(pps_act_y_qp_offset_plus5);
        pps_act_cb_qp_offset_plus5(pps_act_cb_qp_offset_plus5);
        pps_act_cr_qp_offset_plus3(pps_act_cr_qp_offset_plus3);
        pps_num_palette_predictor_initializers(pps_num_palette_predictor_initializers);
        luma_bit_depth_entry_minus8(luma_bit_depth_entry_minus8);
        chroma_bit_depth_entry_minus8(chroma_bit_depth_entry_minus8);
        num_tile_columns_minus1(num_tile_columns_minus1);
        num_tile_rows_minus1(num_tile_rows_minus1);
        column_width_minus1(column_width_minus1);
        row_height_minus1(row_height_minus1);
        pScalingLists(pScalingLists);
        pPredictorPaletteEntries(pPredictorPaletteEntries);

        return this;
    }

    /**
     * Copies the specified struct data to this struct.
     *
     * @param src the source struct
     *
     * @return this struct
     */
    public StdVideoH265PictureParameterSet set(StdVideoH265PictureParameterSet src) {
        memCopy(src.address(), address(), SIZEOF);
        return this;
    }

    // -----------------------------------

    /** Returns a new {@code StdVideoH265PictureParameterSet} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed. */
    public static StdVideoH265PictureParameterSet malloc() {
        return wrap(StdVideoH265PictureParameterSet.class, nmemAllocChecked(SIZEOF));
    }

    /** Returns a new {@code StdVideoH265PictureParameterSet} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed. */
    public static StdVideoH265PictureParameterSet calloc() {
        return wrap(StdVideoH265PictureParameterSet.class, nmemCallocChecked(1, SIZEOF));
    }

    /** Returns a new {@code StdVideoH265PictureParameterSet} instance allocated with {@link BufferUtils}. */
    public static StdVideoH265PictureParameterSet create() {
        ByteBuffer container = BufferUtils.createByteBuffer(SIZEOF);
        return wrap(StdVideoH265PictureParameterSet.class, memAddress(container), container);
    }

    /** Returns a new {@code StdVideoH265PictureParameterSet} instance for the specified memory address. */
    public static StdVideoH265PictureParameterSet create(long address) {
        return wrap(StdVideoH265PictureParameterSet.class, address);
    }

    /** Like {@link #create(long) create}, but returns {@code null} if {@code address} is {@code NULL}. */
    @Nullable
    public static StdVideoH265PictureParameterSet createSafe(long address) {
        return address == NULL ? null : wrap(StdVideoH265PictureParameterSet.class, address);
    }

    /**
     * Returns a new {@link StdVideoH265PictureParameterSet.Buffer} instance allocated with {@link MemoryUtil#memAlloc memAlloc}. The instance must be explicitly freed.
     *
     * @param capacity the buffer capacity
     */
    public static StdVideoH265PictureParameterSet.Buffer malloc(int capacity) {
        return wrap(Buffer.class, nmemAllocChecked(__checkMalloc(capacity, SIZEOF)), capacity);
    }

    /**
     * Returns a new {@link StdVideoH265PictureParameterSet.Buffer} instance allocated with {@link MemoryUtil#memCalloc memCalloc}. The instance must be explicitly freed.
     *
     * @param capacity the buffer capacity
     */
    public static StdVideoH265PictureParameterSet.Buffer calloc(int capacity) {
        return wrap(Buffer.class, nmemCallocChecked(capacity, SIZEOF), capacity);
    }

    /**
     * Returns a new {@link StdVideoH265PictureParameterSet.Buffer} instance allocated with {@link BufferUtils}.
     *
     * @param capacity the buffer capacity
     */
    public static StdVideoH265PictureParameterSet.Buffer create(int capacity) {
        ByteBuffer container = __create(capacity, SIZEOF);
        return wrap(Buffer.class, memAddress(container), capacity, container);
    }

    /**
     * Create a {@link StdVideoH265PictureParameterSet.Buffer} instance at the specified memory.
     *
     * @param address  the memory address
     * @param capacity the buffer capacity
     */
    public static StdVideoH265PictureParameterSet.Buffer create(long address, int capacity) {
        return wrap(Buffer.class, address, capacity);
    }

    /** Like {@link #create(long, int) create}, but returns {@code null} if {@code address} is {@code NULL}. */
    @Nullable
    public static StdVideoH265PictureParameterSet.Buffer createSafe(long address, int capacity) {
        return address == NULL ? null : wrap(Buffer.class, address, capacity);
    }

    /**
     * Returns a new {@code StdVideoH265PictureParameterSet} instance allocated on the specified {@link MemoryStack}.
     *
     * @param stack the stack from which to allocate
     */
    public static StdVideoH265PictureParameterSet malloc(MemoryStack stack) {
        return wrap(StdVideoH265PictureParameterSet.class, stack.nmalloc(ALIGNOF, SIZEOF));
    }

    /**
     * Returns a new {@code StdVideoH265PictureParameterSet} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero.
     *
     * @param stack the stack from which to allocate
     */
    public static StdVideoH265PictureParameterSet calloc(MemoryStack stack) {
        return wrap(StdVideoH265PictureParameterSet.class, stack.ncalloc(ALIGNOF, 1, SIZEOF));
    }

    /**
     * Returns a new {@link StdVideoH265PictureParameterSet.Buffer} instance allocated on the specified {@link MemoryStack}.
     *
     * @param stack    the stack from which to allocate
     * @param capacity the buffer capacity
     */
    public static StdVideoH265PictureParameterSet.Buffer malloc(int capacity, MemoryStack stack) {
        return wrap(Buffer.class, stack.nmalloc(ALIGNOF, capacity * SIZEOF), capacity);
    }

    /**
     * Returns a new {@link StdVideoH265PictureParameterSet.Buffer} instance allocated on the specified {@link MemoryStack} and initializes all its bits to zero.
     *
     * @param stack    the stack from which to allocate
     * @param capacity the buffer capacity
     */
    public static StdVideoH265PictureParameterSet.Buffer calloc(int capacity, MemoryStack stack) {
        return wrap(Buffer.class, stack.ncalloc(ALIGNOF, capacity, SIZEOF), capacity);
    }

    // -----------------------------------

    /** Unsafe version of {@link #flags}. */
    public static StdVideoH265PpsFlags nflags(long struct) { return StdVideoH265PpsFlags.create(struct + StdVideoH265PictureParameterSet.FLAGS); }
    /** Unsafe version of {@link #pps_pic_parameter_set_id}. */
    public static byte npps_pic_parameter_set_id(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_PIC_PARAMETER_SET_ID); }
    /** Unsafe version of {@link #pps_seq_parameter_set_id}. */
    public static byte npps_seq_parameter_set_id(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_SEQ_PARAMETER_SET_ID); }
    /** Unsafe version of {@link #sps_video_parameter_set_id}. */
    public static byte nsps_video_parameter_set_id(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.SPS_VIDEO_PARAMETER_SET_ID); }
    /** Unsafe version of {@link #num_extra_slice_header_bits}. */
    public static byte nnum_extra_slice_header_bits(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.NUM_EXTRA_SLICE_HEADER_BITS); }
    /** Unsafe version of {@link #num_ref_idx_l0_default_active_minus1}. */
    public static byte nnum_ref_idx_l0_default_active_minus1(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.NUM_REF_IDX_L0_DEFAULT_ACTIVE_MINUS1); }
    /** Unsafe version of {@link #num_ref_idx_l1_default_active_minus1}. */
    public static byte nnum_ref_idx_l1_default_active_minus1(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.NUM_REF_IDX_L1_DEFAULT_ACTIVE_MINUS1); }
    /** Unsafe version of {@link #init_qp_minus26}. */
    public static byte ninit_qp_minus26(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.INIT_QP_MINUS26); }
    /** Unsafe version of {@link #diff_cu_qp_delta_depth}. */
    public static byte ndiff_cu_qp_delta_depth(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.DIFF_CU_QP_DELTA_DEPTH); }
    /** Unsafe version of {@link #pps_cb_qp_offset}. */
    public static byte npps_cb_qp_offset(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_CB_QP_OFFSET); }
    /** Unsafe version of {@link #pps_cr_qp_offset}. */
    public static byte npps_cr_qp_offset(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_CR_QP_OFFSET); }
    /** Unsafe version of {@link #pps_beta_offset_div2}. */
    public static byte npps_beta_offset_div2(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_BETA_OFFSET_DIV2); }
    /** Unsafe version of {@link #pps_tc_offset_div2}. */
    public static byte npps_tc_offset_div2(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_TC_OFFSET_DIV2); }
    /** Unsafe version of {@link #log2_parallel_merge_level_minus2}. */
    public static byte nlog2_parallel_merge_level_minus2(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.LOG2_PARALLEL_MERGE_LEVEL_MINUS2); }
    /** Unsafe version of {@link #log2_max_transform_skip_block_size_minus2}. */
    public static byte nlog2_max_transform_skip_block_size_minus2(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.LOG2_MAX_TRANSFORM_SKIP_BLOCK_SIZE_MINUS2); }
    /** Unsafe version of {@link #diff_cu_chroma_qp_offset_depth}. */
    public static byte ndiff_cu_chroma_qp_offset_depth(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.DIFF_CU_CHROMA_QP_OFFSET_DEPTH); }
    /** Unsafe version of {@link #chroma_qp_offset_list_len_minus1}. */
    public static byte nchroma_qp_offset_list_len_minus1(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.CHROMA_QP_OFFSET_LIST_LEN_MINUS1); }
    /** Unsafe version of {@link #cb_qp_offset_list}. */
    public static ByteBuffer ncb_qp_offset_list(long struct) { return memByteBuffer(struct + StdVideoH265PictureParameterSet.CB_QP_OFFSET_LIST, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE); }
    /** Unsafe version of {@link #cb_qp_offset_list(int) cb_qp_offset_list}. */
    public static byte ncb_qp_offset_list(long struct, int index) {
        return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.CB_QP_OFFSET_LIST + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE) * 1);
    }
    /** Unsafe version of {@link #cr_qp_offset_list}. */
    public static ByteBuffer ncr_qp_offset_list(long struct) { return memByteBuffer(struct + StdVideoH265PictureParameterSet.CR_QP_OFFSET_LIST, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE); }
    /** Unsafe version of {@link #cr_qp_offset_list(int) cr_qp_offset_list}. */
    public static byte ncr_qp_offset_list(long struct, int index) {
        return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.CR_QP_OFFSET_LIST + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE) * 1);
    }
    /** Unsafe version of {@link #log2_sao_offset_scale_luma}. */
    public static byte nlog2_sao_offset_scale_luma(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.LOG2_SAO_OFFSET_SCALE_LUMA); }
    /** Unsafe version of {@link #log2_sao_offset_scale_chroma}. */
    public static byte nlog2_sao_offset_scale_chroma(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.LOG2_SAO_OFFSET_SCALE_CHROMA); }
    /** Unsafe version of {@link #pps_act_y_qp_offset_plus5}. */
    public static byte npps_act_y_qp_offset_plus5(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_ACT_Y_QP_OFFSET_PLUS5); }
    /** Unsafe version of {@link #pps_act_cb_qp_offset_plus5}. */
    public static byte npps_act_cb_qp_offset_plus5(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_ACT_CB_QP_OFFSET_PLUS5); }
    /** Unsafe version of {@link #pps_act_cr_qp_offset_plus3}. */
    public static byte npps_act_cr_qp_offset_plus3(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_ACT_CR_QP_OFFSET_PLUS3); }
    /** Unsafe version of {@link #pps_num_palette_predictor_initializers}. */
    public static byte npps_num_palette_predictor_initializers(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.PPS_NUM_PALETTE_PREDICTOR_INITIALIZERS); }
    /** Unsafe version of {@link #luma_bit_depth_entry_minus8}. */
    public static byte nluma_bit_depth_entry_minus8(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.LUMA_BIT_DEPTH_ENTRY_MINUS8); }
    /** Unsafe version of {@link #chroma_bit_depth_entry_minus8}. */
    public static byte nchroma_bit_depth_entry_minus8(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.CHROMA_BIT_DEPTH_ENTRY_MINUS8); }
    /** Unsafe version of {@link #num_tile_columns_minus1}. */
    public static byte nnum_tile_columns_minus1(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.NUM_TILE_COLUMNS_MINUS1); }
    /** Unsafe version of {@link #num_tile_rows_minus1}. */
    public static byte nnum_tile_rows_minus1(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.NUM_TILE_ROWS_MINUS1); }
    public static byte nreserved1(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.RESERVED1); }
    public static byte nreserved2(long struct) { return UNSAFE.getByte(null, struct + StdVideoH265PictureParameterSet.RESERVED2); }
    /** Unsafe version of {@link #column_width_minus1}. */
    public static ShortBuffer ncolumn_width_minus1(long struct) { return memShortBuffer(struct + StdVideoH265PictureParameterSet.COLUMN_WIDTH_MINUS1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE); }
    /** Unsafe version of {@link #column_width_minus1(int) column_width_minus1}. */
    public static short ncolumn_width_minus1(long struct, int index) {
        return UNSAFE.getShort(null, struct + StdVideoH265PictureParameterSet.COLUMN_WIDTH_MINUS1 + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE) * 2);
    }
    /** Unsafe version of {@link #row_height_minus1}. */
    public static ShortBuffer nrow_height_minus1(long struct) { return memShortBuffer(struct + StdVideoH265PictureParameterSet.ROW_HEIGHT_MINUS1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE); }
    /** Unsafe version of {@link #row_height_minus1(int) row_height_minus1}. */
    public static short nrow_height_minus1(long struct, int index) {
        return UNSAFE.getShort(null, struct + StdVideoH265PictureParameterSet.ROW_HEIGHT_MINUS1 + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE) * 2);
    }
    public static int nreserved3(long struct) { return UNSAFE.getInt(null, struct + StdVideoH265PictureParameterSet.RESERVED3); }
    /** Unsafe version of {@link #pScalingLists}. */
    public static StdVideoH265ScalingLists npScalingLists(long struct) { return StdVideoH265ScalingLists.create(memGetAddress(struct + StdVideoH265PictureParameterSet.PSCALINGLISTS)); }
    /** Unsafe version of {@link #pPredictorPaletteEntries}. */
    public static StdVideoH265PredictorPaletteEntries npPredictorPaletteEntries(long struct) { return StdVideoH265PredictorPaletteEntries.create(memGetAddress(struct + StdVideoH265PictureParameterSet.PPREDICTORPALETTEENTRIES)); }

    /** Unsafe version of {@link #flags(StdVideoH265PpsFlags) flags}. */
    public static void nflags(long struct, StdVideoH265PpsFlags value) { memCopy(value.address(), struct + StdVideoH265PictureParameterSet.FLAGS, StdVideoH265PpsFlags.SIZEOF); }
    /** Unsafe version of {@link #pps_pic_parameter_set_id(byte) pps_pic_parameter_set_id}. */
    public static void npps_pic_parameter_set_id(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_PIC_PARAMETER_SET_ID, value); }
    /** Unsafe version of {@link #pps_seq_parameter_set_id(byte) pps_seq_parameter_set_id}. */
    public static void npps_seq_parameter_set_id(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_SEQ_PARAMETER_SET_ID, value); }
    /** Unsafe version of {@link #sps_video_parameter_set_id(byte) sps_video_parameter_set_id}. */
    public static void nsps_video_parameter_set_id(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.SPS_VIDEO_PARAMETER_SET_ID, value); }
    /** Unsafe version of {@link #num_extra_slice_header_bits(byte) num_extra_slice_header_bits}. */
    public static void nnum_extra_slice_header_bits(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.NUM_EXTRA_SLICE_HEADER_BITS, value); }
    /** Unsafe version of {@link #num_ref_idx_l0_default_active_minus1(byte) num_ref_idx_l0_default_active_minus1}. */
    public static void nnum_ref_idx_l0_default_active_minus1(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.NUM_REF_IDX_L0_DEFAULT_ACTIVE_MINUS1, value); }
    /** Unsafe version of {@link #num_ref_idx_l1_default_active_minus1(byte) num_ref_idx_l1_default_active_minus1}. */
    public static void nnum_ref_idx_l1_default_active_minus1(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.NUM_REF_IDX_L1_DEFAULT_ACTIVE_MINUS1, value); }
    /** Unsafe version of {@link #init_qp_minus26(byte) init_qp_minus26}. */
    public static void ninit_qp_minus26(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.INIT_QP_MINUS26, value); }
    /** Unsafe version of {@link #diff_cu_qp_delta_depth(byte) diff_cu_qp_delta_depth}. */
    public static void ndiff_cu_qp_delta_depth(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.DIFF_CU_QP_DELTA_DEPTH, value); }
    /** Unsafe version of {@link #pps_cb_qp_offset(byte) pps_cb_qp_offset}. */
    public static void npps_cb_qp_offset(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_CB_QP_OFFSET, value); }
    /** Unsafe version of {@link #pps_cr_qp_offset(byte) pps_cr_qp_offset}. */
    public static void npps_cr_qp_offset(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_CR_QP_OFFSET, value); }
    /** Unsafe version of {@link #pps_beta_offset_div2(byte) pps_beta_offset_div2}. */
    public static void npps_beta_offset_div2(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_BETA_OFFSET_DIV2, value); }
    /** Unsafe version of {@link #pps_tc_offset_div2(byte) pps_tc_offset_div2}. */
    public static void npps_tc_offset_div2(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_TC_OFFSET_DIV2, value); }
    /** Unsafe version of {@link #log2_parallel_merge_level_minus2(byte) log2_parallel_merge_level_minus2}. */
    public static void nlog2_parallel_merge_level_minus2(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.LOG2_PARALLEL_MERGE_LEVEL_MINUS2, value); }
    /** Unsafe version of {@link #log2_max_transform_skip_block_size_minus2(byte) log2_max_transform_skip_block_size_minus2}. */
    public static void nlog2_max_transform_skip_block_size_minus2(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.LOG2_MAX_TRANSFORM_SKIP_BLOCK_SIZE_MINUS2, value); }
    /** Unsafe version of {@link #diff_cu_chroma_qp_offset_depth(byte) diff_cu_chroma_qp_offset_depth}. */
    public static void ndiff_cu_chroma_qp_offset_depth(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.DIFF_CU_CHROMA_QP_OFFSET_DEPTH, value); }
    /** Unsafe version of {@link #chroma_qp_offset_list_len_minus1(byte) chroma_qp_offset_list_len_minus1}. */
    public static void nchroma_qp_offset_list_len_minus1(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.CHROMA_QP_OFFSET_LIST_LEN_MINUS1, value); }
    /** Unsafe version of {@link #cb_qp_offset_list(ByteBuffer) cb_qp_offset_list}. */
    public static void ncb_qp_offset_list(long struct, ByteBuffer value) {
        if (CHECKS) { checkGT(value, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE); }
        memCopy(memAddress(value), struct + StdVideoH265PictureParameterSet.CB_QP_OFFSET_LIST, value.remaining() * 1);
    }
    /** Unsafe version of {@link #cb_qp_offset_list(int, byte) cb_qp_offset_list}. */
    public static void ncb_qp_offset_list(long struct, int index, byte value) {
        UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.CB_QP_OFFSET_LIST + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE) * 1, value);
    }
    /** Unsafe version of {@link #cr_qp_offset_list(ByteBuffer) cr_qp_offset_list}. */
    public static void ncr_qp_offset_list(long struct, ByteBuffer value) {
        if (CHECKS) { checkGT(value, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE); }
        memCopy(memAddress(value), struct + StdVideoH265PictureParameterSet.CR_QP_OFFSET_LIST, value.remaining() * 1);
    }
    /** Unsafe version of {@link #cr_qp_offset_list(int, byte) cr_qp_offset_list}. */
    public static void ncr_qp_offset_list(long struct, int index, byte value) {
        UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.CR_QP_OFFSET_LIST + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE) * 1, value);
    }
    /** Unsafe version of {@link #log2_sao_offset_scale_luma(byte) log2_sao_offset_scale_luma}. */
    public static void nlog2_sao_offset_scale_luma(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.LOG2_SAO_OFFSET_SCALE_LUMA, value); }
    /** Unsafe version of {@link #log2_sao_offset_scale_chroma(byte) log2_sao_offset_scale_chroma}. */
    public static void nlog2_sao_offset_scale_chroma(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.LOG2_SAO_OFFSET_SCALE_CHROMA, value); }
    /** Unsafe version of {@link #pps_act_y_qp_offset_plus5(byte) pps_act_y_qp_offset_plus5}. */
    public static void npps_act_y_qp_offset_plus5(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_ACT_Y_QP_OFFSET_PLUS5, value); }
    /** Unsafe version of {@link #pps_act_cb_qp_offset_plus5(byte) pps_act_cb_qp_offset_plus5}. */
    public static void npps_act_cb_qp_offset_plus5(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_ACT_CB_QP_OFFSET_PLUS5, value); }
    /** Unsafe version of {@link #pps_act_cr_qp_offset_plus3(byte) pps_act_cr_qp_offset_plus3}. */
    public static void npps_act_cr_qp_offset_plus3(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_ACT_CR_QP_OFFSET_PLUS3, value); }
    /** Unsafe version of {@link #pps_num_palette_predictor_initializers(byte) pps_num_palette_predictor_initializers}. */
    public static void npps_num_palette_predictor_initializers(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.PPS_NUM_PALETTE_PREDICTOR_INITIALIZERS, value); }
    /** Unsafe version of {@link #luma_bit_depth_entry_minus8(byte) luma_bit_depth_entry_minus8}. */
    public static void nluma_bit_depth_entry_minus8(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.LUMA_BIT_DEPTH_ENTRY_MINUS8, value); }
    /** Unsafe version of {@link #chroma_bit_depth_entry_minus8(byte) chroma_bit_depth_entry_minus8}. */
    public static void nchroma_bit_depth_entry_minus8(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.CHROMA_BIT_DEPTH_ENTRY_MINUS8, value); }
    /** Unsafe version of {@link #num_tile_columns_minus1(byte) num_tile_columns_minus1}. */
    public static void nnum_tile_columns_minus1(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.NUM_TILE_COLUMNS_MINUS1, value); }
    /** Unsafe version of {@link #num_tile_rows_minus1(byte) num_tile_rows_minus1}. */
    public static void nnum_tile_rows_minus1(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.NUM_TILE_ROWS_MINUS1, value); }
    public static void nreserved1(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.RESERVED1, value); }
    public static void nreserved2(long struct, byte value) { UNSAFE.putByte(null, struct + StdVideoH265PictureParameterSet.RESERVED2, value); }
    /** Unsafe version of {@link #column_width_minus1(ShortBuffer) column_width_minus1}. */
    public static void ncolumn_width_minus1(long struct, ShortBuffer value) {
        if (CHECKS) { checkGT(value, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE); }
        memCopy(memAddress(value), struct + StdVideoH265PictureParameterSet.COLUMN_WIDTH_MINUS1, value.remaining() * 2);
    }
    /** Unsafe version of {@link #column_width_minus1(int, short) column_width_minus1}. */
    public static void ncolumn_width_minus1(long struct, int index, short value) {
        UNSAFE.putShort(null, struct + StdVideoH265PictureParameterSet.COLUMN_WIDTH_MINUS1 + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE) * 2, value);
    }
    /** Unsafe version of {@link #row_height_minus1(ShortBuffer) row_height_minus1}. */
    public static void nrow_height_minus1(long struct, ShortBuffer value) {
        if (CHECKS) { checkGT(value, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE); }
        memCopy(memAddress(value), struct + StdVideoH265PictureParameterSet.ROW_HEIGHT_MINUS1, value.remaining() * 2);
    }
    /** Unsafe version of {@link #row_height_minus1(int, short) row_height_minus1}. */
    public static void nrow_height_minus1(long struct, int index, short value) {
        UNSAFE.putShort(null, struct + StdVideoH265PictureParameterSet.ROW_HEIGHT_MINUS1 + check(index, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE) * 2, value);
    }
    public static void nreserved3(long struct, int value) { UNSAFE.putInt(null, struct + StdVideoH265PictureParameterSet.RESERVED3, value); }
    /** Unsafe version of {@link #pScalingLists(StdVideoH265ScalingLists) pScalingLists}. */
    public static void npScalingLists(long struct, StdVideoH265ScalingLists value) { memPutAddress(struct + StdVideoH265PictureParameterSet.PSCALINGLISTS, value.address()); }
    /** Unsafe version of {@link #pPredictorPaletteEntries(StdVideoH265PredictorPaletteEntries) pPredictorPaletteEntries}. */
    public static void npPredictorPaletteEntries(long struct, StdVideoH265PredictorPaletteEntries value) { memPutAddress(struct + StdVideoH265PictureParameterSet.PPREDICTORPALETTEENTRIES, value.address()); }

    /**
     * Validates pointer members that should not be {@code NULL}.
     *
     * @param struct the struct to validate
     */
    public static void validate(long struct) {
        check(memGetAddress(struct + StdVideoH265PictureParameterSet.PSCALINGLISTS));
        check(memGetAddress(struct + StdVideoH265PictureParameterSet.PPREDICTORPALETTEENTRIES));
    }

    // -----------------------------------

    /** An array of {@link StdVideoH265PictureParameterSet} structs. */
    public static class Buffer extends StructBuffer<StdVideoH265PictureParameterSet, Buffer> implements NativeResource {

        private static final StdVideoH265PictureParameterSet ELEMENT_FACTORY = StdVideoH265PictureParameterSet.create(-1L);

        /**
         * Creates a new {@code StdVideoH265PictureParameterSet.Buffer} instance backed by the specified container.
         *
         * Changes to the container's content will be visible to the struct buffer instance and vice versa. The two buffers' position, limit, and mark values
         * will be independent. The new buffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this buffer divided
         * by {@link StdVideoH265PictureParameterSet#SIZEOF}, and its mark will be undefined.
         *
         *
The created buffer instance holds a strong reference to the container object.

         */
        public Buffer(ByteBuffer container) {
            super(container, container.remaining() / SIZEOF);
        }

        public Buffer(long address, int cap) {
            super(address, null, -1, 0, cap, cap);
        }

        Buffer(long address, @Nullable ByteBuffer container, int mark, int pos, int lim, int cap) {
            super(address, container, mark, pos, lim, cap);
        }

        @Override
        protected Buffer self() {
            return this;
        }

        @Override
        protected StdVideoH265PictureParameterSet getElementFactory() {
            return ELEMENT_FACTORY;
        }

        /** @return a {@link StdVideoH265PpsFlags} view of the {@code flags} field. */
        public StdVideoH265PpsFlags flags() { return StdVideoH265PictureParameterSet.nflags(address()); }
        /** @return the value of the {@code pps_pic_parameter_set_id} field. */
        @NativeType("uint8_t")
        public byte pps_pic_parameter_set_id() { return StdVideoH265PictureParameterSet.npps_pic_parameter_set_id(address()); }
        /** @return the value of the {@code pps_seq_parameter_set_id} field. */
        @NativeType("uint8_t")
        public byte pps_seq_parameter_set_id() { return StdVideoH265PictureParameterSet.npps_seq_parameter_set_id(address()); }
        /** @return the value of the {@code sps_video_parameter_set_id} field. */
        @NativeType("uint8_t")
        public byte sps_video_parameter_set_id() { return StdVideoH265PictureParameterSet.nsps_video_parameter_set_id(address()); }
        /** @return the value of the {@code num_extra_slice_header_bits} field. */
        @NativeType("uint8_t")
        public byte num_extra_slice_header_bits() { return StdVideoH265PictureParameterSet.nnum_extra_slice_header_bits(address()); }
        /** @return the value of the {@code num_ref_idx_l0_default_active_minus1} field. */
        @NativeType("uint8_t")
        public byte num_ref_idx_l0_default_active_minus1() { return StdVideoH265PictureParameterSet.nnum_ref_idx_l0_default_active_minus1(address()); }
        /** @return the value of the {@code num_ref_idx_l1_default_active_minus1} field. */
        @NativeType("uint8_t")
        public byte num_ref_idx_l1_default_active_minus1() { return StdVideoH265PictureParameterSet.nnum_ref_idx_l1_default_active_minus1(address()); }
        /** @return the value of the {@code init_qp_minus26} field. */
        @NativeType("int8_t")
        public byte init_qp_minus26() { return StdVideoH265PictureParameterSet.ninit_qp_minus26(address()); }
        /** @return the value of the {@code diff_cu_qp_delta_depth} field. */
        @NativeType("uint8_t")
        public byte diff_cu_qp_delta_depth() { return StdVideoH265PictureParameterSet.ndiff_cu_qp_delta_depth(address()); }
        /** @return the value of the {@code pps_cb_qp_offset} field. */
        @NativeType("int8_t")
        public byte pps_cb_qp_offset() { return StdVideoH265PictureParameterSet.npps_cb_qp_offset(address()); }
        /** @return the value of the {@code pps_cr_qp_offset} field. */
        @NativeType("int8_t")
        public byte pps_cr_qp_offset() { return StdVideoH265PictureParameterSet.npps_cr_qp_offset(address()); }
        /** @return the value of the {@code pps_beta_offset_div2} field. */
        @NativeType("int8_t")
        public byte pps_beta_offset_div2() { return StdVideoH265PictureParameterSet.npps_beta_offset_div2(address()); }
        /** @return the value of the {@code pps_tc_offset_div2} field. */
        @NativeType("int8_t")
        public byte pps_tc_offset_div2() { return StdVideoH265PictureParameterSet.npps_tc_offset_div2(address()); }
        /** @return the value of the {@code log2_parallel_merge_level_minus2} field. */
        @NativeType("uint8_t")
        public byte log2_parallel_merge_level_minus2() { return StdVideoH265PictureParameterSet.nlog2_parallel_merge_level_minus2(address()); }
        /** @return the value of the {@link StdVideoH265PictureParameterSet#log2_max_transform_skip_block_size_minus2} field. */
        @NativeType("uint8_t")
        public byte log2_max_transform_skip_block_size_minus2() { return StdVideoH265PictureParameterSet.nlog2_max_transform_skip_block_size_minus2(address()); }
        /** @return the value of the {@code diff_cu_chroma_qp_offset_depth} field. */
        @NativeType("uint8_t")
        public byte diff_cu_chroma_qp_offset_depth() { return StdVideoH265PictureParameterSet.ndiff_cu_chroma_qp_offset_depth(address()); }
        /** @return the value of the {@code chroma_qp_offset_list_len_minus1} field. */
        @NativeType("uint8_t")
        public byte chroma_qp_offset_list_len_minus1() { return StdVideoH265PictureParameterSet.nchroma_qp_offset_list_len_minus1(address()); }
        /** @return a {@link ByteBuffer} view of the {@code cb_qp_offset_list} field. */
        @NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]")
        public ByteBuffer cb_qp_offset_list() { return StdVideoH265PictureParameterSet.ncb_qp_offset_list(address()); }
        /** @return the value at the specified index of the {@code cb_qp_offset_list} field. */
        @NativeType("int8_t")
        public byte cb_qp_offset_list(int index) { return StdVideoH265PictureParameterSet.ncb_qp_offset_list(address(), index); }
        /** @return a {@link ByteBuffer} view of the {@code cr_qp_offset_list} field. */
        @NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]")
        public ByteBuffer cr_qp_offset_list() { return StdVideoH265PictureParameterSet.ncr_qp_offset_list(address()); }
        /** @return the value at the specified index of the {@code cr_qp_offset_list} field. */
        @NativeType("int8_t")
        public byte cr_qp_offset_list(int index) { return StdVideoH265PictureParameterSet.ncr_qp_offset_list(address(), index); }
        /** @return the value of the {@code log2_sao_offset_scale_luma} field. */
        @NativeType("uint8_t")
        public byte log2_sao_offset_scale_luma() { return StdVideoH265PictureParameterSet.nlog2_sao_offset_scale_luma(address()); }
        /** @return the value of the {@code log2_sao_offset_scale_chroma} field. */
        @NativeType("uint8_t")
        public byte log2_sao_offset_scale_chroma() { return StdVideoH265PictureParameterSet.nlog2_sao_offset_scale_chroma(address()); }
        /** @return the value of the {@link StdVideoH265PictureParameterSet#pps_act_y_qp_offset_plus5} field. */
        @NativeType("int8_t")
        public byte pps_act_y_qp_offset_plus5() { return StdVideoH265PictureParameterSet.npps_act_y_qp_offset_plus5(address()); }
        /** @return the value of the {@code pps_act_cb_qp_offset_plus5} field. */
        @NativeType("int8_t")
        public byte pps_act_cb_qp_offset_plus5() { return StdVideoH265PictureParameterSet.npps_act_cb_qp_offset_plus5(address()); }
        /** @return the value of the {@code pps_act_cr_qp_offset_plus3} field. */
        @NativeType("int8_t")
        public byte pps_act_cr_qp_offset_plus3() { return StdVideoH265PictureParameterSet.npps_act_cr_qp_offset_plus3(address()); }
        /** @return the value of the {@code pps_num_palette_predictor_initializers} field. */
        @NativeType("uint8_t")
        public byte pps_num_palette_predictor_initializers() { return StdVideoH265PictureParameterSet.npps_num_palette_predictor_initializers(address()); }
        /** @return the value of the {@code luma_bit_depth_entry_minus8} field. */
        @NativeType("uint8_t")
        public byte luma_bit_depth_entry_minus8() { return StdVideoH265PictureParameterSet.nluma_bit_depth_entry_minus8(address()); }
        /** @return the value of the {@code chroma_bit_depth_entry_minus8} field. */
        @NativeType("uint8_t")
        public byte chroma_bit_depth_entry_minus8() { return StdVideoH265PictureParameterSet.nchroma_bit_depth_entry_minus8(address()); }
        /** @return the value of the {@code num_tile_columns_minus1} field. */
        @NativeType("uint8_t")
        public byte num_tile_columns_minus1() { return StdVideoH265PictureParameterSet.nnum_tile_columns_minus1(address()); }
        /** @return the value of the {@code num_tile_rows_minus1} field. */
        @NativeType("uint8_t")
        public byte num_tile_rows_minus1() { return StdVideoH265PictureParameterSet.nnum_tile_rows_minus1(address()); }
        /** @return a {@link ShortBuffer} view of the {@code column_width_minus1} field. */
        @NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]")
        public ShortBuffer column_width_minus1() { return StdVideoH265PictureParameterSet.ncolumn_width_minus1(address()); }
        /** @return the value at the specified index of the {@code column_width_minus1} field. */
        @NativeType("uint16_t")
        public short column_width_minus1(int index) { return StdVideoH265PictureParameterSet.ncolumn_width_minus1(address(), index); }
        /** @return a {@link ShortBuffer} view of the {@code row_height_minus1} field. */
        @NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]")
        public ShortBuffer row_height_minus1() { return StdVideoH265PictureParameterSet.nrow_height_minus1(address()); }
        /** @return the value at the specified index of the {@code row_height_minus1} field. */
        @NativeType("uint16_t")
        public short row_height_minus1(int index) { return StdVideoH265PictureParameterSet.nrow_height_minus1(address(), index); }
        /** @return a {@link StdVideoH265ScalingLists} view of the struct pointed to by the {@link StdVideoH265PictureParameterSet#pScalingLists} field. */
        @NativeType("StdVideoH265ScalingLists const *")
        public StdVideoH265ScalingLists pScalingLists() { return StdVideoH265PictureParameterSet.npScalingLists(address()); }
        /** @return a {@link StdVideoH265PredictorPaletteEntries} view of the struct pointed to by the {@link StdVideoH265PictureParameterSet#pPredictorPaletteEntries} field. */
        @NativeType("StdVideoH265PredictorPaletteEntries const *")
        public StdVideoH265PredictorPaletteEntries pPredictorPaletteEntries() { return StdVideoH265PictureParameterSet.npPredictorPaletteEntries(address()); }

        /** Copies the specified {@link StdVideoH265PpsFlags} to the {@code flags} field. */
        public StdVideoH265PictureParameterSet.Buffer flags(StdVideoH265PpsFlags value) { StdVideoH265PictureParameterSet.nflags(address(), value); return this; }
        /** Passes the {@code flags} field to the specified {@link java.util.function.Consumer Consumer}. */
        public StdVideoH265PictureParameterSet.Buffer flags(java.util.function.Consumer<StdVideoH265PpsFlags> consumer) { consumer.accept(flags()); return this; }
        /** Sets the specified value to the {@code pps_pic_parameter_set_id} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_pic_parameter_set_id(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.npps_pic_parameter_set_id(address(), value); return this; }
        /** Sets the specified value to the {@code pps_seq_parameter_set_id} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_seq_parameter_set_id(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.npps_seq_parameter_set_id(address(), value); return this; }
        /** Sets the specified value to the {@code sps_video_parameter_set_id} field. */
        public StdVideoH265PictureParameterSet.Buffer sps_video_parameter_set_id(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nsps_video_parameter_set_id(address(), value); return this; }
        /** Sets the specified value to the {@code num_extra_slice_header_bits} field. */
        public StdVideoH265PictureParameterSet.Buffer num_extra_slice_header_bits(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nnum_extra_slice_header_bits(address(), value); return this; }
        /** Sets the specified value to the {@code num_ref_idx_l0_default_active_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer num_ref_idx_l0_default_active_minus1(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nnum_ref_idx_l0_default_active_minus1(address(), value); return this; }
        /** Sets the specified value to the {@code num_ref_idx_l1_default_active_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer num_ref_idx_l1_default_active_minus1(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nnum_ref_idx_l1_default_active_minus1(address(), value); return this; }
        /** Sets the specified value to the {@code init_qp_minus26} field. */
        public StdVideoH265PictureParameterSet.Buffer init_qp_minus26(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.ninit_qp_minus26(address(), value); return this; }
        /** Sets the specified value to the {@code diff_cu_qp_delta_depth} field. */
        public StdVideoH265PictureParameterSet.Buffer diff_cu_qp_delta_depth(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.ndiff_cu_qp_delta_depth(address(), value); return this; }
        /** Sets the specified value to the {@code pps_cb_qp_offset} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_cb_qp_offset(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.npps_cb_qp_offset(address(), value); return this; }
        /** Sets the specified value to the {@code pps_cr_qp_offset} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_cr_qp_offset(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.npps_cr_qp_offset(address(), value); return this; }
        /** Sets the specified value to the {@code pps_beta_offset_div2} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_beta_offset_div2(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.npps_beta_offset_div2(address(), value); return this; }
        /** Sets the specified value to the {@code pps_tc_offset_div2} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_tc_offset_div2(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.npps_tc_offset_div2(address(), value); return this; }
        /** Sets the specified value to the {@code log2_parallel_merge_level_minus2} field. */
        public StdVideoH265PictureParameterSet.Buffer log2_parallel_merge_level_minus2(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nlog2_parallel_merge_level_minus2(address(), value); return this; }
        /** Sets the specified value to the {@link StdVideoH265PictureParameterSet#log2_max_transform_skip_block_size_minus2} field. */
        public StdVideoH265PictureParameterSet.Buffer log2_max_transform_skip_block_size_minus2(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nlog2_max_transform_skip_block_size_minus2(address(), value); return this; }
        /** Sets the specified value to the {@code diff_cu_chroma_qp_offset_depth} field. */
        public StdVideoH265PictureParameterSet.Buffer diff_cu_chroma_qp_offset_depth(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.ndiff_cu_chroma_qp_offset_depth(address(), value); return this; }
        /** Sets the specified value to the {@code chroma_qp_offset_list_len_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer chroma_qp_offset_list_len_minus1(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nchroma_qp_offset_list_len_minus1(address(), value); return this; }
        /** Copies the specified {@link ByteBuffer} to the {@code cb_qp_offset_list} field. */
        public StdVideoH265PictureParameterSet.Buffer cb_qp_offset_list(@NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]") ByteBuffer value) { StdVideoH265PictureParameterSet.ncb_qp_offset_list(address(), value); return this; }
        /** Sets the specified value at the specified index of the {@code cb_qp_offset_list} field. */
        public StdVideoH265PictureParameterSet.Buffer cb_qp_offset_list(int index, @NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.ncb_qp_offset_list(address(), index, value); return this; }
        /** Copies the specified {@link ByteBuffer} to the {@code cr_qp_offset_list} field. */
        public StdVideoH265PictureParameterSet.Buffer cr_qp_offset_list(@NativeType("int8_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]") ByteBuffer value) { StdVideoH265PictureParameterSet.ncr_qp_offset_list(address(), value); return this; }
        /** Sets the specified value at the specified index of the {@code cr_qp_offset_list} field. */
        public StdVideoH265PictureParameterSet.Buffer cr_qp_offset_list(int index, @NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.ncr_qp_offset_list(address(), index, value); return this; }
        /** Sets the specified value to the {@code log2_sao_offset_scale_luma} field. */
        public StdVideoH265PictureParameterSet.Buffer log2_sao_offset_scale_luma(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nlog2_sao_offset_scale_luma(address(), value); return this; }
        /** Sets the specified value to the {@code log2_sao_offset_scale_chroma} field. */
        public StdVideoH265PictureParameterSet.Buffer log2_sao_offset_scale_chroma(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nlog2_sao_offset_scale_chroma(address(), value); return this; }
        /** Sets the specified value to the {@link StdVideoH265PictureParameterSet#pps_act_y_qp_offset_plus5} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_act_y_qp_offset_plus5(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.npps_act_y_qp_offset_plus5(address(), value); return this; }
        /** Sets the specified value to the {@code pps_act_cb_qp_offset_plus5} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_act_cb_qp_offset_plus5(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.npps_act_cb_qp_offset_plus5(address(), value); return this; }
        /** Sets the specified value to the {@code pps_act_cr_qp_offset_plus3} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_act_cr_qp_offset_plus3(@NativeType("int8_t") byte value) { StdVideoH265PictureParameterSet.npps_act_cr_qp_offset_plus3(address(), value); return this; }
        /** Sets the specified value to the {@code pps_num_palette_predictor_initializers} field. */
        public StdVideoH265PictureParameterSet.Buffer pps_num_palette_predictor_initializers(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.npps_num_palette_predictor_initializers(address(), value); return this; }
        /** Sets the specified value to the {@code luma_bit_depth_entry_minus8} field. */
        public StdVideoH265PictureParameterSet.Buffer luma_bit_depth_entry_minus8(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nluma_bit_depth_entry_minus8(address(), value); return this; }
        /** Sets the specified value to the {@code chroma_bit_depth_entry_minus8} field. */
        public StdVideoH265PictureParameterSet.Buffer chroma_bit_depth_entry_minus8(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nchroma_bit_depth_entry_minus8(address(), value); return this; }
        /** Sets the specified value to the {@code num_tile_columns_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer num_tile_columns_minus1(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nnum_tile_columns_minus1(address(), value); return this; }
        /** Sets the specified value to the {@code num_tile_rows_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer num_tile_rows_minus1(@NativeType("uint8_t") byte value) { StdVideoH265PictureParameterSet.nnum_tile_rows_minus1(address(), value); return this; }
        /** Copies the specified {@link ShortBuffer} to the {@code column_width_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer column_width_minus1(@NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]") ShortBuffer value) { StdVideoH265PictureParameterSet.ncolumn_width_minus1(address(), value); return this; }
        /** Sets the specified value at the specified index of the {@code column_width_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer column_width_minus1(int index, @NativeType("uint16_t") short value) { StdVideoH265PictureParameterSet.ncolumn_width_minus1(address(), index, value); return this; }
        /** Copies the specified {@link ShortBuffer} to the {@code row_height_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer row_height_minus1(@NativeType("uint16_t[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]") ShortBuffer value) { StdVideoH265PictureParameterSet.nrow_height_minus1(address(), value); return this; }
        /** Sets the specified value at the specified index of the {@code row_height_minus1} field. */
        public StdVideoH265PictureParameterSet.Buffer row_height_minus1(int index, @NativeType("uint16_t") short value) { StdVideoH265PictureParameterSet.nrow_height_minus1(address(), index, value); return this; }
        /** Sets the address of the specified {@link StdVideoH265ScalingLists} to the {@link StdVideoH265PictureParameterSet#pScalingLists} field. */
        public StdVideoH265PictureParameterSet.Buffer pScalingLists(@NativeType("StdVideoH265ScalingLists const *") StdVideoH265ScalingLists value) { StdVideoH265PictureParameterSet.npScalingLists(address(), value); return this; }
        /** Sets the address of the specified {@link StdVideoH265PredictorPaletteEntries} to the {@link StdVideoH265PictureParameterSet#pPredictorPaletteEntries} field. */
        public StdVideoH265PictureParameterSet.Buffer pPredictorPaletteEntries(@NativeType("StdVideoH265PredictorPaletteEntries const *") StdVideoH265PredictorPaletteEntries value) { StdVideoH265PictureParameterSet.npPredictorPaletteEntries(address(), value); return this; }

    }

}

redpajama_set_name: RedPajamaGithub


text:
El Ral·li de la Costa Esmerlada (en italià Rally Costa Smeralda) és una prova de ral·li que es disputa des de 1978 a l'illa de Sardenya, concretament a la zona de la Costa Esmeralda.

És una prova del Campionat d'Itàlia de Ral·lis i va ser puntuable pel Campionat d'Europa de Ral·lis entre 1982 i 1994, així com el 2002 i el 2003. L'any 1993 va ser cancel·lat i no es va disputar els anys 1995, 1996 i 1997.

Des del 2013 disputa molts trams de forma idèntica al Ral·li de Sardenya del Campionat Mundial de Ral·lis.

El pilot amb major nombre de victòries és Paolo Andreucci amb set, no obstant, en el palmarès de la prova hi trobem diferents campions mundials com Markku Alén, Miki Biasion, Juha Kankkunen o Didier Auriol.

Palmarès

Ral·lis del Campionat d'Europa de Ral·lis
Esport a Sardenya
Competicions d'automobilisme a Itàlia

redpajama_set_name: RedPajamaWikipedia


Many online merchants view online advertising as a necessity to get exposure for their listings, and Amazon has just scratched the surface when it comes to monetizing its ad inventory, according to Wall Street firm Cowen and Company.
But sellers are finding advertising rates increase as brands are spending more on Amazon ads compared to prior years when it was predominantly private label sellers, according to Cowen analyst John Blackledge.
He said he's hearing from former Amazon employees that its ad business is still in the third inning and that Amazon is hiring in the advertising area.
Some stats he published in a new Cowen report: Sponsored products CPCs are rising 25-50% year-over-year depending on the vertical, while traffic is growing 30% year-over-year.
He estimates Amazon ad revenue will rise at a 37% compound annual growth rate through 2023.
The report comes at a time when there has been much talk of Amazon's potential to disrupt online advertising and how this could impact Google and Facebook. A January Wall Street Journal article said Amazon's ad business could threaten those rivals and noted that Amazon has valuable data its tech competitors can't access: its own sales.
In a pay-to-play environment, advertising is just another way it's getting tougher for small sellers to compete with large retailers and brands, making it crucial to be smart with marketing dollars.


Falcons News · Apr 1 And the Clackamas Square Dental Group Athlete of the Month is….
Falcons News · Nov 6 Oregon Top Plays Week 10: TD's, Spikes, and Saves — Which School had the Best?
Falcons News · Oct 30 Oregon Top Plays Week 9: Will a New School Unseat Clackamas for Reigning Top Play Champ?
Time to recognize the Clackamas Square Dental Group March Athletes of the month… Female Winner: Softball player for the Milwaukie Mustangs , Cecelia Kamhoot Congratulation to Cecelia who is a highly committed student and athlete with excellent energy and hustle. She is a vocal leader on the field who has invested in the program and its younger players.


Getting a Raw Meal: Is an Exclusive Diet of Uncooked Food Good for Personal–and Planetary–Health?
Ever heard of toxic overload? This happens to our kidneys if we eat meat on a daily basis- because animal protein, especially denatured protein (through heating) is the cause of kidney failure- just one example.
Congratulations to Scientific American for broaching the Raw Food Nutrition as an alternative to Conventional Cooked Foodism!
In a world where the majority of our species are literally mal-nourished, due to our unscientific food habits, it is high time a science journal like Scientific American bite the bullet and point out that there ARE alternatives to eating heat-damaged, condensed food processed by Food Inc.!
There is a plethora of scientific evidence to prove that the more raw plant food we eat, the better we can avoid degenerative diseases.
1. Wouldn't it more reasonable to help diabetes sufferers with a more natural, i.e., not toxic, diet, which can actually cure them in many cases?
After all, it's the wrong fuel ( glucose concentrates) in the first place that our body was never meant to have to metabolize, and that's causing the tissue damage!
Put sugar in the fuel tank of your car, and then watch what happens!
The two deficient enzymes mentioned in the article are products of genes being read and proteins being synthesized. I am not aware of any dietary changes that diabetics could make that would improve this type of protein systhesis. Sunnystrobe do you have something specific in mind regarding diet? I am interested in any information you might have to offer.
Dietary changes are the only remedy to tackle the epidemic increase of diabetes, since the problem that's causing it is clearly our nutritionally deficient feeding habits, mainly caused by our profit-biassed 'food' industry, with sugar-baited, animal-fat-laced, and salt-laden 'fast' food monstrosities that may taste 'moreish', but, through their energy concentration, are un-natural, but all the more highly addictive to our body system which can easily get out of sync at a cellular level, because the enzyme system gets overstressed with this synthezised 'Frankenstein food'.
We happen to be the only mammals that invented 99% fatty foods like oil, margarine, butter, that, alas, lack the living fatty acids; we have increased our sugar intake a hundredfold -and with it our diabetes!- and we can claim that we alone invented 'combustion' ( which denatures proteins, depletes vitamins, and destroys living enzyme/co-enzyme proteins through massive heat damage.
How much more blithely ignorant can we get?
I am particularly astounded how many medical specialists & researchers appear to turn a blind eye to their own blatant case of mal-(='bad') nutrition, all in favour of finding a new pill as a magic bullet.
Yet it has been known for many decades now that a diet of enzyme-rich raw plant foods can prevent and/or reverse not only diabetes, but also cancers and heart disease, and arthritis, and osteoporosis, etc, etc.
I personally have met people who managed this 'self-cure' through simple diet changes, and compiled my own findings into a health almanac, after having run workshops at local community level, from which evolved the Y.AN.C.H.E.P. DI.E.T., as an easy, but species-specific nutrition alternative, fit for mankind and kind to women, because it minimizes cooking and favours salad days!
It deals with optimal food choices from a grassroot approach.
I would like to welcome you at our interactive www.Youthevity.com, or The Yanchep Diet, via Google.
A new study says high sodium and low potassium intake are the twin culprits in many cardiovascular syndromes.
1. It is commonly forgotten that a plant-based diet, containing plenty of raw vegetables and fruits, is the ideal, and completely natural, potassium source for human nutrition. Plants also provide sufficient sodium ( e.g. celery ). Cooked foods, however, have deficient mineral content, due to them leaching out into water.
We are the only creatures on this planet to have invented cooking- with poor health resulting from this heat damage.Cookbooks are a health hazard, and cooks are food arsonists par excellence!
How did those intestinal worms get into the system? From a pig's guts, we can inherit a reach-me-down tapeworm….The worm's in the animal feed! No such problem for a vegetarian!
They have wormed themselves wilily through all our evolutionary past, pepping up our immune system.
A nightcap may force the body to work harder at repair during sleep, making for a less restful night.
It makes sense because our bodies interprets alcohol like venom and gives priority to eliminate it.
Yes, alcohol is plain ethanol, i.e. fermented sugar, a nerve poison,which makes our inbuilt bio-lab called 'liver' automatically work all hours, if need be, to detoxify this toxic input..
Could you imagine any other chimps treating themselves to 'nightcaps' before tucking in?
Lord Stern, who authored the UK report "The Economics of Climate Change" in 2006 and has long been a climate change stalwart in that country, is upset about the coverage his latest remarks have received.
The Times is running a story under the headline "Climate chief Lord Stern: give up meat to save the planet" . Stern was interviewed by the Times and said some things about meat that those pesky reporters decided was the best quote going, and slapped on their front page. "Meat is a wasteful use of water and creates a lot of greenhouse gases," he says. In future people will treat eating meat differently, more like smoking or drinking, the article continues. And of course, the point has been picked up in the Brit press (Evening Standard, Spectator, Telegraph).
Meat consumption is wasteful of resources including water, land, and secondary considerations like the increased medical costs associated with a meat-based diet. We'd all be better off giving it up!
There are entire cultures representing millions of people who have lived and thrived for centuries without meat, which is enough evidence that humans do not "need" it to satisy their taste buds or to survive and thrive.
In fact, the evidence weighs heavily in the other direction: the hazards of a meat and dairy diet and the benefits of a vegan diet are well known in the medical and scientific community. Health, animal cruelty, and environmental issues could be alleviated if everyone ate a vegan diet.
* U.N. scientists have determined that raising animals for food generates more greenhouse-gas emissions than all the cars, SUVs, trucks, and planes in the world combined.
* Researchers at the University of Chicago determined that switching to a vegan diet is more effective in countering climate change than switching from a standard car to a Toyota Prius.
* According to Environmental Defense, if every American substituted vegetarian foods for chicken at just one meal per week, the carbon dioxide savings would be the same as taking more than a half-million cars off U.S. roads.
And it's just plain barbaric to breed, confine, and slaughter animals for food. Go vegan for health, for animals, and for the environment!
Thanks for this post. I used to eat red meat many times a week. Not only do I get tired easily and feel depressed, I also feel very heavy. I hate stairs, I don't like long walk and most especially I don't run. Somebody advised me to change my eating habit. It was not easy, but I did it anyways. I now eat white meat, more veggies and fruits and lots of drinking water. And then, there was a change, I'm happy, I'm smaller, I can go through the stairs, though I still prefer the elevator if there's any, I can run and I can do long walk. Most of all, I'm healthier. I'm doing this for my health and not for global warming. And if I am contributing to save the earth, then the more I should eat veggies.


Kathryn Przybyla in the Barclays Center during the Dec. 10, 2015 game against the Philadelphia 76ers. Photographs by Brendan Awerbuch.
For Kathryn Przybyla, a 15-hour workday without breaks is business as usual. "Kat" Przybyla (BA '11) at the age of 26, is in her third season as the social media coordinator for the Nets and Barclays Center.
A typical workday begins at 8 a.m., when Przybyla catches up on news and the team's social media feeds, and then posts @BrooklynNets' first tweet of the day: "Beautiful day for a game. #Nets look to start win streak vs. #Sixers." She relies on her iPhone almost exclusively to post content. "I try to hit the morning commute crowd," she says.
A big part of Przybyla's job is to give fans an inside look: images and information that they can't get anywhere else. She arrives at the arena an hour before "shootaround," the NBA term for practice on game days. "I take photos, post sound bites from the players about tonight's game—anything cool about the matchup," she says.
If a fan posts something interesting, she'll respond. "I'm really big on interactions with fans. It's a conversation with our base. If fans are hyped about something, I'll retweet that." After practice ends, she grabs lunch, but still posts content—there's no break on game day.
In 2009, as a sophomore communications major at UB, she signed up for her first Twitter account. "I tried to teach myself as much as possible on my own," she says. Later, she took an advertising class taught by Marc Adler (MA '83, MBA '82, BA '79) in which students were required to have a Twitter account and to submit homework via tweets and using hashtags."Just using the medium was a great start. I never realized that it would be a major part of my career," she says.
The following year, she applied for an internship at CNN's "The Situation Room with Wolf Blitzer." She had introduced herself to Blitzer (BA '70) at a university awards ceremony. He was receiving a Distinguished Alumni Award and Przybyla a J. Scott Fleming Scholarship from the UB Future Alumni Network. She told the news anchor that she followed him on Twitter. Blitzer encouraged her to apply for CNN's internship program. She did, and the next summer ended up working for one of the show's on-air correspondents in New York City—transcribing interviews, helping with on-location shoots, cutting background video for the web and on-air packages. It was her first time living away from home. "I fell in love with the city. And big media," she says.
Excerpted from At Buffalo magazine. Read the full article.
In October 2015, Przybyla took over our Twitter account to answer questions about social media, the Brooklyn Nets, and her experiences at UB. Read the recap of the talk below.
You can follow the Brooklyn Nets and the Barclays Center on Twitter.
And follow the UB Alumni Association too!


text:
// Generated by CoffeeScript 1.9.0
var APISchema, RenderableSchema,
  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  __hasProp = {}.hasOwnProperty;

RenderableSchema = require('./RenderableSchema');

APISchema = (function(_super) {
  __extends(APISchema, _super);

  function APISchema() {
    this.__template = "/*\n * <%=name%>.js\n * Schema Generated by API-Hero\n * Add custom Schema Validators, Types and Methods below\n */\nmodule.exports = function(<%=name%>) {\n\n};";
    APISchema.__super__.constructor.apply(this, arguments);
  }

  return APISchema;

})(RenderableSchema);

module.exports = APISchema;


This one's a sheer delight. Flora + fauna never looked so good. The Gracia Floral Mock Neck Top features a high neckline, cap sleeves, an invisible back zipper closure, sheer front and a solid back. Unlined. Pair this see-through top with a bandaged mini, lace bralette & lace up pumps.


text:
FX Risk Management
Client Concentration
Sector Split
Top 20 Clients
Being Alpha
Development Style
We are Alpha – a company where people and technology come together to deliver powerful currency management solutions for some of the world's most respected organisations.
CLICK HERE FOR AN INTRODUCTION TO WHAT WE DO
Making an impact.
As specialists, we don't work with everyone and are honest about where our value lies.
But if we do, we're sure to make an impact.
Currency Risk Management Payments and Collections
The elephant in the room.
There is no shortage of advice or opinions on where exchange rates are going. However, for those responsible for deciding how to manage their currency exposures, the elephant in the room is obvious: in the long-term, nobody can reliably predict the currency market.
Despite this, currency purchasing decisions are still frequently based on a 'best guess' and therefore companies remain materially vulnerable to currency risk.
A balancing act.
At Alpha, we solve the problem of unpredictable exchange rates by developing strategies to balance the three major variables you have to consider when hedging: How much? How far forward? And when?
In doing so, we help you find the balance between being over and under hedged, and give you greater control over the impact exchange rate volatility has on your objectives and commercial landscape.
Making sense of it all.
With a strategy in place, many clients will have an element of discretion over when they buy currency. Whilst evidence shows us that long-term market predictions are inconsistent at best, we recognise that opportunities do exist within short time frames and it's possible to capitalise on these to optimise returns.
To do this, our dedicated analysts provide tailored and proactive insights, guiding market entry up to three months into the future.
Well-executed.
We provide a range of products for executing your strategy, focused on maximising hedge effectiveness whilst minimising hedging costs. Indeed, we work with a number of clients who do not require our consultancy services, but still choose us based on the effectiveness and competitiveness of our execution capabilities alone.
View our execution capabilities
It's easier said than done.
When it comes to payments and collections, every business wants to reduce manual processes and unlock new efficiencies.
However, existing solutions are often high maintenance, unreliable and take significant time and resource to setup.
Uniquely positioned.
Whilst new FinTechs offer attractive levels of innovation, many lack a track record that businesses can trust.
This is where Alpha differs. As an established financial technology provider listed on the London Stock Exchange, we're able to ensure that the cutting-edge solutions we provide are underpinned by robust levels of governance, a strong balance sheet, and a truly global banking infrastructure. It's the best of both worlds.
Well-connected.
With the ability to send and receive payments in 160 currencies and open accounts in multiple countries, Alpha is enabling businesses to transact locally on a truly global scale.
By plugging this network into our cutting-edge platform, built free from legacy, we've made transacting globally simple, fast and cost-effective.
Accounts Payments CoLLECTIONS
Regulatory Info

redpajama_set_name: RedPajamaCommonCrawl


text:
Making extractive industries audit reports publicly accessible.
By Gilbert Makore. Supreme Audit Institutions as Custodians of Finite Extractive Resources. Mining, oil and gas resources have the potential to significantly contribute to countries' socio-economic development. Socio-economic benefits stream in through taxes, a share of the revenues and economic...
Operational levies affecting Rebecca's business
Programme Information The informal sector in Kenya plays a significant role in the economy and is said to account for close to 50% of GDP. The Government of Kenya has been seeking ways to broaden the tax base and consequently net in those operating in the informal economy. However, there are still...
Cess strains Martha's business
Programme Information The informal sector in Kenya plays a significant role in the economy and is said to account for close to 50% of GDP. The Government of Kenya has been seeking ways to broaden the tax base and consequently net in those operating in the informal economy.However, there are still...
How increase in cess has affected Coletta's business
Peris the Entrepreneur: A voice for accountability in Kibra
Oxfam and partners, SITE Enterprise Promotion and NOPE Institute through funding from the EU implemented a women rights project aimed at;promoting the livelihoods,social inclusion of vulnerable female domestic workers and female small-scale traders. Also enhanced the social-economic empowerment of...
Oxfam delivers rapid response in emergencies
"This rain was too much, the worst I have seen in the last 10 seasons," Mariam Nabura recounts. "We were caught unawares by the floods in the middle of the night, at times we would receive the warning information but the floods don't come. But this time round, right after we received an alert about...
A Vaccine at a time: Strengthening the resilience and livelihoods of the people of Marsabit County
I started tending to my father's herd of cattle when I was only 10 years old. I would be sent out to look for pasture in the fields and then come back in the evening when the animals had enough to eat and drink. Back then, we would move from one area to another with our livestock in search of...
They saved our animals, story of Halkano a pastoralist from Marsabit County
The year 2015 was particularly dry and we were forced to move our Satellite herds to Huri Hills where there was pasture, leaving behind only a few animals for our families to get milk. One morning as I was walking to the pen to release the animals for grazing, I noticed that two cattle looked dull...
Innovation for increased water access in Wajir
Oxfam piloted the use of electronic water meters commonly known us water ATMs in Wajir County in 2014-2015. The county government of Wajir through WAJWASCO is collaborating with World Vision to scale up the technology to other water utilities within the county.
Story topics